Pelatihan kernel kuantum

Perkiraan penggunaan: kurang dari satu menit pada prosesor Eagle r3 (CATATAN: Ini hanya perkiraan. Waktu eksekusi Anda bisa berbeda.)

Latar Belakang

Tutorial ini menunjukkan cara membangun pola Qiskit untuk mengevaluasi entri dalam matriks kernel kuantum yang digunakan untuk klasifikasi biner. Untuk informasi lebih lanjut tentang pola Qiskit dan bagaimana Qiskit Serverless dapat digunakan untuk men-deploy-nya ke cloud untuk eksekusi yang dikelola, kunjungi halaman dokumentasi IBM Quantum® Platform.

Persyaratan

Sebelum memulai tutorial ini, pastikan kamu sudah menginstal hal-hal berikut:

• Qiskit SDK v1.0 atau lebih baru, dengan dukungan visualisasi
• Qiskit Runtime v0.22 atau lebih baru (pip install qiskit-ibm-runtime)

Pengaturan

# 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 klasikal ke masalah kuantum

• Input: Dataset pelatihan.
• Output: Circuit abstrak untuk menghitung entri matriks kernel.

Buat Circuit kuantum yang digunakan untuk mengevaluasi satu entri dalam matriks kernel. Kita gunakan data input untuk menentukan sudut rotasi bagi gate-gate terparameter pada Circuit. Kita akan menggunakan sampel data x1=14 dan x2=19.

Catatan: Dataset yang digunakan dalam tutorial ini dapat diunduh 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: Optimalkan masalah untuk eksekusi pada perangkat keras kuantum

• Input: Circuit abstrak, belum dioptimalkan untuk Backend tertentu
• Output: Circuit target dan observable, dioptimalkan untuk QPU yang dipilih

Gunakan fungsi generate_preset_pass_manager dari Qiskit untuk menentukan rutinitas optimasi bagi Circuit kita berkenaan dengan QPU tempat kita berencana menjalankan eksperimen. Kita set optimization_level=3, yang berarti kita akan menggunakan preset pass manager yang memberikan tingkat optimasi 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: Eksekusi menggunakan primitif Qiskit

• Input: Circuit target
• Output: Distribusi kuasi-probabilitas

Gunakan primitif Sampler dari Qiskit Runtime untuk merekonstruksi distribusi kuasi-probabilitas dari state-state yang dihasilkan saat men-sampling Circuit. Untuk tugas membangkitkan matriks kernel, kita terutama tertarik pada probabilitas mengukur state |0>.

Untuk demo ini, kita akan menjalankan pada QPU dengan primitif qiskit-ibm-runtime. Untuk menjalankan pada primitif berbasis statevector dari qiskit, gantikan blok kode 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: Post-process dan kembalikan hasil dalam format klasikal yang diinginkan

• Input: Distribusi probabilitas
• Output: Satu elemen matriks kernel

Hitung probabilitas mengukur |0> pada Circuit overlap, dan isi matriks kernel di posisi yang sesuai dengan sampel yang diwakili oleh Circuit overlap ini (baris 15, kolom 20). Dalam visualisasi ini, merah lebih gelap menunjukkan fidelitas yang lebih mendekati 1,0. Untuk mengisi seluruh 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

Deploy pola Qiskit ke cloud

Untuk melakukan ini, pindahkan kode sumber di atas ke sebuah file, ./source/generate_kernel_entry.py, bungkus kode dalam sebuah skrip yang menerima input dan mengembalikan solusi akhir, lalu upload ke cluster remote menggunakan kelas QiskitFunction dari Qiskit Serverless. Untuk panduan tentang menentukan dependensi eksternal, mengoper argumen input, dan lainnya, lihat panduan Qiskit Serverless.

Input ke Pola adalah sepasang sampel data, x1 dan x2. Output-nya adalah fidelitas antara kedua sampel. Nilai ini akan digunakan untuk mengisi entri matriks kernel yang sesuai dengan kedua 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 pola Qiskit sebagai layanan terkelola

Setelah kita mengupload pola ke cloud, kita bisa menjalankannya dengan mudah menggunakan klien IBMServerlessProvider. Untuk kemudahan, kita akan menggunakan simulator kuantum eksak di lingkungan cloud, sehingga fidelitas yang kita hitung 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]}")

Survei tutorial

Silakan isi survei singkat ini untuk memberikan masukan tentang tutorial ini. Pendapatmu akan membantu kami meningkatkan konten dan pengalaman pengguna.

Tautan ke survei

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.