Квантові ядра

Вступ до квантових ядер

«Квантовий метод ядра» — це будь-який метод, що використовує квантові комп'ютери для оцінки ядра. У цьому контексті під «ядром» розуміється матриця ядра або її окремі елементи. Нагадаємо: відображення ознак $\Phi(\vec{x})$ — це відображення з $\vec{x}\in \mathbb{R}^d$ у $\Phi(\vec{x})\in \mathbb{R}^{d'},$ де зазвичай $d'>d$, а мета цього відображення — зробити категорії даних лінійно відокремлюваними. Функція ядра приймає вектори у просторі відображених ознак як аргументи та повертає їх внутрішній добуток, тобто $K:\mathbb{R}^d\times\mathbb{R}^d\rightarrow \mathbb{R}$ з $K(x,y) = \langle \Phi(x)|\Phi(y)\rangle$. У класичному підході нас цікавлять відображення ознак, для яких функцію ядра легко обчислити. Це часто означає пошук такої функції ядра, для якої внутрішній добуток у просторі відображених ознак можна записати через вихідні вектори даних, не конструюючи $\Phi(x)$ та $\Phi(y)$ явно. У методі квантових ядер відображення ознак виконується квантовою схемою, а ядро оцінюється за результатами вимірювань цієї схеми та відносними ймовірностями вимірювань.

У цьому уроці ми вивчимо глибини попередньо закодованих кодувальних схем зі значним заплутуванням і порівняємо їх із глибинами схем, які ми пишемо вручну. Це не означає, що один підхід кращий за інший. Ти можеш виявити, що попередньо закодовані схеми надто глибокі, а заплутування у власноруч побудованій схемі недостатнє, щоб бути корисним. Ці приклади наведено лише для того, щоб ти міг досліджувати різні варіанти.

Перш ніж детально розбирати оцінку матриці ядра, окреслимо робочий процес у термінах патернів Qiskit.

Крок 1: Відображення класичних вхідних даних у квантову задачу

• Вхід: навчальний датасет
• Вихід: абстрактна схема для обчислення елемента матриці ядра

Маючи датасет, починаємо з кодування даних у квантову схему. Іншими словами, нам потрібно відобразити наші дані в гільбертовий простір станів квантового комп'ютера. Для цього ми будуємо схему, що залежить від даних. Є багато способів це зробити; попередній урок описував кілька варіантів. Ти можеш побудувати власну схему для кодування даних або скористатися готовим відображенням ознак, наприклад zz_feature_map. У цьому уроці ми зробимо обидва варіанти.

Зверни увагу: щоб обчислити один елемент матриці ядра, нам потрібно закодувати дві різні точки, аби оцінити їх внутрішній добуток. Повний квантовий робочий процес для ядра, звичайно, включатиме багато таких внутрішніх добутків між відображеними векторами даних, а також класичні методи машинного навчання. Але основний крок, що повторюється, — це оцінка одного елемента матриці ядра. Для цього ми обираємо квантову схему, що залежить від даних, і відображаємо два вектори даних у простір ознак.

При побудові матриці ядра нас особливо цікавить імовірність виміряти стан $|0\rangle^{\otimes N}$, де всі $N$ кубітів перебувають у стані $|0\rangle$. Щоб зрозуміти чому, розглянемо: схема, що відповідає за кодування та відображення вектора даних $\vec{x}_i$, записується як $\Phi(\vec{x}_i)$, а схема для $\vec{x}_j$ — як $\Phi(\vec{x}_j)$. Позначимо відображені стани:

$$|\psi(\vec{x}_i)\rangle = \Phi(\vec{x}_i)|0\rangle^{\otimes N}$$ $$|\psi(\vec{x}_j)\rangle = \Phi(\vec{x}_j)|0\rangle^{\otimes N}.$$

Ці стани є відображенням даних у вищі виміри, тому потрібний нам елемент ядра — це внутрішній добуток:

$$\langle\psi(\vec{x}_j)|\psi(\vec{x}_i)\rangle = \langle 0 |^{\otimes N}\Phi^\dagger(\vec{x}_j)\Phi(\vec{x}_i)|0\rangle^{\otimes N}.$$

Якщо ми діємо на початковий стан $|0\rangle^{\otimes N}$ обома схемами $\Phi^\dagger(\vec{x}_j)$ та $\Phi(\vec{x}_i)$, то ймовірність подальшого вимірювання стану $|0\rangle^{\otimes N}$ дорівнює:

$$P_0 = |\langle0|^{\otimes N}\Phi^\dagger(\vec{x}_j)\Phi(\vec{x}_i)|0\rangle^{\otimes N}|^2.$$

