Ergebnisse visualisieren

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen, diese oder neuere Versionen zu verwenden.

qiskit[all]~=2.5.2

Histogramm plotten

Die Funktion plot_histogram visualisiert das Ergebnis des Samplings eines Quantum Circuit auf einer QPU.

Ausgaben von Funktionen verwenden

Diese Funktion gibt ein matplotlib.Figure-Objekt zurück. Wenn die letzte Zeile einer Code-Zelle solche Objekte ausgibt, zeigen Jupyter-Notebooks sie unterhalb der Zelle an. Wenn du diese Funktionen in anderen Umgebungen oder in Skripten aufrufst, musst du die Ausgaben explizit anzeigen oder speichern.

Zwei Möglichkeiten sind:

• Rufe .show() auf dem zurückgegebenen Objekt auf, um das Bild in einem neuen Fenster zu öffnen (sofern dein konfiguriertes Matplotlib-Backend interaktiv ist).
• Rufe .savefig("out.png") auf, um die Abbildung als out.png im aktuellen Arbeitsverzeichnis zu speichern. Die Methode savefig() akzeptiert einen Pfad, sodass du Speicherort und Dateiname anpassen kannst. Zum Beispiel: plot_state_city(psi).savefig("out.png").

Erstelle zum Beispiel einen Zwei-Qubit-Bell-Zustand:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit.primitives import StatevectorSampler as Sampler
from qiskit.transpiler import generate_preset_pass_manager

from qiskit.circuit import QuantumCircuit
from qiskit.visualization import plot_histogram

# Quantum circuit to make a Bell state
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()

pm = generate_preset_pass_manager(optimization_level=1)
isa_circuit = pm.run(bell)

# execute the quantum circuit
sampler = Sampler()
job = sampler.run([isa_circuit])
result = job.result()

print(result)

PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(), num_shots=1024, num_bits=2>)), metadata={'shots': 1024, 'circuit_metadata': {}})], metadata={'version': 2})

plot_histogram(result[0].data.meas.get_counts())

Optionen beim Plotten eines Histogramms

Verwende die folgenden Optionen für plot_histogram, um das Ausgabediagramm anzupassen.

• legend: Gibt eine Beschriftung für die Ausführungen an. Es wird eine Liste von Zeichenketten übergeben, die die Ergebnisse jeder Ausführung beschriften. Dies ist vor allem nützlich, wenn mehrere Ausführungsergebnisse im selben Histogramm dargestellt werden

• sort: Passt die Reihenfolge der Balken im Histogramm an. Es kann entweder auf aufsteigende Reihenfolge mit asc oder absteigende Reihenfolge mit desc gesetzt werden

• number_to_keep: Erwartet eine ganze Zahl, die die Anzahl der anzuzeigenden Terme angibt. Die restlichen werden in einem einzelnen Balken namens „rest" zusammengefasst

• color: Passt die Farbe der Balken an; nimmt eine Zeichenkette oder eine Liste von Zeichenketten für die Farben der Balken jeder Ausführung

• bar_labels: Legt fest, ob Beschriftungen über den Balken angezeigt werden

• figsize: Nimmt ein Tupel mit der Größe in Zoll für die Ausgabeabbildung

# Execute two-qubit Bell state again

job = sampler.run([isa_circuit], shots=1000)
second_result = job.result()

# Plot results with custom options
plot_histogram(
    [
        result[0].data.meas.get_counts(),
        second_result[0].data.meas.get_counts(),
    ],
    legend=["first", "second"],
    sort="desc",
    figsize=(15, 12),
    color=["orange", "black"],
    bar_labels=False,
)

Estimator-Ergebnisse plotten

Qiskit verfügt über keine integrierte Funktion zum Plotten von Estimator-Ergebnissen, aber du kannst Matplotlibs bar-Plot für eine schnelle Visualisierung verwenden.

Zur Veranschaulichung schätzt die folgende Zelle die Erwartungswerte von sieben verschiedenen Observablen für einen Quantenzustand.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator as Estimator
from qiskit.transpiler import generate_preset_pass_manager
from matplotlib import pyplot as plt

# Simple estimation experiment to create results
qc = QuantumCircuit(2)
qc.h(0)
qc.crx(1.5, 0, 1)

observables_labels = ["ZZ", "XX", "YZ", "ZY", "XY", "XZ", "ZX"]
observables = [SparsePauliOp(label) for label in observables_labels]

pm = generate_preset_pass_manager(optimization_level=1)
isa_circuit = pm.run(qc)
isa_observables = [
    operator.apply_layout(isa_circuit.layout) for operator in observables
]

# Reshape observable array for broadcasting
reshaped_ops = np.fromiter(isa_observables, dtype=object)
reshaped_ops = reshaped_ops.reshape((7, 1))

estimator = Estimator()
job = estimator.run([(isa_circuit, reshaped_ops)])
result = job.result()[0]
exp_val = job.result()[0].data.evs
print(result)

# Since the result array is structured as a 2D array where each element is a
# list containing a single value, you need to flatten the array.

# Plot using Matplotlib
plt.bar(observables_labels, exp_val.flatten())

PubResult(data=DataBin(evs=np.ndarray(<shape=(7, 1), dtype=float64>), stds=np.ndarray(<shape=(7, 1), dtype=float64>), shape=(7, 1)), metadata={'target_precision': 0.0, 'circuit_metadata': {}})

<BarContainer object of 7 artists>

Die folgende Zelle verwendet den geschätzten Standardfehler jedes Ergebnisses und fügt ihn als Fehlerbalken hinzu. Eine vollständige Beschreibung des Plots findest du in der bar-Plot-Dokumentation.

standard_error = job.result()[0].data.stds

_, ax = plt.subplots()
ax.bar(
    observables_labels,
    exp_val.flatten(),
    yerr=standard_error.flatten(),
    capsize=2,
)
ax.set_title("Expectation values (with standard errors)")

Text(0.5, 1.0, 'Expectation values (with standard errors)')