top of page
  • Google+ Social Icon
  • Twitter Social Icon
  • LinkedIn Social Icon
  • Facebook Social Icon

quantenneuronales Netzwerk

  • Autorenbild: Martin Döhring
    Martin Döhring
  • vor 1 Stunde
  • 2 Min. Lesezeit

Hier ist ein vollständiges Beispielprogramm für ein quantenneuronales Netz (QNN) unter Verwendung von Qiskit, einem Framework von IBM für Quantencomputing in Python. Dieses Netzwerk verwendet ein variational circuit (Ansatz) und ein klassisches Trainingsverfahren zur binären Klassifikation einfacher Datenpunkte (z. B. XOR oder lineare Trennung).

⚙️ Voraussetzungen:

  • Python 3.x

  • Qiskit und Torch installiert:

pip install qiskit qiskit-machine-learning torch matplotlib

🧠 Beispiel: Quantenneuronales Netz (QNN) zur binären Klassifikation

import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer
from qiskit.utils import algorithm_globals, QuantumInstance
from qiskit_machine_learning.neural_networks import EstimatorQNN
from qiskit_machine_learning.connectors import TorchConnector
import torch
from torch import nn
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler

# Schritt 1: Daten vorbereiten (Mond-Datensatz)
X, y = make_moons(n_samples=200, noise=0.2, random_state=0)
X = MinMaxScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.float32)

# Schritt 2: Quantenansatz (Datenkodierung + Parametrisierung)
def create_qnn(num_qubits):
    qc = QuantumCircuit(num_qubits)

    # Datenkodierung (Angle Encoding)
    for i in range(num_qubits):
        qc.ry(np.pi * (i + 1), i)

    # Trainierbare Parameter (Ansatz)
    param_y = [f'y{i}' for i in range(num_qubits)]
    for i in range(num_qubits):
        qc.ry(f'@{param_y[i]}', i)

    return qc

# Schritt 3: QNN erstellen
quantum_instance = QuantumInstance(backend=Aer.get_backend("aer_simulator"), shots=1024, seed_simulator=42)
qnn = EstimatorQNN(
    circuit=create_qnn(2),
    input_params=[0, 1],  # Index der Eingabeparameter
    weight_params=[2, 3],  # Index der trainierbaren Parameter
    quantum_instance=quantum_instance
)

# Schritt 4: QNN in PyTorch-Wrapper (TorchConnector)
torch_qnn = TorchConnector(qnn)

# Schritt 5: Klassifizierer definieren
class QuantumClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.qnn = torch_qnn
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.qnn(x)
        x = self.sigmoid(x)
        return x

model = QuantumClassifier()
loss_fn = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.1)

# Schritt 6: Training
epochs = 30
for epoch in range(epochs):
    optimizer.zero_grad()
    output = model(X_train_tensor)
    loss = loss_fn(output.squeeze(), y_train_tensor)
    loss.backward()
    optimizer.step()
    print(f"Epoch {epoch+1} / {epochs}, Loss: {loss.item():.4f}")

# Optional: Genauigkeit auf Testdaten berechnen
X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
y_test_tensor = torch.tensor(y_test, dtype=torch.float32)
predictions = model(X_test_tensor).detach().numpy().squeeze()
predictions = np.round(predictions)

accuracy = np.mean(predictions == y_test_tensor.numpy())
print(f"Test Accuracy: {accuracy:.2f}")

📌 Hinweise

  • Dieses QNN nutzt angle encoding und einen einfachen Ansatz mit Ry-Rotationen.

  • Der EstimatorQNN ist ein von Qiskit bereitgestelltes Interface für Quantenschaltkreise mit automatischem Backpropagation-Support.

  • Du kannst das Netzwerk mit eigenen Daten testen (z. B. XOR, Gauss, etc.).

  • Der Code läuft komplett auf einem klassischen Simulator – kein echter Quantencomputer erforderlich.

Wenn du möchtest, kann ich dir den Code auch anpassen für:

  • Reale Molekülklassifikation (chemisches QNN)

  • Mehr Qubits / komplexere Ansätze (z. B. mit CNOT-Verschränkung)

  • Integration mit PennyLane (für hybride Backends)


1 comentario


Martin Döhring
Martin Döhring
vor einer Stunde

Hier bekommst du eine vollständige Implementierung eines quantenneuronalen Netzes (QNN) mit PennyLane, das auf hybriden Backends läuft (z. B. simuliert oder auf echten IBM-/IonQ-/Rigetti-Backends via braket, qiskit oder default.qubit).

✅ Voraussetzungen

Installiere die erforderlichen Pakete (am besten in einer frischen virtuellen Umgebung):

pip install pennylane torch matplotlib scikit-learn

🧠 Beispiel: Quantenneuronales Netz mit PennyLane und PyTorch

Wir nutzen einen binären Klassifikator auf dem berühmten XOR-Problem, das für lineare Modelle nicht lösbar ist – perfekt zur Demonstration der Quantenüberlegenheit!

import pennylane as qml from pennylane

import numpy as np import torch from torch

import nn import matplotlib.pyplot as plt from sklearn.datasets

import make_classification from sklearn.model_selection import train_test_split

# Schritt 1: Einfacher XOR-Datensatz X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) Y = np.array([0,…

Me gusta
SIGN UP AND STAY UPDATED!
  • Grey Google+ Icon
  • Grey Twitter Icon
  • Grey LinkedIn Icon
  • Grey Facebook Icon

© 2023 by Talking Business.  Proudly created with Wix.com Martin Döhring Engelstrasse 37 in D-55124 Mainz

bottom of page