Це саме те значення, яке нам потрібне (з точністю до $||^2$). Шар вимірювання нашої схеми поверне ймовірності вимірювань (або так звані «квазіймовірності», якщо застосовуються певні методи пом'якшення помилок). Нас цікавить ймовірність нульового стану $|0\rangle^{\otimes N}$.

Крок 2: Оптимізація задачі для квантового виконання

• Вхід: абстрактна схема, не оптимізована під конкретний бекенд
• Вихід: цільова схема та спостережувана, оптимізовані для обраного QPU

На цьому кроці ми використаємо функцію generate_preset_pass_manager з Qiskit, щоб задати процедуру оптимізації нашої схеми для реального квантового комп'ютера, на якому плануємо запускати експеримент. Ми встановимо optimization_level=3, що означає використання менеджера пропусків із найвищим рівнем оптимізації. У цьому контексті «оптимізація» стосується реалізації схеми на реальному квантовому комп'ютері. Це включає вибір фізичних кубітів, що відповідають кубітам у абстрактній квантовій схемі, з метою мінімізації глибини вентилів або вибору фізичних кубітів із найнижчими доступними рівнями помилок. Це не пов'язано безпосередньо з оптимізацією задачі машинного навчання (як у класичних оптимізаторах, таких як COBYLA).

Залежно від реалізації кроку 2, можливо, доведеться оптимізувати схему більше одного разу, оскільки кожна пара точок, що входить до елемента матриці, породжує окрему схему для вимірювання.

Крок 3: Виконання за допомогою Qiskit Runtime Primitives

• Вхід: цільова схема
• Вихід: розподіл імовірностей

Використовуй примітив Sampler з Qiskit Runtime для відновлення розподілу імовірностей станів, отриманих при семплюванні схеми. Зверни увагу: це може називатися «розподілом квазіймовірностей» — термін, що застосовується там, де шум є проблемою і де введено додаткові кроки, наприклад пом'якшення помилок. У таких випадках сума всіх імовірностей може бути не рівно 1; звідси «квазіймовірність».

Крок 4: Постобробка, повернення результату у класичному форматі

• Вхід: розподіл імовірностей
• Вихід: один елемент матриці ядра або вся матриця ядра при повторенні

Обчисли ймовірність виміряти $|0\rangle^{\otimes N}$ на квантовій схемі та запиши значення в матрицю ядра на позиції, що відповідає двом використаним векторам даних. Щоб заповнити всю матрицю ядра, потрібно провести квантовий експеримент для кожного елемента. Коли матриця ядра готова, її можна використовувати в багатьох класичних алгоритмах машинного навчання, що приймають pre-calculated kernels. Наприклад: qml_svc = SVC(kernel="precomputed"). Після цього можна застосувати класичні робочі процеси до тестових даних і отримати оцінку точності. Залежно від того, чи задовольняє нас точність, може знадобитися переглянути певні аспекти обчислення, зокрема відображення ознак.

Огляд уроку

У цьому уроці ми виконаємо ці кроки кількома способами, щоб оптимально використати твій час на реальних квантових комп'ютерах. Ми застосуємо квантовий метод ядра до:

• одного елемента матриці ядра для даних із відносно невеликою кількістю ознак на реальному бекенді, щоб легко стежити за тим, що відбувається на кожному кроці;
• цілого датасету з відносно невеликою кількістю ознак на симульованому бекенді, щоб побачити, як квантовий робочий процес поєднується з класичними методами машинного навчання;
• одного елемента матриці ядра для даних із великою кількістю ознак на реальному квантовому комп'ютері. Ми не оцінюватимемо всю матрицю ядра для великого датасету, щоб не витрачати зайвий час на квантових комп'ютерах IBM®.

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

# If you have not already, install scikit learn
#!pip install scikit-learn

Один елемент матриці ядра

Крок 1: Відображення класичних вхідних даних у квантову задачу

Розглянемо спочатку датасет із невеликою кількістю ознак, скажімо 10. Датасет може бути довільного розміру, оскільки ми обчислюємо елементи матриці ядра по одному. Нам потрібні хоча б дві точки, тому почнемо з цього (у наступному прикладі ми імпортуємо повний датасет). Імпортуємо кілька необхідних пакетів:

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

# Two mock data points, including category labels, as in training
small_data = [
    [-0.194, 0.114, -0.006, 0.301, -0.359, -0.088, -0.156, 0.342, -0.016, 0.143, 1],
    [-0.1, 0.002, 0.244, 0.127, -0.064, -0.086, 0.072, 0.043, -0.053, 0.02, -1],
]

# Data points with labels removed, for inner product
train_data = [small_data[0][:-1], small_data[1][:-1]]

Можемо спробувати скористатися z_feature_map.

# from qiskit.circuit.library import zz_feature_map
# fm = zz_feature_map(feature_dimension=np.shape(train_data)[1], entanglement='linear', reps=1)

from qiskit.circuit.library import z_feature_map

fm = z_feature_map(feature_dimension=np.shape(train_data)[1])

unitary1 = fm.assign_parameters(train_data[0])
unitary2 = fm.assign_parameters(train_data[1])

Два унітарні оператори вище точно відповідають $U_1$ та $U_2$, описаним у вступі. Ми можемо об'єднати їх за допомогою unitary_overlap. Як завжди, варто стежити за глибиною схеми.

from qiskit.circuit.library import unitary_overlap

overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()

print("circuit depth = ", overlap_circ.decompose().depth())
overlap_circ.decompose().draw("mpl", scale=0.6, style="iqp")

circuit depth =  9

Крок 2: Оптимізація задачі для квантового виконання

Починаємо з вибору найменш завантаженого бекенду, після чого оптимізуємо схему для запуску на ньому.

# Import needed packages
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

# Get the least busy backend
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=fm.num_qubits
)
print(backend)

