量子サポートベクトルマシン入門(第五回量子説明コンテスト)

Copy
!pip install scikit-learn

Copy
from blueqat import Circuit
import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from sklearn.datasets import make_moons
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap

def print_Zbasis_expression(statevector):
    nqubit = int(np.log2(np.size(statevector)))
    for i in range(2**nqubit):
        print('+({:.2f})*|{number:0{width}b}>'.format(statevector[i],number=i,width=nqubit),end='')

def myplot_histogram(sv,n,figsize=(20,10),fontsize=24):
    probs = np.abs(sv)**2
    ## z方向に射影測定した時に得られる可能性があるビット列
    z_basis = [format(i,"b").zfill(n) for i in range(probs.size)]

    plt.figure(figsize=figsize)
    plt.xlabel("states",fontsize=fontsize)
    plt.ylabel("probability(%)",fontsize=fontsize)
    plt.xticks(fontsize=fontsize)
    plt.yticks(fontsize=fontsize)
    plt.bar(z_basis, probs*100)
    plt.show()

Copy
def data_encoding(data):
    circuit = Circuit(2)
    for i,x in enumerate(data):
        circuit.rx(x)[i]
    return circuit

Copy
data = np.array([[0.1,0.2],[0.5,0.6],[0.3,0.4],[-0.2,0.6]])
data_encoding(data[0]).run(backend="draw") # show a circuit

Copy
sv = data_encoding(data[0]).run(backend="numpy") # データが埋め込まれた状態ベクトル
print_Zbasis_expression(sv)

Copy
v0 = data_encoding(data[0]).run(backend="numpy") # data0
v1 = data_encoding(data[1]).run(backend="numpy") # data1
kernel_value_from_sv = np.abs(np.vdot(v0,v1))**2 # calculate innner product 
print(kernel_value_from_sv)

Copy
def make_circuit(data0,data1):
    subcircuit0 = data_encoding(data0)
    subcircuit1 = data_encoding(data1).dagger()
    circuit = subcircuit0 + subcircuit1
    return circuit

Copy
make_circuit(data[0],data[1]).run(backend="draw")

Copy
def kernel(data0,data1):
    circuit = make_circuit(data0,data1)
    sv = circuit.run(backend="numpy")
    prob = np.abs(sv)**2
    kernel_value = prob[0]
    return kernel_value

Copy
kernel(data[0],data[1])

Copy
kernel(data[0],data[1]) == kernel_value_from_sv

Copy
def kernel_matrix(A, B):
    """Compute the matrix whose entries are the kernel
       evaluated on pairwise data from sets A and B."""
    return np.array([[kernel(a, b) for b in B] for a in A])

Copy
mat = kernel_matrix(data,data)
fig, ax = plt.subplots()
ax.imshow(mat)
plt.show()

Copy
np.random.seed(42)

X, y = load_iris(return_X_y=True)

# pick inputs and labels from the first two classes only,
# corresponding to the first 100 samples
X = X[0:100,0:2]
y = y[0:100]

# scaling the inputs is important since the embedding we use is periodic
scaler = StandardScaler().fit(X)
X_scaled = scaler.transform(X)

# scaling the labels to -1, 1 is important for the SVM and the
# definition of a hinge loss
y_scaled = 2 * (y - 0.5)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled)

Copy
mat = kernel_matrix(X_train,X_train)
fig, ax = plt.subplots()
ax.imshow(mat)
plt.show()

Copy
svm = SVC(kernel=kernel_matrix).fit(X_train, y_train)

Copy
predictions = svm.predict(X_test)
print("accuracy is ", accuracy_score(predictions, y_test))

Copy
   
def plot_decision_boundaries(classifier, ax, N_gridpoints=10):
    _xx, _yy = np.meshgrid(np.linspace(-2*np.pi, 2*np.pi, N_gridpoints), np.linspace(-2*np.pi, 2*np.pi, N_gridpoints))

    _zz = np.zeros_like(_xx)
    for idx in np.ndindex(*_xx.shape):
        _zz[idx] = classifier.predict(np.array([_xx[idx], _yy[idx]])[np.newaxis, :])

    plot_data = {"_xx": _xx, "_yy": _yy, "_zz": _zz}
    ax.contourf(
        _xx,
        _yy,
        _zz,
        cmap=ListedColormap(["#FF0000", "#0000FF"]),
        alpha=0.2,
        levels=[-1, 0, 1],
    )
    for ii in range(len(X_test)):
        if y_test[ii] > 0:
            plt.plot(X_test[ii,0],X_test[ii,1], marker="o", color='black')
        else:
            plt.plot(X_test[ii,0],X_test[ii,1], marker="x", color='black')
    return plot_data

Copy
plot_data = plot_decision_boundaries(svm, plt.gca())

Copy
X, y = make_moons(n_samples=200, shuffle=True)

# pick inputs and labels from the first two classes only,
# corresponding to the first 100 samples
X = X[0:100,0:2]
y = y[0:100]

# scaling the inputs is important since the embedding we use is periodic
scaler = StandardScaler().fit(X)
X_scaled = scaler.transform(X)

# scaling the labels to -1, 1 is important for the SVM and the
# definition of a hinge loss
y_scaled = 2 * (y - 0.5)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled)

Copy
svm = SVC(kernel=kernel_matrix).fit(X_train, y_train)

Copy
predictions = svm.predict(X_test)
print("accuracy is ", accuracy_score(predictions, y_test))

Copy
plot_data = plot_decision_boundaries(svm, plt.gca())

Copy
svm = SVC(kernel="rbf").fit(X_train, y_train)
predictions = svm.predict(X_test)
print("accuracy is ", accuracy_score(predictions, y_test))
plot_data = plot_decision_boundaries(svm, plt.gca())