Quantenmaschinelles Lernen: Ein Leitfaden für Anfänger

​Bugatti

Rezensent |. 🎜🎜#

Willkommen in der Welt des Quantenmaschinellen Lernens! Dieses Tutorial bietet eine schrittweise Anleitung mit Code durch ein Starterprojekt unter Verwendung eines Beispieldatensatzes. Am Ende dieses Tutorials verfügen Sie über ein grundlegendes Verständnis dafür, wie Sie einen Quantencomputer zur Durchführung maschineller Lernaufgaben verwenden und dabei helfen, Ihr erstes Quantenmodell zu erstellen.

Aber bevor wir in dieses Tutorial eintauchen, wollen wir verstehen, was Quantenmaschinelles Lernen ist und warum es so spannend ist.

Quantum Machine Learning ist der Bereich, in dem Quantencomputing und maschinelles Lernen zusammenlaufen. Es verwendet Quantencomputer, um maschinelle Lernaufgaben wie Klassifizierung, Regression und Clustering auszuführen. Ein Quantencomputer ist eine leistungsstarke Maschine, die Quantenbits (Qubits) anstelle herkömmlicher Bits zum Speichern und Verarbeiten von Informationen verwendet. Dadurch können sie bestimmte Aufgaben deutlich schneller erledigen als herkömmliche Computer und eignen sich daher besonders für maschinelle Lernaufgaben mit großen Datenmengen.

Starten Sie jetzt das Tutorial!

Schritt 1: Erforderliche Bibliotheken und Abhängigkeiten installieren.

In diesem Tutorial verwenden wir die PennyLane-Bibliothek für Quantenmaschinelles Lernen, NumPy für numerische Berechnungen und Matplotlib für die Datenvisualisierung. Sie können diese Bibliotheken mit pip installieren, indem Sie den folgenden Befehl ausführen:

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

Schritt 2: Laden Sie den Beispieldatensatz.

In diesem Tutorial verwenden wir den Iris-Datensatz, der aus 150 Stichproben von Irisblüten mit vier Merkmalen besteht: Kelchblattlänge, Kelchblattbreite, Blütenblattlänge und Blütenblattbreite. Der Datensatz ist in der sklearn-Bibliothek enthalten, sodass wir ihn mit dem folgenden Code laden können:

from sklearn import datasets

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

Schritt 3: Teilen Sie den Datensatz in Trainings- und Testsätze auf.

Wir werden den Trainingssatz verwenden, um unser Quantenmodell zu trainieren, und den Testsatz, um seine Leistung zu bewerten. Wir können die Funktion train_test_split aus dem Modul sklearn.model_selection verwenden, um den Datensatz aufzuteilen:

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)

Schritt 4: Verarbeiten Sie die Daten vor.

Bevor wir die Daten zum Trainieren eines Quantenmodells verwenden können, müssen wir die Daten vorverarbeiten. Ein üblicher Vorverarbeitungsschritt ist die Normalisierung, bei der die Daten so angepasst werden, dass sie einen Mittelwert von Null und eine Einheitsvarianz aufweisen. Wir können die StandardScaler-Klasse aus dem sklearn.preprocessing-Modul verwenden, um eine Normalisierung durchzuführen:

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)

Dieser Code initialisiert das StandardScaler-Objekt und verwendet die Fit-Methode, um es an die Trainingsdaten anzupassen. Anschließend werden die Trainings- und Testdaten mithilfe der Transformationsmethode angepasst.

Der Grund, warum die Normalisierung ein wichtiger Vorverarbeitungsschritt ist, besteht darin, dass sie sicherstellt, dass alle Merkmale der Daten im gleichen Maßstab liegen, was die Leistung von Quantenmodellen verbessern kann.

Schritt 5: Definieren Sie das Quantenmodell.

Jetzt können wir die PennyLane-Bibliothek verwenden, um das Quantenmodell zu definieren. Der erste Schritt besteht darin, die notwendigen Funktionen zu importieren und das Quantengerät zu erstellen:

import pennylane as qml

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

Als nächstes definieren wir eine Quantenfunktion, die Daten als Eingabe aufnimmt und eine Vorhersage zurückgibt. Wir werden ein einfaches Quantenneuronales Netzwerk mit nur einer Schicht Quantenneuronen verwenden:

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

Diese Quantenfunktion nimmt zwei Variablen auf: Gewichte (die die Parameter des Quantenneuronalen Netzwerks sind) und Daten (die sind). die Eingabedaten).

Die erste Zeile initialisiert das Qubit mithilfe der AmplitudeEmbedding-Vorlage von PennyLane. Die Vorlage ordnet Daten der Amplitude des Qubits zu, sodass der Abstand zwischen Datenpunkten erhalten bleibt.

Die zweite Zeile verwendet die StronglyEntanglingLayers-Vorlage, um eine Schicht aus Quantenneuronen anzuwenden. Die Vorlage wendet eine Reihe von Verschränkungsoperationen auf Qubits an, die dann zur Implementierung universellen Quantencomputings verwendet werden können.

Schließlich misst die letzte Zeile das Qubit auf Pauli-Z-Metrikbasis und gibt den erwarteten Wert zurück.

Schritt 6: Definieren Sie die Kostenfunktion.

Um ein Quantenmodell zu trainieren, müssen wir eine Kostenfunktion definieren, um zu messen, wie gut das Modell funktioniert. Für die Zwecke dieses Tutorials verwenden wir den mittleren quadratischen Fehler (MSE) als Kostenfunktion:

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

Diese Kostenfunktion berücksichtigt drei Variablen: Gewichte (die Parameter des Quantenmodells) , Daten (die Eingabedaten sind) und Beschriftungen (die tatsächlichen Beschriftungen der Daten). Es verwendet ein neuronales Quantennetzwerk, um Vorhersagen auf der Grundlage von Eingabedaten zu treffen, und berechnet den MSE zwischen Vorhersagen und echten Etiketten.

MSE ist eine gängige Kostenfunktion beim maschinellen Lernen, die die mittlere quadratische Differenz zwischen dem vorhergesagten Wert und dem wahren Wert misst. Ein kleinerer MSE zeigt an, dass das Modell besser zu den Daten passt.

Schritt 7: Trainieren Sie das Quantenmodell.

Jetzt sind wir bereit, die Gradientenabstiegsmethode zum Trainieren des Quantenmodells zu verwenden. Wir werden die AdamOptimizer-Klasse von PennyLane verwenden, um die Optimierung durchzuführen:

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

Dieser Code initialisiert den Optimierer mit einer Schrittgröße von 0,01 und setzt die Anzahl der Trainingsschritte auf 100. Anschließend werden die Anfangsgewichte des Modells auf zufällige Werte gesetzt, die aus einer Normalverteilung mit Mittelwert 0 und Standardabweichung 1 stammen.

Bei jedem Trainingsschritt verwendet der Code die Funktion qml.grad, um den Gradienten der Kostenfunktion in Bezug auf die Gewichte zu berechnen. Anschließend aktualisiert es die Gewichte mithilfe der opt.step-Methode und gibt die Kosten alle 10 Schritte aus.

梯度下降法是机器学习中常见的优化算法，它迭代更新模型参数以最小化成本函数。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​

Das obige ist der detaillierte Inhalt vonQuantenmaschinelles Lernen: Ein Leitfaden für Anfänger. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!