<IBMBackend('ibm_brisbane')>

# Apply level 3 optimization to our overlap circuit
pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
overlap_ibm = pm.run(overlap_circ)

Для складних схем цей крок суттєво збільшує глибину схеми, оскільки відбувається відображення на нативні вентилі реальних квантових комп'ютерів і може знадобитися переміщення інформації між кубітами. У цьому простому випадку глибина майже не змінюється.

print("circuit depth = ", overlap_ibm.decompose().depth())
overlap_ibm.decompose().depth(lambda instr: len(instr.qubits) > 1)

circuit depth =  10

1

Крок 3: Виконання за допомогою Qiskit Runtime Primitives

Синтаксис запуску на симуляторі закоментовано нижче. Для цього датасету з невеликою кількістю ознак запуск на симуляторі ще є варіантом. Для обчислень у масштабі корисності симуляція зазвичай нежиттєздатна. Симулятори слід використовувати лише для налагодження коду у зменшеному масштабі.

# Run this for a simulator
# from qiskit.primitives import StatevectorSampler

# from qiskit_ibm_runtime import Options, Session, Sampler

# num_shots = 10000

# Evaluate the problem using state vector-based primitives from Qiskit
# sampler = StatevectorSampler()
# results = sampler.run([overlap_circ], shots=num_shots).result()
# .get_counts() returns counts associated with a state labeled by bit results such as |001101...01>.
# counts_bit = results[0].data.meas.get_counts()
# .get_int_counts returns the same counts, but labeled by integer equivalent of the above bit string.
# counts = results[0].data.meas.get_int_counts()

# Benchmarked on an Eagle processor, 7-11-24, took 4 sec.

# Import our runtime primitive
from qiskit_ibm_runtime import Session, SamplerV2 as Sampler

num_shots = 10000

# Use sampler and get the counts

sampler = Sampler(mode=backend)
results = sampler.run([overlap_ibm], shots=num_shots).result()
# .get_counts() returns counts associated with a state labeled by bit results such as |001101...01>.
counts_bit = results[0].data.meas.get_counts()
# .get_int_counts returns the same counts, but labeled by integer equivalent of the above bit string.
counts = results[0].data.meas.get_int_counts()

Крок 4: Постобробка, повернення результату у класичному форматі

Як описано у вступі, найкорисніше вимірювання тут — це ймовірність виміряти нульовий стан $|00000\rangle$.

counts.get(0, 0.0) / num_shots

0.6525

Це саме той результат, який нам потрібен: оцінка внутрішнього добутку (з точністю до модуля в квадраті) між векторами, що відповідають двом точкам даних. Якщо хочеш подивитися на повний розподіл ймовірностей вимірювань (або квазіймовірностей), скористайся функцією plot_distribution, як показано нижче. Для великої кількості кубітів такі графіки швидко стають непридатними для сприйняття.

from qiskit.visualization import plot_distribution

plot_distribution(counts_bit)

Як альтернативу, можна визначити візуалізацію, як наведено нижче, щоб дивитися лише на 10 найімовірніших вимірювань. Це може бути корисно для налагодження або спроби отримати більше інтуїції щодо даних. Але ймовірність вимірювання нульового стану — це і є наш елемент матриці ядра.

