Visualiser les résultats

Le code de cette page a été développé en tenant compte des exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.
```
qiskit[all]~=2.5.1
```

Histogramme de tracé

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

Utilisation des résultats des fonctions

Cette fonction renvoie un objet matplotlib.Figure . Lorsque la dernière ligne d'une cellule de code produit ces objets, les carnets Jupyter les affichent sous la cellule. Si vous appelez ces fonctions dans d'autres environnements ou dans des scripts, vous devrez explicitement afficher ou enregistrer les résultats.

Deux options sont possibles :

Appelez .show() sur l'objet retourné pour ouvrir l'image dans une nouvelle fenêtre (en supposant que votre backend matplotlib configuré soit interactif).
Appelez .savefig("out.png") pour enregistrer la figure à out.png dans le répertoire de travail actuel. La méthode savefig() prend un chemin d'accès afin que vous puissiez ajuster l'emplacement et le nom de fichier où vous enregistrez la sortie. Par exemple, plot_state_city(psi).savefig("out.png").

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

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)

Output:

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

Output:

Options lors du tracé d'un histogramme

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

legend: Fournit une étiquette pour les exécutions. Il prend une liste de chaînes de caractères utilisées pour étiqueter les résultats de chaque exécution. Cette fonction est surtout utile pour représenter plusieurs résultats d'exécution dans le même histogramme
sort: Règle l'ordre des barres dans l'histogramme. Il peut être défini par ordre croissant avec asc ou par ordre décroissant avec desc
number_to_keep: Prend un nombre entier pour le nombre de termes à afficher. Les autres sont regroupés dans une barre unique appelée "rest"
color: Ajuste la couleur des barres; prend une chaîne ou une liste de chaînes pour les couleurs à utiliser pour les barres pour chaque exécution
bar_labels: Permet de déterminer si les étiquettes sont imprimées au-dessus des barres
figsize: Prend un tuple de la taille en pouces pour faire le chiffre de sortie

# 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,
)

Output:

Résultats de l'estimateur de surface

Qiskit ne dispose pas d'une fonction intégrée pour tracer les résultats de l'estimateur, mais vous pouvez utiliser Matplotlib. bar tracé pour une visualisation rapide.

Pour le démontrer, la cellule suivante estime les valeurs d'espérance de sept observables différentes sur un état quantique.

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

Output:

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>

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

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

Output:

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

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.