German
Languages
English
Bengali
French
German
Japanese
Korean
Portuguese
Spanish
Tamil

Einführung in Qiskit

Bei der Verwendung von Qiskit besteht ein Benutzerworkflow nominell aus den folgenden vier high-level Schritten:

  • Build: Entwerfen Sie eine Quantenschaltung(en), die das von Ihnen betrachtete Problem darstellt.

  • ** Compile**: Kompiliert Schaltungen für einen bestimmten Quantendienst, z.B. ein Quantensystem oder einen klassischer Simulator.

  • Run: Führt die kompilierten Schaltkreise auf dem/den angegebenen Quantendienst(en) aus. Diese Dienste können Cloud-basiert oder lokal sein.

  • Analyze: Berechnet zusammenfassende Statistiken und visualisiert die Ergebnisse der Experimente.

Hier ist ein Beispiel für den gesamten Workflow, wobei jeder Schritt in folgenden Abschnitten ausführlich erläutert wird:

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram

# Use Aer's qasm_simulator
simulator = QasmSimulator()

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)

# Add a H gate on qubit 0
circuit.h(0)

# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)

# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])

# compile the circuit down to low-level QASM instructions
# supported by the backend (not needed for simple circuits)
compiled_circuit = transpile(circuit, simulator)

# Execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=1000)

# Grab results from the job
result = job.result()

# Returns counts
counts = result.get_counts(compiled_circuit)
print("\nTotal count for 00 and 11 are:",counts)

# Draw the circuit
circuit.draw()

Total count for 00 and 11 are: {'00': 513, '11': 487}
     ┌───┐     ┌─┐   
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1 
# Plot a histogram
plot_histogram(counts)
_images/intro_tutorial1_1_0.png

Workflow Schritt für Schritt

Das obige Programm kann in sechs Schritte untergliedert werden:

  1. Pakete importieren

  2. Variablen initialisieren

  3. Gates hinzufügen

  4. Den Schaltkreis visualisieren

  5. Das Experiment simulieren

  6. Die Ergebnisse visualisieren

Schritt 1 : Pakete importieren

So werden die Grundbausteine für das Programm importiert:

import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram

Im Einzelnen sind die Importe

  • ` ` QuantumCircuit ` `: kann als die Befehle des Quantensystems angesehen werden. Er enthält alle Quantenoperationen.

  • ` ` QasmSimulator ` `: ist der Aer Hochleistungs Schaltungssimulator.

  • ` ` plot_histogram ` `: erzeugt Histogramme.

Schritt 2: Variablen initialisieren

Betrachten Sie die nächste Codezeile

circuit = QuantumCircuit(2, 2)

Hier wird ein Quantenschaltkreis circuit definiert, bestehend aus zwei Qubits im Basiszustand 0 und zwei auf 0 gesetzten klassischen Bits.

Syntax:

  • QuantumCircuit(int, int)

Schritt 3 : Gates hinzufügen

Sie können Gates (Operationen) hinzufügen, um die Register Ihrer Schaltung zu manipulieren.

Betrachten Sie die folgenden drei Zeilen Code:

circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0,1], [0,1])

Die Gates werden nacheinander hinzugefügt um den Bell-Zustand zu bilden

\[|\psi\rangle = \left(|00\rangle+|11\rangle\right)/\sqrt{2}.\]

Der obige Code verwendet die folgenden Gates:

  • QuantumCircuit.h(0): Ein Hadamard-Gate \(H\) auf Qubit 0, welches das Qubit in einen Zustand der Superposition (superposition state) überführt.

  • QuantumCircuit.cx(0, 1): Ein Controlled-Not Operator (\(CNOT\)) mit Kontroll-Qubit 0 und Ziel-Qubit 1. Damit werden diese Qubits in einen quantenmechanisch verschränkten Zustand gebracht.

  • QuantumCircuit.measure([0,1], [0,1]): Werden die Quanten- und klassischen Register als Ganzes an measure übergeben, wird das Messergebnis des i-ten Qubits im i-ten klassischen Bit gespeichert.