def visualize_counts(probs, num_qubits):
    """Visualize the outputs from the Qiskit Sampler primitive."""
    zero_prob = probs.get(0, 0.0)
    top_10 = dict(sorted(probs.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]))
    xvals, yvals = list(zip(*by_key.items()))
    xvals = [bin(xval)[2:].zfill(num_qubits) for xval in xvals]
    plt.bar(xvals, yvals)
    plt.xticks(rotation=75)
    plt.title("Results of sampling")
    plt.xlabel("Measured bitstring")
    plt.ylabel("Counts")
    plt.show()

visualize_counts(counts, overlap_circ.num_qubits)

З цієї інформації про лише один внутрішній добуток між двома точками даних у просторі ознак вищої розмірності ми можемо лише сказати, що їх перекриття є досить великим порівняно з максимальним перекриттям (яке дорівнювало б 1.0). Це може свідчити про те, що ці дві точки певним чином схожі за природою і будуть класифіковані в один клас. Або ж це може означати, що наше відображення ознак неефективно відображає у простір, де схожі дані мають велике перекриття, а несхожі — мале. Щоб дізнатися, що саме вірно, потрібно застосувати відображення ознак до всього набору даних і перевірити, чи можна маніпулювати отриманою матрицею ядра для ефективного розділення класів із високою точністю.

Варто зазначити, що ми використовували z_feature_map, який дав малу транспілювану глибину по двохкубітних вентилях (глибина 1, фактично). Якщо твої схеми стають надто глибокими, це неминуче призведе до великого рівня шуму, і це зробить ймовірність виміряти нульовий стан дуже низькою, навіть якщо твоє відображення ознак добре узгоджується з даними. Наприклад, повторення описаного процесу з використанням zz_feature_map та , entanglement='linear', reps=1 дало dist.get(0,0.0) = 0.0015 для тих самих точок даних. Це пов'язано зі значно більшими глибинами схем і двохкубітними глибинами у zz_feature_map. На малюнку нижче показано розподіл імовірностей для цього обчислення.

Варто поекспериментувати з кількома точками даних з одного класу, щоб з'ясувати, наскільки малою має бути глибина для отримання хороших результатів. Наведені нижче поради є грубими і матимуть винятки. Загалом, транспільована двохкубітна глибина до 10 — жодної проблеми. Транспільована двохкубітна глибина 50–60 — на межі можливостей, і потребуватиме передових методів пом'якшення помилок та інших інструментів. Між цими крайнощами результати можуть варіюватися залежно від схожості даних, виразності відображення ознак, ширини схеми та інших факторів. Зазвичай крок постобробки також включає класичні процеси машинного навчання. У наступному розділі ми розширимо цей процес на весь датасет і покажемо класичний робочий процес машинного навчання.

Перевір своє розуміння

Прочитай питання нижче, подумай над відповідями, а потім натисни трикутники, щоб розкрити рішення.

У 10-кубітній квантовій схемі скільки загалом різних станів може бути виміряно?

Відповідь:

$2^{10}$ або 1024.

Припустимо, що хтось, хто тільки починає вивчати квантові обчислення, намагається використати квантову схему з дуже великою двохкубітною глибиною і не застосовує пом'якшення помилок. Припустимо також, що це призводить до рівня помилок 10% на кожному кубіті. Якщо справжній (без помилок) елемент матриці ядра для цієї схеми дуже великий, скажімо 1.0, якою буде ймовірність виміряти всі 10 кубітів у стані |0>?

Відповідь:

Імовірність правильного виявлення кожного кубіта у стані |0> дорівнює 0.90. Імовірність того, що всі 10 кубітів виявляться у правильному стані, становить $0.90^{10}$ або близько 35%.

Поясни своїми словами, чому так важливо стежити за глибиною схем. Це справедливо загалом, але поясни це в контексті оцінки квантового ядра.

Відповідь:

У цьому робочому процесі оцінки квантового ядра (QKE) наші оцінки базуються на вимірюваннях нульового стану, тобто стану, в якому кожен кубіт перебуває у стані $|0\rangle$. Дуже глибокі схеми вводять високий рівень помилок. Коли цей рівень помилок накопичується по багатьох кубітах, це суттєво знижує ймовірність виміряти нульовий стан.

Повна матриця ядра

У цьому розділі ми розширимо описаний вище процес на бінарну класифікацію повного датасету. Це додасть дві важливі складові: (1) тепер ми можемо реалізувати класичне машинне навчання в постобробці і (2) отримати оцінки точності для навчання.

Крок 1: Відображення класичних вхідних даних у квантову задачу

Тепер ми імпортуємо наявний датасет для класифікації. Цей датасет містить 128 рядків (точок даних) і 14 ознак для кожної точки. Є 15-й елемент, що вказує на бінарну категорію кожної точки ($\pm 1$). Датасет імпортується нижче, або ти можеш отримати доступ до датасету і переглянути його структуру тут.

