pengantar

Selamat datang di dunia pembelajaran mesin kuantum! Dalam tutorial ini, kami akan memandu Anda melalui proyek tingkat pemula menggunakan kumpulan data sampel dan memberikan petunjuk langkah demi langkah dengan kode. Di akhir tutorial ini, Anda akan memiliki pemahaman yang kuat tentang cara menggunakan komputer kuantum untuk melakukan tugas pembelajaran mesin dan akan membangun model kuantum pertama Anda.

Namun sebelum kita menyelami tutorialnya, mari luangkan waktu sejenak untuk memahami apa itu pembelajaran mesin kuantum dan mengapa hal itu begitu menarik.

Pembelajaran mesin kuantum adalah bidang di persimpangan komputasi kuantum dan pembelajaran mesin. Ini melibatkan penggunaan komputer kuantum untuk melakukan tugas pembelajaran mesin, seperti klasifikasi, regresi, dan pengelompokan. Komputer kuantum adalah mesin canggih yang menggunakan bit kuantum (qubit), bukan bit klasik, untuk menyimpan dan memproses informasi. Ini memungkinkan mereka untuk melakukan tugas-tugas tertentu jauh lebih cepat daripada komputer klasik, membuatnya sangat cocok untuk tugas-tugas pembelajaran mesin yang melibatkan data dalam jumlah besar.

Sekarang, mari kita mulai tutorial kami!

Langkah 1: Instal pustaka dan dependensi yang diperlukan.

Untuk tutorial ini, kita akan menggunakan PennyLaneperpustakaan untuk pembelajaran mesin kuantum, serta NumPyuntuk komputasi numerik dan Matplotlibvisualisasi data. Anda dapat menginstal pustaka ini menggunakan pipdengan menjalankan perintah berikut:

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

Untuk tutorial ini, kita akan menggunakan dataset Iris yang terdiri dari 150 sampel bunga iris dengan empat fitur: panjang sepal, lebar sepal, panjang petal, dan lebar petal. Dataset disertakan dengan sklearnlibrary, sehingga kita dapat memuatnya menggunakan kode berikut:

from sklearn import datasets

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

Kami akan menggunakan set pelatihan untuk melatih model kuantum kami dan set pengujian untuk mengevaluasi kinerjanya. Kita dapat membagi dataset menggunakan train_test_splitfungsi dari sklearn.model_selectionmodul:

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)

Sebelum kita dapat menggunakan data untuk melatih model kuantum kita, kita perlu memprosesnya terlebih dahulu. Salah satu langkah prapemrosesan yang umum adalah normalisasi, yang menskalakan data sehingga memiliki rata-rata nol dan varian unit. Kita dapat melakukan normalisasi menggunakan StandardScalerkelas dari sklearn.preprocessingmodul:

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)

Normalisasi adalah langkah prapemrosesan yang penting karena memastikan bahwa semua fitur data berada pada skala yang sama, yang dapat meningkatkan kinerja model kuantum.

Langkah 5: Tentukan model kuantum.

Sekarang kami siap untuk mendefinisikan model kuantum kami menggunakan PennyLaneperpustakaan. Langkah pertama adalah mengimpor fungsi yang diperlukan dan membuat perangkat kuantum:

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))

Baris pertama menginisialisasi qubit menggunakan AmplitudeEmbeddingtemplat dari PennyLane. Templat ini memetakan data ke amplitudo qubit dengan cara yang menjaga jarak antara titik data.

Baris kedua menerapkan lapisan neuron kuantum menggunakan StronglyEntanglingLayerstemplat. Templat ini menerapkan serangkaian operasi pelibatan ke qubit, yang dapat digunakan untuk mengimplementasikan komputasi kuantum universal.

Terakhir, baris terakhir mengukur qubit dalam basis Pauli-Z dan mengembalikan nilai ekspektasi.

Langkah 6: Tentukan fungsi biaya.

Untuk melatih model kuantum kita, kita perlu menentukan fungsi biaya yang mengukur seberapa baik kinerja model. Untuk tutorial ini, kita akan menggunakan mean squared error (MSE) sebagai fungsi biaya kita:

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

MSE adalah fungsi biaya umum dalam pembelajaran mesin dan mengukur selisih kuadrat rata-rata antara nilai prediksi dan nilai sebenarnya. MSE yang lebih kecil menunjukkan model yang lebih cocok dengan data.

Langkah 7: Latih model kuantum.

Sekarang kami siap untuk melatih model kuantum kami menggunakan penurunan gradien. Kami akan menggunakan AdamOptimizerkelas dari PennyLaneuntuk melakukan optimasi:

# 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}')

Di setiap langkah pelatihan, kode menghitung gradien fungsi biaya sehubungan dengan bobot menggunakan qml.gradfungsi tersebut. Kemudian memperbarui bobot menggunakan opt.stepmetode dan mencetak biaya setiap 10 langkah.

Penurunan gradien adalah algoritme pengoptimalan umum dalam pembelajaran mesin yang melibatkan pembaruan parameter model secara iteratif untuk meminimalkan fungsi biaya. Ini AdamOptimizeradalah varian penurunan gradien yang menggunakan kecepatan pembelajaran adaptif, yang dapat membantu pengoptimalan menyatu lebih cepat.

Langkah 8: Evaluasi model kuantum.

Sekarang setelah kami melatih model kuantum kami, kami dapat mengevaluasi kinerjanya pada set pengujian. Kita dapat melakukannya dengan menggunakan kode berikut:

# 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}')

Langkah 9: Visualisasikan hasilnya.

Akhirnya, kita dapat memvisualisasikan hasil model kuantum kita menggunakan Matplotlib. Misalnya, kita dapat memplot prediksi pada set pengujian terhadap label sebenarnya:

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()

Dan itu saja! Kami telah berhasil membangun model pembelajaran mesin kuantum dan mengevaluasi kinerjanya pada kumpulan data sampel.

Hasil

Untuk menguji kinerja model kuantum, kami menjalankan kode yang disediakan dalam tutorial dan memperoleh hasil sebagai berikut:

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

Kesimpulan

Pembelajaran mesin kuantum adalah bidang yang menarik dengan banyak aplikasi potensial, mulai dari mengoptimalkan rantai pasokan hingga memprediksi harga saham. Kami harap tutorial ini memberi Anda gambaran tentang apa yang mungkin dilakukan dengan komputer kuantum dan pembelajaran mesin dan telah menginspirasi Anda untuk mempelajari lebih lanjut tentang topik yang menarik ini.

Jika Anda memiliki pertanyaan atau memerlukan klarifikasi lebih lanjut, jangan ragu untuk bertanya!