Visualiser les résultats

Versions des packages

Le code de cette page a été développé avec les prérequis suivants. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

Tracer un histogramme

La fonction plot_histogram visualise le résultat de l'échantillonnage d'un circuit quantique sur un QPU.

Utiliser la sortie des fonctions

Cette fonction retourne un objet matplotlib.Figure. Lorsque la dernière ligne d'une cellule de code produit ces objets, les notebooks Jupyter les affichent sous la cellule. Si tu appelles ces fonctions dans d'autres environnements ou dans des scripts, tu devras explicitement afficher ou sauvegarder les sorties.

Deux options s'offrent à toi :

• Appelle .show() sur l'objet retourné pour ouvrir l'image dans une nouvelle fenêtre (en supposant que le backend matplotlib configuré est interactif).
• Appelle .savefig("out.png") pour sauvegarder la figure dans out.png dans le répertoire de travail courant. La méthode savefig() prend un chemin en paramètre, ce qui te permet d'ajuster l'emplacement et le nom du fichier de sortie. Par exemple, plot_state_city(psi).savefig("out.png").

Par exemple, crée un état de Bell à deux qubits :

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-ibm-runtime

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit.transpiler import generate_preset_pass_manager

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

service = QiskitRuntimeService()

backend = service.least_busy(simulator=False, operational=True)

# 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(backend=backend, optimization_level=1)
isa_circuit = pm.run(bell)

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

print(result)

PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(), num_shots=4096, num_bits=2>)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-01-15 07:11:30', stop='2026-01-15 07:11:32', size=4096>)])}, 'version': 2})

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

Options pour tracer un histogramme

Utilise les options suivantes pour plot_histogram afin d'ajuster le graphique de sortie.

• legend : Fournit une étiquette pour les exécutions. Prend une liste de chaînes de caractères utilisées pour étiqueter les résultats de chaque exécution. C'est surtout utile lorsque tu traces plusieurs résultats d'exécution dans le même histogramme.
• sort : Ajuste l'ordre des barres dans l'histogramme. Peut être défini en ordre croissant avec asc ou décroissant avec desc.
• number_to_keep : Prend un entier pour le nombre de termes à afficher. Le reste est regroupé dans une seule barre appelée « rest ».
• color : Ajuste la couleur des barres ; prend une chaîne de caractères ou une liste de chaînes pour les couleurs à utiliser pour les barres de chaque exécution.
• bar_labels : Ajuste si des étiquettes sont affichées au-dessus des barres.
• figsize : Prend un tuple indiquant la taille en pouces de la figure de sortie.

# Execute two-qubit Bell state again
sampler.options.default_shots = 1000

job = sampler.run([isa_circuit])
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,
)

Tracer les résultats de l'Estimator

Qiskit ne dispose pas de fonction intégrée pour tracer les résultats de l'Estimator, mais tu peux utiliser le bar plot de Matplotlib pour une visualisation rapide.

Pour illustrer cela, la cellule suivante estime les valeurs d'espérance de sept observables différents sur un état quantique.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import EstimatorV2 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]

service = QiskitRuntimeService()

pm = generate_preset_pass_manager(backend=backend, 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(backend)
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>), ensemble_standard_error=np.ndarray(<shape=(7, 1), dtype=float64>), shape=(7, 1)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})

<BarContainer object of 7 artists>

La cellule suivante utilise l'erreur standard estimée de chaque résultat et les ajoute sous forme de barres d'erreur. Consulte la documentation du bar plot pour une description complète du graphique.

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