Ми використаємо перші 90 точок даних для навчання та наступні 30 точок для тестування.

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

df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)

# Prepare training data

train_size = 90
X_train = df.values[0:train_size, :-1]
train_labels = df.values[0:train_size, -1]

# Prepare testing data
test_size = 30
X_test = df.values[train_size : train_size + test_size, :-1]
test_labels = df.values[train_size : train_size + test_size, -1]

--2024-07-11 23:05:22--  https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.111.133, 185.199.109.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 49405 (48K) [text/plain]
Saving to: ‘dataset_graph7.csv.15’

dataset_graph7.csv. 100%[===================>]  48.25K  --.-KB/s    in 0.02s   

2024-07-11 23:05:23 (2.11 MB/s) - ‘dataset_graph7.csv.15’ saved [49405/49405]

Підготуємо заздалегідь збереження кількох виводів, побудувавши матрицю ядра та тестову матрицю відповідних розмірів.

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

Тепер ми створюємо відображення ознак для кодування та відображення наших класичних даних у квантовій схемі. Ми можемо побудувати власне відображення ознак або скористатися готовим. Можеш вільно змінювати відображення ознак нижче або повернутися до ZFeatureMap. Але завжди звертай увагу на глибину схеми. Згадаємо, що в попередньому прикладі на 6 кубітах транспільована глибина схеми виявилася непридатною при використанні zz_feature_map. Зі збільшенням масштабу і складності схеми глибина може стрімко зростати до точки, де шум захльоснє наші результати. Якщо ти знаєш щось про структуру своїх даних, що може підказати, яка структура відображення ознак буде найкориснішою, — варто створити власне відображення ознак, що використовує це знання.

from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit

# Prepare feature map for computing overlap
num_features = np.shape(X_train)[1]
num_qubits = int(num_features / 2)

# To use a custom feature map use the lines below.
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)

Кроки 2 та 3: Оптимізація задачі та виконання за допомогою примітивів

Ми побудуємо схему перекриття, і якби ми запускали її на реальному квантовому комп'ютері в цьому прикладі, ми б оптимізували її для виконання, як і раніше. Але в цьому випадку ми маємо намір перебрати всі точки даних і обчислити повну матрицю ядра. Для кожної пари векторів даних $\vec{x}_i$ та $\vec{x}_j$ ми створюємо іншу схему перекриття. Отже, для кожної пари точок даних потрібна окрема оптимізація. Таким чином, кроки 2 та 3 виконуватимуться разом у кількох ітераціях.

Комірка коду нижче виконує рівно той самий процес, що й раніше, для однієї пари точок даних. Цього разу він просто виконується всередині двох циклів for, і є додатковий рядок наприкінці kernel_matrix[x_1,x_2] = ... для зберігання результатів кожного обчислення. Зверни увагу: ми скористалися симетрією матриці ядра, щоб скоротити кількість обчислень удвічі. Ми також просто встановили діагональні елементи рівними 1, оскільки саме такими вони мають бути за відсутності шуму. Залежно від реалізації та потрібної точності, діагональні елементи можна також використовувати для оцінки шуму або його вивчення з метою пом'якшення помилок.

Після повного заповнення матриці ядра ми повторюємо процес для тестових даних і заповнюємо test_matrix. Це насправді теж матриця ядра; ми просто даємо їй іншу назву для розрізнення.

# To use a simulator
from qiskit.primitives import StatevectorSampler

# Remember to insert your token in the QiskitRuntimeService constructor to use real quantum computers
# service = QiskitRuntimeService()
# backend = service.least_busy(
#    operational=True, simulator=False, min_num_qubits=fm.num_qubits
# )

num_shots = 10000

# Evaluate the problem using state vector-based primitives from Qiskit.
sampler = StatevectorSampler()

for x1 in range(0, train_size):
    for x2 in range(x1 + 1, train_size):
        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 = unitary_overlap(unitary1, unitary2)
        overlap_circ.measure_all()

        # These lines run the qiskit sampler primitive.
        counts = (
            sampler.run([overlap_circ], shots=num_shots)
            .result()[0]
            .data.meas.get_int_counts()
        )

        # Assign the probability of the 0 state to the kernel matrix, and the transposed element (since this is an inner product)
        kernel_matrix[x1, x2] = counts.get(0, 0.0) / num_shots
        kernel_matrix[x2, x1] = counts.get(0, 0.0) / num_shots
    # Fill in on-diagonal elements with 1, again, since this is an inner-product corresponding to probability (or alter the code to check these entries and verify they yield 1)
    kernel_matrix[x1, x1] = 1

print("training done")

