Pembelajaran Mesin Kuantum: Panduan Pemula

​Penterjemah |. Bugatti

Pengulas |. pembelajaran mesin kuantum! Tutorial ini menyediakan panduan langkah demi langkah dengan kod melalui projek pengenalan menggunakan set data sampel. Menjelang akhir tutorial ini, anda akan mempunyai pemahaman asas tentang cara menggunakan komputer kuantum untuk melaksanakan tugas pembelajaran mesin dan membantu membina model kuantum pertama anda.

Tetapi sebelum menyelami tutorial ini, mari kita fahami apa itu pembelajaran mesin kuantum dan mengapa ia begitu mengujakan.

Pembelajaran mesin kuantum ialah bidang di mana pengkomputeran kuantum dan pembelajaran mesin bercantum. Ia menggunakan komputer kuantum untuk melaksanakan tugas pembelajaran mesin seperti pengelasan, regresi dan pengelompokan. Komputer kuantum ialah mesin berkuasa yang menggunakan bit kuantum (qubit) dan bukannya bit tradisional untuk menyimpan dan memproses maklumat. Ini membolehkan mereka melaksanakan tugas tertentu dengan lebih pantas daripada komputer tradisional, menjadikannya sangat sesuai untuk tugas pembelajaran mesin yang melibatkan sejumlah besar data.

Mulakan tutorial sekarang!

Langkah 1: Pasang perpustakaan dan kebergantungan yang diperlukan.

Kami akan menggunakan perpustakaan PennyLane untuk pembelajaran mesin kuantum, NumPy untuk pengiraan berangka dan Matplotlib untuk visualisasi data dalam tutorial ini. Anda boleh memasang perpustakaan ini menggunakan pip dengan menjalankan arahan berikut:

Langkah 2: Muatkan set data sampel.

Kami akan menggunakan set data Iris dalam tutorial ini, yang terdiri daripada 150 sampel bunga iris dengan empat ciri: panjang sepal, lebar sepal, panjang kelopak dan lebar kelopak. Set data disertakan dalam pustaka sklearn, jadi kami boleh memuatkannya menggunakan kod berikut:

Langkah 3: Pisahkan set data kepada set latihan dan ujian.

Kami akan menggunakan set latihan untuk melatih model kuantum kami dan set ujian untuk menilai prestasinya. Kita boleh memisahkan set data menggunakan fungsi train_test_split daripada modul sklearn.model_selection:

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

Langkah 4: Praproses data.

Sebelum kita boleh menggunakan data untuk melatih model kuantum, kita perlu praproses data. Langkah prapemprosesan biasa ialah normalisasi, iaitu melaraskan data supaya ia mempunyai min sifar dan varians unit. Kita boleh menggunakan kelas StandardScaler daripada modul sklearn.preprocessing untuk melaksanakan normalisasi:

from sklearn import datasets

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

Kod ini memulakan objek StandardScaler dan menyesuaikannya dengan data latihan menggunakan kaedah muat. Kemudian, ia menggunakan kaedah transformasi untuk melaraskan data latihan dan ujian.

Sebab mengapa penormalan merupakan langkah pra-pemprosesan yang penting ialah ia memastikan semua ciri data berada pada skala yang sama, yang boleh meningkatkan prestasi model kuantum.

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)

Langkah 5: Tentukan model kuantum.

Kini kami bersedia untuk menggunakan perpustakaan PennyLane untuk menentukan model kuantum. Langkah pertama ialah mengimport fungsi yang diperlukan dan mencipta peranti kuantum:

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)

Seterusnya, kami akan mentakrifkan fungsi kuantum yang mengambil data sebagai input dan mengembalikan ramalan. Kami akan menggunakan rangkaian neural kuantum mudah dengan hanya satu lapisan neuron kuantum:

Fungsi kuantum ini mengambil dua pembolehubah: pemberat (yang merupakan parameter rangkaian neural kuantum) dan data (iaitu data input).

