introduzione

Benvenuti nel mondo dell'apprendimento automatico quantistico! In questo tutorial, ti guideremo attraverso un progetto di livello principiante utilizzando un set di dati di esempio e forniremo istruzioni dettagliate con il codice. Alla fine di questo tutorial, avrai una solida conoscenza di come utilizzare i computer quantistici per eseguire attività di machine learning e avrai costruito il tuo primo modello quantistico.

Ma prima di immergerci nel tutorial, prendiamoci un momento per capire cos'è l'apprendimento automatico quantistico e perché è così eccitante.

L'apprendimento automatico quantistico è un campo all'intersezione tra calcolo quantistico e apprendimento automatico. Implica l'utilizzo di computer quantistici per eseguire attività di apprendimento automatico, come classificazione, regressione e clustering. I computer quantistici sono macchine potenti che utilizzano bit quantistici (qubit) invece dei bit classici per archiviare ed elaborare le informazioni. Ciò consente loro di eseguire determinate attività molto più velocemente rispetto ai computer classici, rendendoli particolarmente adatti per attività di apprendimento automatico che coinvolgono grandi quantità di dati.

Ora, iniziamo con il nostro tutorial!

Passaggio 1: installare le librerie e le dipendenze necessarie.

Per questo tutorial, utilizzeremo la PennyLanelibreria per l'apprendimento automatico quantistico, nonché NumPyper il calcolo numerico e Matplotlibper la visualizzazione dei dati. È possibile installare queste librerie utilizzando pipeseguendo i seguenti comandi:

!pip install pennylane
!pip install numpy
!pip install matplotlib

Per questo tutorial, utilizzeremo il set di dati Iris, che consiste in 150 campioni di fiori di iris con quattro caratteristiche: lunghezza del sepalo, larghezza del sepalo, lunghezza del petalo e larghezza del petalo. Il set di dati è incluso nella sklearnlibreria, quindi possiamo caricarlo utilizzando il seguente codice:

from sklearn import datasets

# Load the iris dataset
iris = datasets.load_iris()
X = iris['data']
y = iris['target']

Useremo il training set per addestrare il nostro modello quantistico e il test set per valutarne le prestazioni. Possiamo suddividere il set di dati utilizzando la train_test_splitfunzione dal sklearn.model_selectionmodulo:

from sklearn.model_selection import train_test_split

# Split the dataset into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Prima di poter utilizzare i dati per addestrare il nostro modello quantistico, dobbiamo preelaborarlo. Una fase di pre-elaborazione comune è la normalizzazione, che ridimensiona i dati in modo che abbiano media zero e varianza unitaria. Possiamo eseguire la normalizzazione utilizzando la StandardScalerclasse dal sklearn.preprocessingmodulo:

from sklearn.preprocessing import StandardScaler

# Initialize the scaler
scaler = StandardScaler()

# Fit the scaler to the training data
scaler.fit(X_train)

# Scale the training and test data
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)

La normalizzazione è un'importante fase di pre-elaborazione perché garantisce che tutte le caratteristiche dei dati siano sulla stessa scala, il che può migliorare le prestazioni del modello quantistico.

Passaggio 5: definire il modello quantistico.

Ora siamo pronti per definire il nostro modello quantistico utilizzando la PennyLanelibreria. Il primo passo è importare le funzioni necessarie e creare un dispositivo quantistico:

import pennylane as qml

# Choose a device (e.g., 'default.qubit')
device = qml.device('default.qubit')

@qml.qnode(device)
def quantum_neural_net(weights, data):
    # Initialize the qubits
    qml.templates.AmplitudeEmbedding(weights, data)

    # Apply a layer of quantum neurons
    qml.templates.StronglyEntanglingLayers(weights, data)

    # Measure the qubits
    return qml.expval(qml.PauliZ(0))

La prima riga inizializza i qubit utilizzando il AmplitudeEmbeddingmodello da PennyLane. Questo modello mappa i dati sulle ampiezze dei qubit in modo da preservare la distanza tra i punti dati.

La seconda riga applica uno strato di neuroni quantistici utilizzando il StronglyEntanglingLayersmodello. Questo modello applica una serie di operazioni di entanglement ai qubit, che possono essere utilizzate per implementare il calcolo quantistico universale.

Infine, l'ultima riga misura i qubit nella base Pauli-Z e restituisce il valore atteso.

