Kostenlose Quantensimulatoren im Vergleich: Qiskit Aer vs. Cirq vs. PennyLane vs. CUDA-Q

Quantensimulatoren ermöglichen es Ihnen, Schaltkreise zu testen, ohne in Hardware-Warteschlangen zu warten oder pro Shot zu bezahlen. Aber bei sechs großen kostenlos verfügbaren Simulatoren – welchen sollten Sie verwenden? Hier ist eine praktische Aufschlüsselung.

Die schnelle Antwort

Qiskit Aer: Das Arbeitstier

Qiskit Aer ist der funktionsreichste kostenlose Simulator. Er unterstützt mehrere Simulationsmethoden:

• statevector_simulator: Exakte Simulation bis zu ~30 Qubits. Der Speicher skaliert mit 2ⁿ komplexen Zahlen (16 GB RAM für 30 Qubits erforderlich).
• qasm_simulator: Shot-basiertes Sampling mit Unterstützung für Rauschmodelle
• density_matrix: Simuliert gemischte Zustände und offene Quantensysteme
• mps: Matrix Product State — simuliert Schaltkreise mit begrenzter Verschränkung bis zu Hunderten von Qubits
• stabilizer: Nur Clifford-Schaltkreise, skaliert aber in polynomieller Zeit auf Tausende von Qubits

from qiskit_aer import AerSimulator

# Default: automatic method selection
sim = AerSimulator()

# Force a specific method
sim_sv = AerSimulator(method='statevector')
sim_dm = AerSimulator(method='density_matrix')
sim_mps = AerSimulator(method='matrix_product_state')

Wann Aer verwenden: Für jeden Qiskit-Workflow, für Rauschmodellierung oder wenn Sie das Verhalten von IBM-Hardware möglichst genau nachbilden möchten.

PennyLane: Am besten für Quantum ML

PennyLane glänzt, wenn Sie differenzierbare Schaltkreise benötigen. Der default.qubit-Simulator berechnet exakte Gradienten über die Parameter-Shift-Regel und ermöglicht so die gradientenbasierte Optimierung von Quantenschaltkreisen:

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def circuit(theta):
    qml.RX(theta[0], wires=0)
    qml.RY(theta[1], wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Automatic gradient computation
grad_fn = qml.grad(circuit)
theta = np.array([0.5, 1.2])
print(grad_fn(theta))  # exact gradient

Für schnellere Simulation ohne Gradienten verwenden Sie lightning.qubit (C++-Backend, ~10× schneller als default.qubit):

pip install pennylane-lightning

dev = qml.device("lightning.qubit", wires=20)

Wann PennyLane verwenden: Variationsalgorithmen (VQE, QAOA), Quantum ML, jeder Workflow, der Schaltkreis-Gradienten erfordert.

NVIDIA CUDA-Q: Wenn Geschwindigkeit zählt

CUDA-Q bietet GPU-beschleunigte Simulation, die für große Schaltkreise 100–10.000× schneller sein kann als CPU-Simulatoren. Wenn Sie irgendeine NVIDIA-GPU besitzen, ist dies die richtige Wahl für Schaltkreise mit mehr als 25 Qubits:

import cudaq

@cudaq.kernel
def large_circuit(n: int):
    qvec = cudaq.qvector(n)
    h(qvec[0])
    for i in range(n - 1):
        cx(qvec[i], qvec[i + 1])
    mz(qvec)

# Run on GPU (specify 'nvidia' target)
cudaq.set_target('nvidia')
counts = cudaq.sample(large_circuit, 30, shots_count=10000)
print(counts)

Leistungs-Benchmark (GHZ-Schaltkreis, 28 Qubits, 1000 Shots):

• Qiskit Aer CPU: ~45 Sekunden
• PennyLane lightning.qubit: ~30 Sekunden
• CUDA-Q (A100 GPU): ~0,8 Sekunden

Wann CUDA-Q verwenden: Jeder Schaltkreis mit mehr als 25 Qubits, leistungskritische Simulationen, Multi-GPU-Workloads.

Cirq: Rauschmodellierung und NISQ-Forschung

Google Cirq enthält drei Simulatoren:

import cirq

# Exact statevector simulation
sim = cirq.Simulator()

# Density matrix with noise
noise_model = cirq.ConstantQubitNoiseModel(
    cirq.depolarize(p=0.01)
)
noisy_sim = cirq.DensityMatrixSimulator(noise=noise_model)

# Clifford circuits only (but exponentially faster for stabilizer states)
clifford_sim = cirq.CliffordSimulator()

Wann Cirq verwenden: NISQ-Rauschmodellierung, Forschung an Stabilizer-Schaltkreisen, Google-AI-Quantum-Workflows.

Amazon Braket LocalSimulator: Isolation und Portabilität

Das Braket SDK enthält einen kostenlosen lokalen Simulator, der die Cloud-API exakt abbildet:

from braket.devices import LocalSimulator
from braket.circuits import Circuit

device = LocalSimulator()

circuit = Circuit()
circuit.h(0)
circuit.cnot(0, 1)
circuit.probability()

task = device.run(circuit, shots=1000)
result = task.result()
print(result.measurement_counts)

Wann Braket local verwenden: Sie entwickeln für ein AWS-Deployment und möchten lokale Entwicklung/Tests, die der Cloud-API entsprechen.

Die HLQuantum-Abkürzung

Wenn Sie denselben Schaltkreis zum Benchmarking oder Vergleich auf mehreren Simulatoren ausführen müssen, macht HLQuantum dies zum Kinderspiel:

import hlquantum as hlq
import time

qc = hlq.Circuit(28)
qc.h(0)
for i in range(27):
    qc.cx(i, i + 1)
qc.measure_all()

for backend in ["qiskit", "pennylane", "cudaq"]:
    t0 = time.time()
    result = hlq.run(qc, shots=1000, backend=backend)
    print(f"{backend}: {time.time() - t0:.2f}s")

Ein Schaltkreis, drei Backends, direkt vergleichbare Ergebnisse.