Barisan pertama memulakan qubit menggunakan templat AmplitudeEmbedding daripada PennyLane. Templat memetakan data ke amplitud qubit supaya jarak antara titik data dikekalkan.

Barisan kedua menggunakan templat StronglyEntanglingLayers untuk menggunakan lapisan neuron kuantum. Templat menggunakan satu siri operasi pengikat pada qubit, yang kemudiannya boleh digunakan untuk melaksanakan pengkomputeran kuantum universal.

import pennylane as qml

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

Akhir sekali, baris terakhir mengukur qubit dalam asas metrik Pauli-Z dan mengembalikan nilai yang dijangkakan.

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

Langkah 6: Tentukan fungsi kos.

Untuk melatih model kuantum, kita perlu menentukan fungsi kos untuk mengukur prestasi model tersebut. Untuk tujuan tutorial ini, kami akan menggunakan ralat min kuasa dua (MSE) sebagai fungsi kos:

Fungsi kos ini mengambil tiga pembolehubah: pemberat (yang merupakan parameter model kuantum) , data (iaitu parameter model kuantum) data input) dan label (yang merupakan label sebenar data). Ia menggunakan rangkaian neural kuantum untuk membuat ramalan berdasarkan data input dan mengira MSE antara ramalan dan label benar.

MSE ialah fungsi kos biasa dalam pembelajaran mesin yang mengukur perbezaan kuasa dua min antara nilai ramalan dan nilai sebenar. MSE yang lebih kecil menunjukkan bahawa model itu lebih sesuai dengan data.

Langkah 7: Latih model kuantum.

Kini, kami bersedia untuk melatih model kuantum menggunakan keturunan kecerunan. Kami akan menggunakan kelas AdamOptimizer daripada PennyLane untuk melaksanakan pengoptimuman:

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

Kod ini memulakan pengoptimum dengan saiz langkah 0.01 dan menetapkan bilangan langkah latihan kepada 100. Ia kemudian menetapkan pemberat awal model kepada nilai rawak yang diambil daripada taburan normal dengan min 0 dan sisihan piawai 1.

Pada setiap langkah latihan, kod menggunakan fungsi qml.grad untuk mengira kecerunan fungsi kos berkenaan dengan pemberat. Ia kemudian mengemas kini pemberat menggunakan kaedah opt.step dan mengeluarkan kos setiap 10 langkah.

梯度下降法是机器学习中常见的优化算法，它迭代更新模型参数以最小化成本函数。AdamOptimizer是梯度下降的一种变体，它使用自适应学习率，这可以帮助优化更快地收敛。

第8步：评估量子模型。

我们已经训练了量子模型，可以评估它在测试集上的性能。我们可以使用以下代码来测试：

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

这段代码使用量子神经网络基于测试集做预测，并使用qml.accuracy 函数计算预测准确性。然后，它输出测试准确性。

第9步：直观显示结果。

最后，我们可以使用Matplotlib直观显示量子模型的结果。比如说，我们可以对照真实标签绘制出测试集的预测结果：

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

这段代码将对照真实标签创建预测的散点图，增添对角线以表示完美预测。然后它为散点图添加轴线标签和标题，并使用plt.show函数来显示。

现在，我们已成功地构建了一个量子机器学习模型，并在示例数据集上评估了性能。

结果

为了测试量子模型的性能，我们运行了教程中提供的代码，获得了以下结果：

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

这些结果表明，量子模型能够从训练数据中学习，并基于测试集做出准确的预测。在整个训练过程中，成本稳步下降，这表明模型在学习过程中不断改进。最终的测试准确率为0.87，表现相当好，这表明该模型能够正确地分类大部分测试样例。

结论

量子机器学习是一个令人兴奋的领域，有许多潜在的应用，从优化供应链到预测股价，不一而足。我们希望本教程能让您了解量子计算机和机器学习的可能性，并激励您深入了解这个诱人的话题。

原文标题：​​Quantum Machine Learning: A Beginner’s Guide​​，作者：SPX​

Atas ialah kandungan terperinci Pembelajaran Mesin Kuantum: Panduan Pemula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!