Schritt 4 : Den Schaltkreis visualisieren

Sie können :meth:` qiskit.circuit.QuantumCircuit.draw ` verwenden, um die von Ihnen entworfenen Schaltung so anzuzeigen, wie sie in vielen Lehrbüchern und Forschungsartikeln dargestellt werden.

circuit.draw()
     ┌───┐     ┌─┐   
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1 

In diesem Schaltkreis sind die Qubits so angeordnet, dass sich Qubit 0 oben und Qubit 1 unten befindet. Der Schaltkreis wird von links nach rechts gelesen. Gates welche früher hinzugefügt wurden befinden sich also weiter links.

Das Standard-Backend für QuantumCircuit.draw() oder qiskit.visualization.circuit_drawer() ist das Text-Backend. Dies kann man, abhängig von der lokalen Entwicklungsumgebung, nach Belieben konfigurieren. Die Konfigurationsdatei dafür befindet sich normalerweise in ~/.qiskit/settings.config. Dies ist eine .ini-Datei.

Zum Beispiel wird eine Datei ` `settings.conf ` ` zum Festlegen einer Matplotlib-Eigenschaft zum Zeichnen verwendet:

[default]
circuit_drawer = mpl

Jedes verfügbare gültige Schaltkreis-Zeichner-Backend kann verwendet werden wie zum Beispiel text, mpl, latex und latex_source.

Schritt 5 : Ein Experiment simulieren

Qiskit Aer ist ein hochperformantes Simulations-Framework für Quantenschaltkreise. Es stellt diverse Backends für verschiedene Simulationszwecke zur Verfügung.

Wenn Sie Probleme mit der Installation von Aer haben, können Sie alternativ den Basic-Aer-Provider verwenden, indem Sie ` Aer ` durch ` BasicAer ` ersetzen. Basic-Aer ist in Qiskit-Terra enthalten.

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basicaer import QasmSimulatorPy
...

Um diese Schaltung zu simulieren soll der ` ` qasm_simulator ` ` verwendet werden. Jeder Durchlauf dieser Schaltung ergibt entweder die Bitfolge 00 oder 11.

simulator = QasmSimulator()
compiled_circuit = transpile(circuit, simulator)
job = simulator.run(compiled_circuit, shots=1000)
result = job.result()
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)

Total count for 00 and 11 are: {'00': 491, '11': 509}

Wie erwartet, wird die Bit-Zeichenkette 00 in ungefähr 50 Prozent der Fälle ausgegeben. Die Anzahl der Fälle, in denen die Schaltung ausgeführt wird, kann über das Argument shots der Methode``execute`` festgelegt werden. Die Anzahl der Shots der Simulation wurde auf 1000 eingestellt (die Standardeinstellung ist 1024).

Sobald das result Objekt verfügbar ist, kann man auf das Ergebnis mit der Methode get_counts(circuit) zugreifen. Dadurch erhält man die zusammengefassten Ergebnisse des Experiments.

Schritt 6 : Die Ergebnisse visualisieren

Qiskit stellt viele Visualisierungen zur Verfügung,

inklusive der Funktion plot_histogram um die Ergebnisse anzuzeigen.

plot_histogram(counts)
_images/intro_tutorial1_4_0.png

Die beobachteten Wahrscheinlichkeiten \(Pr(00)\) and \(Pr(11)\) ergeben sich aus den jeweiligen Auszählungen geteilt durch die Anzahl der Durchläufe.

Bemerkung

Versuchen Sie, das Schlüsselwort shots in der Methode run() zu ändern, um zu sehen, wie sich die geschätzten Wahrscheinlichkeiten ändern.

Nächste Schritte

Jetzt, wo Sie die Grundlagen gelernt haben, betrachten Sie einmal dieses Lernmaterial: