Latihan kernel kuantum

Anggaran penggunaan: kurang dari satu minit pada pemproses Eagle r3 (NOTA: Ini adalah anggaran sahaja. Masa jalan sebenar anda mungkin berbeza.)

Latar belakang

Tutorial ini menunjukkan cara membina Qiskit pattern untuk menilai entri dalam matriks kernel kuantum yang digunakan untuk pengelasan binari. Untuk maklumat lanjut tentang Qiskit patterns dan cara Qiskit Serverless boleh digunakan untuk menggunakannya ke awan bagi pelaksanaan terurus, lawati halaman dokumentasi kami tentang IBM Quantum® Platform.

Keperluan

Sebelum memulakan tutorial ini, pastikan anda telah memasang perkara berikut:

• Qiskit SDK v1.0 atau lebih baharu, dengan sokongan visualization
• Qiskit Runtime v0.22 atau lebih baharu (pip install qiskit-ibm-runtime)

Persediaan

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy pandas qiskit qiskit-ibm-catalog qiskit-ibm-runtime

!wget https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv

# General Imports and helper functions

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.circuit.library import UnitaryOverlap
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

# from qiskit_serverless import IBMServerlessClient, QiskitFunction
from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

def visualize_counts(res_counts, num_qubits, num_shots):
    """Visualize the outputs from the Qiskit Sampler primitive."""
    zero_prob = res_counts.get(0, 0.0)
    top_10 = dict(
        sorted(res_counts.items(), key=lambda item: item[1], reverse=True)[
            :10
        ]
    )
    top_10.update({0: zero_prob})
    by_key = dict(sorted(top_10.items(), key=lambda item: item[0]))
    x_vals, y_vals = list(zip(*by_key.items()))
    x_vals = [bin(x_val)[2:].zfill(num_qubits) for x_val in x_vals]
    y_vals_prob = []
    for t in range(len(y_vals)):
        y_vals_prob.append(y_vals[t] / num_shots)
    y_vals = y_vals_prob
    plt.bar(x_vals, y_vals)
    plt.xticks(rotation=75)
    plt.title("Results of sampling")
    plt.xlabel("Measured bitstring")
    plt.ylabel("Probability")
    plt.show()

def get_training_data():
    """Read the training data."""
    df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)
    training_data = df.values[:20, :]
    ind = np.argsort(training_data[:, -1])
    X_train = training_data[ind][:, :-1]

    return X_train

7[Files: 0  Bytes: 0  [0 B/s] Re]87[https://raw.githubusercontent.]87Saving 'dataset_graph7.csv.1'
87dataset_graph7.csv.1 100% [=============================>]   20.25K    --.-KB/s87HTTP response 200  [https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv]
87dataset_graph7.csv.1 100% [=============================>]   20.25K    --.-KB/s87[Files: 1  Bytes: 20.25K [93.33]8

Langkah 1: Petakan input klasik kepada masalah kuantum

• Input: Dataset latihan.
• Output: Circuit abstrak untuk mengira entri matriks kernel.

Buat Circuit kuantum yang digunakan untuk menilai satu entri dalam matriks kernel. Kita gunakan data input untuk menentukan sudut putaran bagi gate-gate berparameter dalam Circuit. Kita akan gunakan sampel data x1=14 dan x2=19.

Nota: Dataset yang digunakan dalam tutorial ini boleh dimuat turun di sini.

# Prepare training data
X_train = get_training_data()

# Empty kernel matrix
num_samples = np.shape(X_train)[0]
kernel_matrix = np.full((num_samples, num_samples), np.nan)

# Prepare feature map for computing overlap
num_features = np.shape(X_train)[1]
num_qubits = int(num_features / 2)
entangler_map = [[0, 2], [3, 4], [2, 5], [1, 4], [2, 3], [4, 6]]
fm = QuantumCircuit(num_qubits)
training_param = Parameter("θ")
feature_params = ParameterVector("x", num_qubits * 2)
fm.ry(training_param, fm.qubits)
for cz in entangler_map:
    fm.cz(cz[0], cz[1])
for i in range(num_qubits):
    fm.rz(-2 * feature_params[2 * i + 1], i)
    fm.rx(-2 * feature_params[2 * i], i)

# Assign tunable parameter to known optimal value and set the data params for first two samples
x1 = 14
x2 = 19
unitary1 = fm.assign_parameters(list(X_train[x1]) + [np.pi / 2])
unitary2 = fm.assign_parameters(list(X_train[x2]) + [np.pi / 2])

# Create the overlap circuit
overlap_circ = UnitaryOverlap(unitary1, unitary2)
overlap_circ.measure_all()
overlap_circ.draw("mpl", scale=0.6, style="iqp")

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

• Input: Circuit abstrak, belum dioptimumkan untuk Backend tertentu
• Output: Circuit sasaran dan boleh cerap, dioptimumkan untuk QPU yang dipilih

Gunakan fungsi generate_preset_pass_manager dari Qiskit untuk menentukan rutin pengoptimuman bagi Circuit kita berkenaan QPU yang kita rancang untuk menjalankan eksperimen. Kita tetapkan optimization_level=3, yang bermaksud kita akan menggunakan pengurus laluan praset yang memberikan tahap pengoptimuman tertinggi.

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=overlap_circ.num_qubits
)
pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
overlap_ibm = pm.run(overlap_circ)
overlap_ibm.draw("mpl", scale=0.6, idle_wires=False, fold=-1, style="iqp")

Langkah 3: Laksanakan menggunakan primitif Qiskit

• Input: Circuit sasaran
• Output: Taburan quasi-kebarangkalian

Gunakan primitif Sampler dari Qiskit Runtime untuk membina semula taburan quasi-kebarangkalian bagi keadaan yang dihasilkan daripada pensampelan Circuit. Untuk tugasan menjana matriks kernel, kita khususnya berminat dengan kebarangkalian mengukur keadaan |0>.

Untuk demo ini, kita akan jalankan pada QPU dengan primitif qiskit-ibm-runtime. Untuk menjalankan pada primitif berasaskan statevector qiskit, gantikan blok kod yang menggunakan primitif Qiskit IBM® Runtime dengan blok yang dikomentari.

num_shots = 10_000

## Evaluate the problem using statevector-based primitives from Qiskit
# from qiskit.primitives import StatevectorSampler

# sampler = StatevectorSampler()
# results = sampler.run([overlap_circ]).result()
# counts = results[0].data.meas.get_int_counts()

# Evaluate the problem using a QPU via Qiskit IBM Runtime

sampler = Sampler(mode=backend)
results = sampler.run([overlap_ibm]).result()
counts = results[0].data.meas.get_int_counts()

visualize_counts(counts, num_qubits, num_shots)

Langkah 4: Pasca-proses dan kembalikan keputusan dalam format klasik yang dikehendaki

• Input: Taburan kebarangkalian
• Output: Satu elemen matriks kernel

Kira kebarangkalian mengukur |0> pada Circuit tindihan, dan isi matriks kernel pada kedudukan yang sepadan dengan sampel yang diwakili oleh Circuit tindihan tertentu ini (baris 15, lajur 20). Dalam visualisasi ini, merah gelap menunjukkan kesetiaan yang lebih hampir kepada 1.0. Untuk melengkapkan keseluruhan matriks kernel, kita perlu menjalankan eksperimen kuantum untuk setiap entri.

# Calculate the fidelity, or the probability to measure 0
kernel_matrix[x1, x2] = counts.get(0, 0.0) / num_shots
print(f"Fidelity: {kernel_matrix[x1, x2]}")

Fidelity: 0.1279

Sebarkan corak Qiskit ke awan

Untuk melakukan ini, pindahkan kod sumber di atas ke satu fail, ./source/generate_kernel_entry.py, bungkus kod dalam skrip yang mengambil input dan mengembalikan penyelesaian akhir, dan akhirnya muat naik ke kluster jauh menggunakan kelas QiskitFunction dari Qiskit Serverless. Untuk panduan tentang menentukan kebergantungan luaran, menghantar argumen input, dan lain-lain, semak panduan Qiskit Serverless.

Input kepada Pattern ialah sepasang sampel data, x1 dan x2. Outputnya adalah kesetiaan antara dua sampel tersebut. Nilai ini akan digunakan untuk mengisi entri matriks kernel yang sepadan dengan kedua-dua sampel ini.

serverless = QiskitServerless()

kernel_entry_pattern = QiskitFunction(
    title="generate-kernel-entry",
    entrypoint="generate_kernel_entry.py",
    working_dir="./source/",
)

serverless.upload(kernel_entry_pattern)

Jalankan corak Qiskit sebagai perkhidmatan terurus

Setelah kita memuat naik corak ke awan, kita boleh menjalankannya dengan mudah menggunakan klien IBMServerlessProvider. Untuk kesederhanaan, kita akan menggunakan simulator kuantum tepat dalam persekitaran awan, jadi kesetiaan yang kita kira akan tepat.

generate_kernel_entry = serverless.load("generate-kernel-entry")
job = generate_kernel_entry.run(
    sample1=list(X_train[x1]), sample2=list(X_train[x2])
)

kernel_matrix[x1, x2] = job.result()["fidelity"]
print(f"fidelity: {kernel_matrix[x1, x2]}")

Kaji selidik tutorial

Sila ambil kaji selidik ringkas ini untuk memberikan maklum balas tentang tutorial ini. Pandangan anda akan membantu kami memperbaiki kandungan dan pengalaman pengguna kami.

Pautan ke kaji selidik

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.