import pennylane as qml
 from pennylane import numpy as np
 from pennylane.optimize import AdamOptimizer
 
 from sklearn.model_selection import train_test_split
 import pandas as pd
 
 from sklearn.metrics import accuracy_score
 from sklearn.metrics import f1_score
 from sklearn.metrics import precision_score
 from sklearn.metrics import recall_score
 
 import math
 
 num_qubits = 4
 num_layers = 2
 
 dev = qml.device("default.qubit", wires=num_qubits)
 
 # quantum circuit functions
 def statepreparation(x):
     qml.BasisEmbedding(x, wires=range(0, num_qubits))
 
 def layer(W):
 
     qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)
     qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)
     qml.Rot(W[2, 0], W[2, 1], W[2, 2], wires=2)
     qml.Rot(W[3, 0], W[3, 1], W[3, 2], wires=3)
 
     qml.CNOT(wires=[0, 1])
     qml.CNOT(wires=[1, 2])
     qml.CNOT(wires=[2, 3])
     qml.CNOT(wires=[3, 0])
 
 @qml.qnode(dev, interface="autograd")
 def circuit(weights, x):
 
     statepreparation(x)
 
     for W in weights:
         layer(W)
 
     return qml.expval(qml.PauliZ(0))
 
 def variational_classifier(weights, bias, x):
     return circuit(weights, x) + bias
 
 def square_loss(labels, predictions):
     loss = 0
     for l, p in zip(labels, predictions):
         loss = loss + (l - p) ** 2
 
     loss = loss / len(labels)
     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
 
 def cost(weights, bias, X, Y):
     predictions = [variational_classifier(weights, bias, x) for x in X]
     return square_loss(Y, predictions)
 
 # preparaing data
 df_train = pd.read_csv('train.csv')
 
 df_train['Pclass'] = df_train['Pclass'].astype(str)
 
 df_train = pd.concat([df_train, pd.get_dummies(df_train[['Pclass', 'Sex', 'Embarked']])], axis=1)
 
 # I will fill missings with the median
 df_train['Age'] = df_train['Age'].fillna(df_train['Age'].median())
 
 df_train['is_child'] = df_train['Age'].map(lambda x: 1 if x < 12 else 0)
 cols_model = ['is_child', 'Pclass_1', 'Pclass_2', 'Sex_female']
 
 X_train, X_test, y_train, y_test = train_test_split(df_train[cols_model], df_train['Survived'], test_size=0.10, random_state=42, stratify=df_train['Survived'])
 
 X_train = np.array(X_train.values, requires_grad=False)
 Y_train = np.array(y_train.values * 2 - np.ones(len(y_train)), requires_grad=False)
 
 # setting init params
 np.random.seed(0)
 weights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)
 bias_init = np.array(0.0, requires_grad=True)
 
 opt = AdamOptimizer(0.125)
 num_it = 70
 batch_size = math.floor(len(X_train)/num_it)
 
 weights = weights_init
 bias = bias_init
 for it in range(num_it):
 
     # Update the weights by one optimizer step
     batch_index = np.random.randint(0, len(X_train), (batch_size,))
     X_batch = X_train[batch_index]
     Y_batch = Y_train[batch_index]
     weights, bias, _, _ = opt.step(cost, weights, bias, X_batch, Y_batch)
 
     # Compute accuracy
     predictions = [np.sign(variational_classifier(weights, bias, x)) for x in X_train]
     acc = accuracy(Y_train, predictions)
 
     print(
         "Iter: {:5d} | Cost: {:0.7f} | Accuracy: {:0.7f} ".format(
             it + 1, cost(weights, bias, X_train, Y_train), acc
        )
    )
 
 X_test = np.array(X_test.values, requires_grad=False)
 Y_test = np.array(y_test.values * 2 - np.ones(len(y_test)), requires_grad=False)
 
 predictions = [np.sign(variational_classifier(weights, bias, x)) for x in X_test]
 
 accuracy_score(Y_test, predictions)
 precision_score(Y_test, predictions)
 recall_score(Y_test, predictions)
 f1_score(Y_test, predictions, average='macro')

Accuracy: 78.89%
 Precision: 76.67%
 Recall: 65.71%
 F1: 77.12%

Accuracy: 75.56%
 Precision: 69.70%
 Recall: 65.71%
 F1: 74.00%