# Similar process to above, but for testing data.
for x1 in range(0, test_size):
    for x2 in range(0, train_size):
        unitary1 = fm.assign_parameters(list(X_test[x1]) + [np.pi / 2])
        unitary2 = fm.assign_parameters(list(X_train[x2]) + [np.pi / 2])

        # Create the overlap circuit
        overlap_circ = unitary_overlap(unitary1, unitary2)
        overlap_circ.measure_all()

        counts = (
            sampler.run([overlap_circ], shots=num_shots)
            .result()[0]
            .data.meas.get_int_counts()
        )

        test_matrix[x1, x2] = counts.get(0, 0.0) / num_shots

print("test matrix done")

training done
test matrix done

Крок 4: Постобробка, повернення результату в класичному форматі

Тепер, коли ми маємо матрицю ядра та відформатовану аналогічним чином тестову матрицю test_matrix, отриману методами квантового ядра, ми можемо застосувати класичні алгоритми машинного навчання, щоб зробити прогнози щодо тестових даних і перевірити їхню точність. Почнемо з імпорту sklearn.svc зі Scikit-Learn — класифікатора на основі метода опорних векторів (SVC). Треба вказати, що ми хочемо використовувати наше попередньо обчислене ядро: kernel = precomputed.

# import a support vector classifier from a classical ML package.
from sklearn.svm import SVC

# Specify that you want to use a pre-computed kernel matrix
qml_svc = SVC(kernel="precomputed")

За допомогою SVC.fit можна передати матрицю ядра та мітки навчальних даних, щоб отримати підгонку моделі. SVC.score потім оцінить наші тестові дані відносно цієї підгонки, використовуючи test_matrix, і поверне нашу точність.

# Feed in the pre-computed matrix and the labels of the training data. The classical algorithm gives you a fit.
qml_svc.fit(kernel_matrix, train_labels)

# Now use the .score to test your data, using the matrix of test data, and test labels as your inputs.
qml_score_precomputed_kernel = qml_svc.score(test_matrix, test_labels)
print(f"Precomputed kernel classification test score: {qml_score_precomputed_kernel}")

Precomputed kernel classification test score: 1.0

Бачимо, що точність нашої навченої моделі склала 100%. Це чудово і доводить, що QKE може працювати. Але це дуже далеко від квантової переваги. Класичні ядра, мабуть, теж могли б розв'язати цю задачу класифікації зі 100% точністю. Ще багато роботи залишається з характеристикою різних типів і зв'язків даних, щоб зрозуміти, де квантові ядра будуть найкориснішими в нинішню еру корисності. Залишаємо тобі можливість змінити частини цього робочого процесу і вивчити ефективність різних квантових карт ознак. Ось кілька речей, які варто розглянути:

• Наскільки стійка точність? Чи зберігається вона для широкого спектра даних чи лише для цих конкретних навчальних даних?
• Яка структура твоїх даних змушує тебе думати, що квантова карта ознак буде корисною?
• Як точність змінюється зі збільшенням/зменшенням обсягу навчальних даних?
• Які карти ознак можна використовувати і як результати залежать від вибору карти?
• Як точність і час виконання залежать від збільшення кількості ознак?
• Які тенденції, якщо такі є, ти очікуєш спостерігати на реальних квантових комп'ютерах?

Масштабування до більшої кількості ознак і кубітів

У цьому розділі ми повторимо обчислення одного елемента матриці, але для значно більшої кількості ознак, намітивши шлях до масштабування до рівня корисності. Обмеження одним елементом матриці зроблено для того, щоб показати процес без надмірного використання виділеного часу на квантових комп'ютерах.

Крок 1: Відображення класичних вхідних даних у квантову задачу

Припустимо, що вихідним набором даних є такий, у якому кожна точка даних має 42 ознаки. Як і в першому прикладі, ми обчислимо один елемент матриці ядра, для чого потрібні дві точки даних. Дві точки нижче мають 42 ознаки та одну категоріальну змінну ($\pm 1$).

# Two mock data points, including category labels, as in training

