from IPython.display import clear_output

!pip install scikit-learn
clear_output()

import time
import matplotlib
import numpy as np
import paddle
from numpy import pi as PI
from matplotlib import pyplot as plt

from paddle import matmul, transpose
from paddle_quantum.ansatz import Circuit
from paddle_quantum.gate import IQPEncoding
import paddle_quantum

import sklearn
from sklearn import svm
from sklearn.datasets import fetch_openml, make_moons, make_circles
from sklearn.model_selection import train_test_split

from IPython.display import clear_output
from tqdm import tqdm

# Generate data set
X_train, y_train = make_circles(10, noise=0.05, factor=0.2, random_state=0)
X_test, y_test = make_circles(10, noise=0.05, factor=0.2, random_state=1024)

# Visualize respectively the training and testing set
fig, ax = plt.subplots(1, 2, figsize=[10, 4])
ax[0].scatter(X_train[:,0], X_train[:,1], 
              marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))
ax[0].set_title('Train')
ax[1].set_title('Test')
ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))

print("Let's first see our training and testing set:")

Let's first see our training and testing set:

# Initialize the progress bar
bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'
pbar = tqdm(total=100, bar_format=bar_format_string)
pbar.close()
clear_output()

# Global variable for manual updates of the progress bar
N = 1

# The QKE circuit simulated by paddle quantum
def q_kernel_estimator(x1, x2):
    
    # Transform data vectors into tensors
    x1 = paddle.to_tensor(x1)
    x2 = paddle.to_tensor(x2)
    
    # Create the circuit
    cir = paddle_quantum.ansatz.Sequential()
    
    # Add the encoding circuit for the first data vector
    cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x1))
    init_state = paddle_quantum.state.zero_state(2)
    state = cir[0](state=init_state)    
    
    # Add inverse of the encoding circuit for the second data vector
    cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x2))
    fin_state = cir[1](state=state,invert=True).data
    
    # Update the progress bar
    global N
    pbar.update(100/N)
    
    # Return the probability of measuring 0...0 
    return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]

# Define a kernel matrix function, for which the input should be two list of vectors
# This is needed to customize the SVM kernel
def q_kernel_matrix(X1, X2):
    return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])

# Visualize the decision function, boundary, and margins of +- 0.2
def visualize_decision_bound(clf):
    
    # Create a 10x10 mesh in the data plan 
    x_min, x_max = X_train[:,0].min(), X_train[:,0].max()
    y_min, y_max = X_train[:,1].min(), X_train[:,1].max()
    XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), 
                         np.linspace(-1.2, 1.2, 10))
    
    # Calculate the decision function value on the 10x10 mesh
    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])
    Z_qke = Z.reshape(XX.shape)
    
    # visualize the decision function and boundary
    clear_output()
    plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,
                 cmap=matplotlib.cm.coolwarm, alpha=1)
    plt.scatter(X_train[:,0], X_train[:,1], 
                c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),
               edgecolor='black')
    plt.scatter(X_test[:,0], X_test[:,1], marker='v', 
                c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),
               edgecolor='black')
    plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],
                levels=[-.2, 0, .2])

# To make sure we didn't make any mistake, check if the kernel function satisfies K(x, x)=1
print('Check if K(x, x) = 1?',
      bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-6))

Check if K(x, x) = 1? True

# Create the progress bar and the total kernel evaluation number N needed for training and prediction
pbar = tqdm(total=100, 
            desc='Training and predicting with QKE-SVM', 
            bar_format=bar_format_string)
N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)

# Create a support vector machine with a quantum kernel
svm_qke = svm.SVC(kernel=q_kernel_matrix)

# Train the svm with training data
svm_qke.fit(X_train, y_train)

# See how the svm classifies the training and testing data
predict_svm_qke_train = svm_qke.predict(X_train)
predict_svm_qke_test = svm_qke.predict(X_test)

# Calculate the accuracy
accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)
accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)

# Visualize the result
pbar.close()
clear_output()
fig, ax = plt.subplots(1, 2, figsize=[10, 4])
ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', 
              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))
ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))
ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', 
              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))
ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))
print("Let's see how the QKE-SVM performs on the training on both the training and testing data:")

Let's see how the QKE-SVM performs on the training on both the training and testing data:

# Create the progress bar and the total kernel evaluation number N needed for visualizing the decision function
pbar = tqdm(total=100, 
            desc='Calculating the decision function of QKE-SVM', 
            bar_format=bar_format_string)
N = 10 ** 2 * len(X_train)
    
# Visualize the decision function
visualize_decision_bound(svm_qke)
pbar.close()

Calculating the decision function of QKE-SVM: 100%|██████████████████████████████▉|[00:09<00:00, 10.96it/s]

# First we can create a circuit to calculate the feature map 
def projected_q_feature_map(x):
    # turn data into tensor
    x = paddle.to_tensor(x)
    
    # Update the progress bar
    global N
    pbar.update(100/N)
    
    init_state = paddle_quantum.state.zero_state(2)

    res = []
    #　Take a projected measurement, returning its expected value as a classical feature
    for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']:
        cir = paddle_quantum.ansatz.Sequential()
        cir.append(IQPEncoding(qubits_idx=[[0, 1]], feature=x))
        state = cir[0](init_state)
        hamiltonian = paddle_quantum.Hamiltonian([[1.0, op_pauli]])
        cir.append(paddle_quantum.loss.ExpecVal(hamiltonian))
        res.append(cir[1](state).numpy()[0])
    return res

# to compute the projected quantum kernel based on the feature vectors
def p_quantum_kernel_estimator(x1, x2):
    
    # compute the feature vector of each data and return the kernel function value
    p_feature_vector_1 = np.array(projected_q_feature_map(x1))
    p_feature_vector_2 = np.array(projected_q_feature_map(x2))
    
    return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())

# similarly, define the kernel matrix as required 
def p_quantum_kernel_matrix(X1, X2):
    return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])

# Set the progress bar and the total kernel evaluation number N needed for training and prediction
pbar = tqdm(total=100, 
            desc='Training and predicting with PQK-SVM', 
            bar_format=bar_format_string)
N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))

# Create a support vector machine with a quantum kernel
svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)

# Train the svm with training data
svm_pqk.fit(X_train, y_train)

# See how the svm classifies the training and testing data
predict_svm_pqk_train = svm_pqk.predict(X_train)
predict_svm_pqk_test = svm_pqk.predict(X_test)

# Calculate the accuracy
accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)
accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)

# Visualize the result
pbar.close()
clear_output()
fig, ax = plt.subplots(1, 2, figsize=[10, 4])
ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', 
              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))
ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))
ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', 
              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))
ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))
print("Let's see how the PQK-SVM performs on the training on both the training and testing data:")

Let's see how the PQK-SVM performs on the training on both the training and testing data:

# Set the progress bar and the total kernel evaluation number N needed for visualizing the decision function
pbar = tqdm(total=100, 
            desc='Calculating the decision function for PQK-SVM', 
            bar_format=bar_format_string)
N = 2 * 10 ** 2 * len(X_train)
    
# Clear the progress bar and visualize the decision function
visualize_decision_bound(svm_pqk)
pbar.close()

Calculating the decision function for PQK-SVM: 100%|█████████████████████████████▉|[01:17<00:00,  1.29it/s]

Quantum Kernel Methods¶

Introduction¶

Background¶

Connections between quantum machine learning and kernel methods¶

Kernel-based Classification with Paddle Quantum¶

Projected quantum kernel¶

Conclusion¶

References¶