I am still not able to make it work, and when it works it fails. one such code with steady angles in qml.ROT is this one. and i am not able to modify it.
This should be a standalone working code with moons dataset. Thanks in advance for your time and help!!
import pennylane as qml
import pandas as pd
from pennylane import numpy as np
from pennylane.templates.layers import StronglyEntanglingLayers
from pennylane.init import strong_ent_layers_uniform
from pennylane.optimize import GradientDescentOptimizer
from sklearn.datasets import make_moons , make_circles
from sklearn.preprocessing import StandardScaler , minmax_scale
from itertools import chain
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split # Import train_test_split function
from sklearn import metrics #Import scikit-learn metrics module for accuracy calculation
blocks=1
layers=2
batch_size = 16
n_epochs = 20
test_size=0.2 #(train/test split)
learning_rate = 0.6
entangler = qml.CNOT
opt = GradientDescentOptimizer(stepsize=learning_rate)
n_qubits =2
dev = qml.device("default.qubit", wires=n_qubits)
randomseed = 1
X, y = make_moons(n_samples=400, noise=0)
X = minmax_scale(X, feature_range=(-np.pi, np.pi))
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=42)
from sklearn.metrics import roc_auc_score
# quantum circuit
#
#
# draw random quantum node weights
theta_weights = [strong_ent_layers_uniform(layers, n_qubits, seed=randomseed+i+1) for i in range(blocks)]
theta_bias = 0.0
chi1=0.1
psi1=0.2
zet1=0.1
chi2=0.1
psi2=0.2
zet2=0.1
theta_init = (theta_weights, theta_bias,chi1,psi1,zet1,chi2,psi2,zet2) # initial weights
@qml.qnode(dev)
def circuit(weights):
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
for i in range(blocks):
qml.Rot(chi1, psi1, zet1, wires=0)
qml.Rot(chi2, psi2, zet2, wires=1)
StronglyEntanglingLayers(weights[i], wires = range(n_qubits),imprimitive=entangler)
return qml.expval(qml.PauliZ(0))
# variational quantum classifier
def variational_classifier(theta):
weights = theta[0]
bias = theta[1]
return circuit(weights) + bias + chi1 + psi1 + zet1 + chi1 + psi2 + zet2
# train the variational classifier
theta = theta_init
def cost(theta, X, expectations):
e_predicted = \
np.array([variational_classifier(theta) for x in X])
loss = np.mean((e_predicted - expectations)**2)
return loss
def accuracy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
if abs(l - p) < 1e-5:
loss = loss + 1
loss = loss / len(labels)
return loss
# calculate numbe of batches
batches = len(X_train) // batch_size
# split training data into batches
X_batches = np.array_split(np.arange(len(X_train)), batches)
lossplot = []
aucrocplot = []
accuracytrainplot = []
accuracytestplot = []
for it, batch_index in enumerate(chain(*(n_epochs * [X_batches]))):
# Update the weights by one optimizer step
batch_cost = \
lambda theta: cost(theta, X_train[batch_index],y_train[batch_index])
theta = opt.step(batch_cost, theta)
if it % 10 == 0:
expectations = np.array([variational_classifier(theta) for x in X_train])
prob_class_one = (expectations + 1) / 2.0
prob_class_one = pd.DataFrame.from_dict(prob_class_one)
prob_class_one = prob_class_one.iloc[:, :]
prob_class_one = prob_class_one[0].apply(lambda x: -1 if x <= 0.5 else 1)
prob_class_onet = prob_class_one.to_numpy()
expectations = np.array([variational_classifier(theta) for x in X_test])
prob_class_one = (expectations + 1) / 2.0
prob_class_one = pd.DataFrame.from_dict(prob_class_one)
prob_class_one = prob_class_one.iloc[:, :]
prob_class_one = prob_class_one[0].apply(lambda x: -1 if x <= 0.5 else 1)
prob_class_one = prob_class_one.to_numpy()
#
#
#--------- GRID PLOT START
#
#
plt.figure()
cm = plt.cm.RdBu
fig= plt.figure(figsize=(5,5))
xx, yy = np.meshgrid(np.linspace(-np.pi, np.pi, 15), np.linspace(-np.pi, np.pi, 15))
X_grid = [np.array([x,y]) for x, y in zip(xx.flatten(), yy.flatten())]
predictions_grid = np.array([variational_classifier(theta) for x in X_grid])
zminus = (predictions_grid + 1.0) / 2.0
zminus = predictions_grid
Z=np.reshape(zminus, xx.shape)
# plot decision regions
cnt = plt.contourf(xx, yy,Z, levels=np.arange(-1, 1., 0.1), cmap=cm, alpha=0.8, extend="both")
plt.contour(xx, yy,Z, levels=[0.0], colors=("black",), linestyles=("--",), linewidths=(0.8,))
plt.show()
#
#
#--------- GRID PLOT END
#
#
#print("Acc test",metrics.accuracy_score(y_test, prob_class_one))
#print(metrics.confusion_matrix(y_test, prob_class_one))
lossplot.append(cost(theta, X_train[batch_index], y_train[batch_index]))
aucrocplot.append(roc_auc_score(y_test, prob_class_one))
accuracytrainplot.append(metrics.accuracy_score(y_train, prob_class_onet))
accuracytestplot.append(metrics.accuracy_score(y_test, prob_class_one))
# print("It",it+1,"out of",len(X_batches) *n_epochs)
print("It",it+1,"out of",len(X_batches) *n_epochs, "loss: ",cost(theta, X_train[batch_index], y_train[batch_index]),
" : Acc train: ",round(metrics.accuracy_score(y_train, prob_class_onet),2),
" : Acc test : ",round(metrics.accuracy_score(y_test, prob_class_one),3),
" : Auc : ",round(roc_auc_score(y_test, prob_class_one),3)
)
if metrics.accuracy_score(y_train, prob_class_onet) >= 0.97:
break
plt.plot(lossplot) #lets plot the second line
plt.ylabel('Loss')
plt.show()
plt.subplot(2,1,1)
plt.plot(accuracytrainplot,'r',label="train")
plt.plot(accuracytestplot,'b',label="test")
plt.ylabel('accuracy')
plt.legend()
plt.show()
plt.plot(aucrocplot) #lets plot the second line
plt.ylabel('auc roc score')
plt.show()
Would be curious to see if you observe any differences with