large_data = [
    [
        -0.028,
        -1.49,
        -1.698,
        0.107,
        -1.536,
        -1.538,
        -1.356,
        -1.514,
        -0.109,
        -1.8,
        -0.122,
        -1.651,
        -1.955,
        -0.123,
        -1.732,
        0.091,
        -0.048,
        -0.128,
        -0.026,
        0.082,
        -1.263,
        0.065,
        0.004,
        -0.055,
        -0.08,
        -0.173,
        -1.734,
        -0.39,
        -1.451,
        0.078,
        -1.578,
        -0.025,
        -0.184,
        -0.119,
        -1.336,
        0.055,
        -0.204,
        -1.578,
        0.132,
        -0.121,
        -1.599,
        -0.187,
        -1,
    ],
    [
        -1.414,
        -1.439,
        -1.606,
        0.246,
        -1.673,
        0.002,
        -1.317,
        -1.262,
        -0.178,
        -1.814,
        0.013,
        -1.619,
        -1.86,
        -0.25,
        -0.212,
        -0.214,
        -0.033,
        0.071,
        -0.11,
        -1.607,
        0.441,
        -0.143,
        -0.009,
        -1.655,
        -1.579,
        0.381,
        -1.86,
        -0.079,
        -0.088,
        -0.058,
        -1.481,
        -0.064,
        -0.065,
        -1.507,
        0.177,
        -0.131,
        -0.153,
        0.07,
        -1.627,
        0.593,
        -1.547,
        -0.16,
        -1,
    ],
]
train_data = [large_data[0][:-1], large_data[1][:-1]]

Пригадаємо, що zz_feature_map давав досить глибокі схеми у випадку відносно невеликої кількості ознак (14 ознак). Зі збільшенням кількості ознак необхідно уважно стежити за глибиною схеми. Щоб проілюструвати це, спочатку спробуємо використати zz_feature_map і перевіримо глибину отриманої схеми.

from qiskit.circuit.library import zz_feature_map

fm = zz_feature_map(
    feature_dimension=np.shape(train_data)[1], entanglement="linear", reps=1
)

unitary1 = fm.assign_parameters(train_data[0])
unitary2 = fm.assign_parameters(train_data[1])

from qiskit.circuit.library import unitary_overlap

overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()

print("circuit depth = ", overlap_circ.decompose(reps=2).depth())
print(
    "two-qubit depth",
    overlap_circ.decompose().depth(lambda instr: len(instr.qubits) > 1),
)
# overlap_circ.draw("mpl", scale=0.6, style="iqp")

circuit depth =  251
two-qubit depth 165

Як описано раніше, визначити точно, яка глибина є занадто великою — питання неоднозначне. Але двокубітна глибина понад 100 ще до транспіляції — це вже неприйнятно. Саме тому протягом усього уроку наголошувалося на важливості власних карт ознак. Якщо ти знаєш щось про структуру всього набору даних, варто розробляти карту заплутування з урахуванням цієї структури. Тут, оскільки ми обчислюємо лише внутрішній добуток між двома такими точками даних, ми надаємо пріоритет низькій глибині схеми, не вдаючись до детального аналізу структури даних.

from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit

# Prepare feature map for computing overlap

entangler_map = [
    [3, 4],
    [2, 5],
    [1, 4],
    [2, 3],
    [4, 6],
    [7, 9],
    [10, 11],
    [9, 12],
    [8, 11],
    [9, 10],
    [11, 13],
    [14, 16],
    [17, 18],
    [16, 19],
    [15, 18],
    [16, 17],
    [18, 20],
]

# Use the entangler map above to build a feature map

num_features = np.shape(train_data)[1]
num_qubits = int(num_features / 2)

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)

from qiskit.circuit.library import unitary_overlap

# Assign features of each data point to a unitary, an instance of the general feature map.

unitary1 = fm.assign_parameters(list(train_data[0]) + [np.pi / 2])
unitary2 = fm.assign_parameters(list(train_data[1]) + [np.pi / 2])

# Create the overlap circuit

overlap_circ = unitary_overlap(unitary1, unitary2)
overlap_circ.measure_all()

Поки не будемо перевіряти глибини, адже справді важливою є транспільована двокубітна глибина.

Крок 2: Оптимізація задачі для квантового виконання

Починаємо з вибору найменш завантаженого бекенду, потім оптимізуємо схему для запуску на цьому бекенді.

# Import needed packages
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService

# Get the least busy backend
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=fm.num_qubits
)
print(backend)

<IBMBackend('ibm_brisbane')>

На невеликих задачах попередньо налаштований менеджер проходів зазвичай повертає ту саму схему з тією самою глибиною надійно. Але у дуже великих і складних схемах менеджер проходів може щоразу повертати різні транспільовані схеми. Це пов'язано з тим, що він використовує евристику, а дуже великі схеми мають складний ландшафт можливих оптимізацій. Часто корисно транспілювати кілька разів і взяти найбільш мілку схему. Це вносить лише класичні накладні витрати, але може суттєво покращити результати квантового комп'ютера.

Тут ми транспілюємо схему унітарного перекриття 20 разів і дивимося на глибини отриманих схем.