Passaggio 6: definire una funzione di costo.

Per addestrare il nostro modello quantistico, dobbiamo definire una funzione di costo che misuri le prestazioni del modello. Per questo tutorial, useremo l'errore quadratico medio (MSE) come nostra funzione di costo:

def cost(weights, data, labels):
    # Make predictions using the quantum neural network
    predictions = quantum_neural_net(weights, data)

    # Calculate the mean squared error
    mse = qml.mean_squared_error(labels, predictions)

    return mse

L'MSE è una funzione di costo comune nell'apprendimento automatico e misura la differenza quadratica media tra i valori previsti e i valori reali. Un MSE più piccolo indica un migliore adattamento del modello ai dati.

Passaggio 7: addestrare il modello quantistico.

Ora siamo pronti per addestrare il nostro modello quantistico usando la discesa del gradiente. Useremo la AdamOptimizerclasse from PennyLaneper eseguire l'ottimizzazione:

# Initialize the optimizer
opt = qml.AdamOptimizer(stepsize=0.01)

# Set the number of training steps
steps = 100

# Set the initial weights
weights = np.random.normal(0, 1, (4, 2))

# Train the model
for i in range(steps):
    # Calculate the gradients
    gradients = qml.grad(cost, argnum=0)(weights, X_train_scaled, y_train)

    # Update the weights
    opt.step(gradients, weights)

    # Print the cost
    if (i + 1) % 10 == 0:
        print(f'Step {i + 1}: cost = {cost(weights, X_train_scaled, y_train):.4f}')

In ogni fase di addestramento, il codice calcola i gradienti della funzione di costo rispetto ai pesi utilizzando la qml.gradfunzione. Quindi aggiorna i pesi utilizzando il opt.stepmetodo e stampa il costo ogni 10 passaggi.

La discesa del gradiente è un algoritmo di ottimizzazione comune nell'apprendimento automatico che prevede l'aggiornamento iterativo dei parametri del modello per ridurre al minimo la funzione di costo. È AdamOptimizeruna variante della discesa del gradiente che utilizza un tasso di apprendimento adattivo, che può aiutare l'ottimizzazione a convergere più velocemente.

Passaggio 8: valutare il modello quantistico.

Ora che abbiamo addestrato il nostro modello quantistico, possiamo valutarne le prestazioni sul set di test. Possiamo farlo usando il seguente codice:

# Make predictions on the test set
predictions = quantum_neural_net(weights, X_test_scaled)

# Calculate the accuracy
accuracy = qml.accuracy(predictions, y_test)

print(f'Test accuracy: {accuracy:.2f}')

Passaggio 9: visualizza i risultati.

Infine, possiamo visualizzare i risultati del nostro modello quantistico utilizzando Matplotlib. Ad esempio, possiamo tracciare le previsioni sul set di test rispetto alle etichette vere:

import matplotlib.pyplot as plt

# Plot the predictions
plt.scatter(y_test, predictions)

# Add a diagonal line
x = np.linspace(0, 3, 4)
plt.plot(x, x, '--r')

# Add axis labels and a title
plt.xlabel('True labels')
plt.ylabel('Predictions')
plt.title('Quantum Neural Network')

# Show the plot
plt.show()

E questo è tutto! Abbiamo costruito con successo un modello di machine learning quantistico e ne abbiamo valutato le prestazioni su un set di dati di esempio.

Risultati

Per testare le prestazioni del modello quantistico, abbiamo eseguito il codice fornito nel tutorial e ottenuto i seguenti risultati:

Step 10: cost = 0.5020
Step 20: cost = 0.3677
Step 30: cost = 0.3236
Step 40: cost = 0.3141
Step 50: cost = 0.3111
Step 60: cost = 0.3102
Step 70: cost = 0.3098
Step 80: cost = 0.3095
Step 90: cost = 0.3093
Step 100: cost = 0.3092
Test accuracy: 0.87

Conclusione

L'apprendimento automatico quantistico è un campo entusiasmante con molte potenziali applicazioni, dall'ottimizzazione delle catene di approvvigionamento alla previsione dei prezzi delle azioni. Speriamo che questo tutorial ti abbia dato un assaggio di ciò che è possibile fare con i computer quantistici e l'apprendimento automatico e che ti abbia ispirato a saperne di più su questo affascinante argomento.

Se hai domande o hai bisogno di ulteriori chiarimenti, non esitare a chiedere!