# Apply level 3 optimization to our overlap circuit
transpiled_qcs = []
transpiled_depths = []
transpiled_twoqubit_depths = []
for i in range(1, 20):
    pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
    overlap_ibm = pm.run(overlap_circ)
    transpiled_qcs.append(overlap_ibm)
    transpiled_depths.append(overlap_ibm.decompose().depth())
    transpiled_twoqubit_depths.append(
        overlap_ibm.decompose().depth(lambda instr: len(instr.qubits) > 1)
    )

print("circuit depth = ", overlap_ibm.decompose().depth())

circuit depth =  61

print(transpiled_depths)
print(transpiled_twoqubit_depths)

[61, 60, 60, 69, 60, 60, 60, 65, 60, 60, 69, 61, 77, 77, 65, 60, 60, 77, 61]
[13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13]

Тут видно, що при різних проходах транспіляції загальна глибина вентилів дещо відрізняється. Наша схема ще недостатньо глибока/широка, щоб побачити варіацію в транспільованих двокубітних глибинах. Ми будемо використовувати transpiled_qcs[1], яка має глибину 60 — трохи менше, ніж глибина найглибшої отриманої схеми, яка дорівнювала 77.

overlap_ibm = transpiled_qcs[1]

Крок 3: Виконання за допомогою примітивів Qiskit Runtime

У міру наближення до масштабів корисності симулятори стають непридатними. Тут показано лише синтаксис для реальних квантових комп'ютерів.

# Run on ibm_osaka, 7-12-24, required 22 sec.

# Import our runtime primitive
from qiskit_ibm_runtime import SamplerV2 as Sampler

# Open a Runtime session:
session = Session(backend=backend)
num_shots = 10000
# Use sampler and get the counts

sampler = Sampler(mode=session)
options = sampler.options
options.dynamical_decoupling.enable = True
options.twirling.enable_gates = True
counts = (
    sampler.run([overlap_ibm], shots=num_shots).result()[0].data.meas.get_int_counts()
)

# Close session after done
session.close()

Крок 4: Постобробка, повернення результату в класичному форматі

Як описано у вступі, найкориснішим вимірюванням тут є імовірність виміряти нульовий стан $|00000\rangle$.

counts.get(0, 0.0) / num_shots

0.0138

Цей процес для одного елемента матриці ядра можна повторити між іншими парами точок даних у наборі, щоб отримати повну матрицю ядра. Розмір матриці ядра визначається кількістю точок у навчальних даних, а не кількістю ознак. Тому обчислювальна вартість перетворення матриці ядра на прогностичну модель не масштабується з кількістю ознак або кубітів. Навіть для відносно невеликих наборів даних із великою кількістю ознак дані все одно потрібно узгоджувати з картою ознак, яка забезпечує ефективну класифікацію.

Масштабування і майбутні роботи

Метод ядра вимагає, щоб ми вимірювали $|0\rangle$ якомога точніше. Але помилки вентилів і помилки зчитування означають, що існує ненульова імовірність $p$ того, що будь-який даний кубіт буде помилково виміряний у стані $|1\rangle$. Навіть при надмірному спрощенні, що імовірність $|0\rangle$ повинна бути $100\%$, для багатьох ознак, закодованих, наприклад, на $N$ бітах, імовірність правильно виміряти всі біти у $|0\rangle$ зменшується до $(1-p)^N$. Зі збільшенням $N$ цей метод стає все менш і менш надійним. Подолання цієї труднощі та масштабування оцінки ядра до дедалі більшої кількості ознак є напрямком поточних досліджень. Щоб дізнатися більше про цю проблему, дивись роботу Thanasilp, Wang, Cerezo і Holmes. Рекомендуємо тобі досліджувати, що можна зробити з нинішніми квантовими комп'ютерами, і також дивитися вперед на те, що стане можливим в еру виправлення помилок.

Огляд

Обчислення квантового ядра включає:

• обчислення елементів матриці ядра з використанням пар навчальних точок даних
• кодування даних та їх відображення через карту ознак
• оптимізацію схеми для запуску на реальних квантових комп'ютерах / бекендах

Квантове ядро може потім використовуватися в класичних алгоритмах машинного навчання, як показано в цьому уроці.

Деякі ключові моменти, про які слід пам'ятати при використанні квантових ядер:

• Чи може набір даних отримати користь від методів квантового ядра?
• Спробуй різні карти ознак і схеми заплутування.
• Чи прийнятна глибина схеми?
• Спробуй запускати менеджер проходів кілька разів і використовуй схему з якомога меншою глибиною.

Методи квантового ядра є потенційно потужними інструментами за умови правильного збігу між наборами даних з квантово-придатними ознаками та відповідною квантовою картою ознак. Щоб краще зрозуміти, де квантові ядра, ймовірно, будуть корисними, рекомендуємо прочитати Liu, Arunachalam & Temme (2021).