Note

Cette page a été générée à partir de tutorials/circuits/2_plotting_data_in_qiskit.ipynb.

Exécuter en mode interactif dans le IBM Quantum lab.

Visualisations Qiskit¶

[1]:

from qiskit import *
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor

Afficher l’histogramme¶

Pour visualiser les données d’un circuit quantique exécuté sur un appareil réel ou ` ` qasm_simulateur ` ` nous avons fait une fonction simple

` ` plot_histogramme (données) ` `

À titre d’exemple, nous faisons un état de Bell avec 2-qubit

[2]:

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

meas = QuantumCircuit(2, 2)
meas.measure([0,1], [0,1])

# execute the quantum circuit
backend = BasicAer.get_backend('qasm_simulator') # the device to run on
circ = bell + meas
result = execute(circ, backend, shots=1000).result()
counts  = result.get_counts(circ)
print(counts)

{'00': 528, '11': 472}

[3]:

plot_histogram(counts)

[3]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_4_0.png

Options lors de la préparation d’un histogramme¶

The plot_histogram() has a few options to adjust the output graph. The first option is the legend kwarg. This is used to provide a label for the executions. It takes a list of strings use to label each execution’s results. This is mostly useful when plotting multiple execution results in the same histogram. The sort kwarg is used to adjust the order the bars in the histogram are rendered. It can be set to either ascending order with asc or descending order with desc. The number_to_keep kwarg takes an integer for the number of terms to show, the rest are grouped together in a single bar called rest. You can adjust the color of the bars with the color kwarg which either takes a string or a list of strings for the colors to use for the bars for each execution. You can adjust whether labels are printed above the bars or not with the bar_labels kwarg. The last option available is the figsize kwarg which takes a tuple of the size in inches to make the output figure.

[4]:

# Execute 2-qubit Bell state again
second_result = execute(circ, backend, shots=1000).result()
second_counts  = second_result.get_counts(circ)
# Plot results with legend
legend = ['First execution', 'Second execution']
plot_histogram([counts, second_counts], legend=legend)

[4]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_6_0.png

[5]:

plot_histogram([counts, second_counts], legend=legend, sort='desc', figsize=(15,12),
               color=['orange', 'black'], bar_labels=False)

[5]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_7_0.png

Utilisation de la sortie de plot_histogram()¶

Lorsque vous utilisez la fonction plot_histogram(), elle renvoie un objet matplotlib.Figure pour la visualisation. Les notebooks Jupyter comprennent ce type et en font la présentation pour nous dans ce tutoriel, mais en dehors de Jupyter, cette fonctionnalité n’est pas disponible automatiquement. Cependant, la classe matplotlib.Figure contient des méthodes natives pour l’affichage et la sauvegarde de la visualisation. Vous pouvez appeler .show() sur l’objet retourné par plot_histogram() pour ouvrir l’image dans une nouvelle fenêtre (en supposant que votre backend matplotlib configuré est interactif). Ou bien vous pouvez appeler .savefig('out.png') pour sauvegarder le diagramme dans out.png. La méthode savefig() accepte un paramètre de chemin pour que vous puissiez ajuster l’emplacement et le nom de fichier où vous enregistrez la sortie.

Tracé de l’état¶

Dans de nombreuses situations, vous voulez voir l’état de l’ordinateur quantique. Cela peut être pour le débogage. Nous supposons ici que vous avez cet état (obtenu par simulation ou tomographie d’état) et l’objectif est de visualiser l’état quantique. Cela nécessite des ressources exponentielles, donc nous conseillons de n’observer l’état que de petits systèmes quantiques. Il existe plusieurs fonctions permettant de générer différents types de visualisations d’un état quantique

plot_state_city(quantum_state)
plot_state_qsphere(quantum_state)
plot_state_paulivec(quantum_state)
plot_state_hinton(quantum_state)
plot_bloch_multivector(quantum_state)

Un état quantique est soit une matrice d’état \(\rho \) | psirangle ` (vecteur complexe). La matrice d’état est liée au vecteur d’état par

\[\rho = |\psi\rangle\langle \psi|,\]

et est plus général car il peut représenter des états mixtes (somme positive des vecteurs d’états)

\[\rho = \sum_k p_k |\psi_k\rangle\langle \psi_k |.\]

Les visualisations générées par les fonctions sont les suivantes :

'plot_state_city': la vue standard des états quantiques où les parties réelles et imaginaires (imag) de la matrice d’état sont représentés comme les bâtiments d’une ville.
` ` plot_state_qsphere”` : la vue unique Qiskit d’un état quantique où l’amplitude et la phase du vecteur d’état sont tracées sur une sphère. L’amplitude est l’épaisseur de la flèche et la phase est la couleur. Pour les états mixtes, il affiche différentes `”qsphere”`` pour chaque composant.
` ` “plot_state_paulivec”` ` : la représentation de la matrice d’état à l’aide des opérateurs Pauli comme base :math:rho = sum_ { q= 0 } ^ { d ^ 2-1 } p_jP_j/d `.
` ` plot_state_hinton”` : Identique à ` ` “city” ` ` mais où la taille de l’élément représente la valeur de l’élément de matrice.
` ` plot_bloch_multivectoriel”` `: la projection de l’état quantique sur l’espace d’un qubit unique et présentée sur une sphère de bloch.

[6]:

from qiskit.visualization import plot_state_city, plot_bloch_multivector
from qiskit.visualization import plot_state_paulivec, plot_state_hinton
from qiskit.visualization import plot_state_qsphere

[7]:

# execute the quantum circuit
backend = BasicAer.get_backend('statevector_simulator') # the device to run on
result = execute(bell, backend).result()
psi  = result.get_statevector(bell)

[8]:

plot_state_city(psi)

[8]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_13_0.png

[9]:

plot_state_hinton(psi)

[9]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_14_0.png

[10]:

plot_state_qsphere(psi)

[10]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_15_0.png

[11]:

plot_state_paulivec(psi)

[11]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_16_0.png

[12]:

plot_bloch_multivector(psi)

[12]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_17_0.png

Nous voyons ici qu’il n’y a pas d’informations sur l’état quantique dans l’espace d’un qubit unique car tous les vecteurs sont nulls.

Options lors de l’utilisation des fonctions de présentation de l””état¶

Les différentes fonctions de présentation des états quantiques fournissent plusieurs d’options pour ajuster la façon dont les tracés sont créés. Les options disponibles dépendent de la fonction utilisée.

Options de plot_state_city()

** title** (str): chaîne représentant le titre du diagramme
** figsize** (n-uplet): taille du diagramme en pouces (largeur, hauteur).
** color** (liste): une liste de longueur= 2 donnant des couleurs pour les composantes réelles et imaginaires des éléments de la matrice.

[13]:

plot_state_city(psi, title="My City", color=['black', 'orange'])

[13]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_21_0.png

Options de plot_state_hinton()

** title** (str): chaîne représentant le titre du diagramme
** figsize** (n-uplet): taille du diagramme en pouces (largeur, hauteur).

[14]:

plot_state_hinton(psi, title="My Hinton")

[14]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_23_0.png

Options de plot_state_paulivec()

** title** (str): chaîne représentant le titre du diagramme
** figsize** (n-uplet): taille du diagramme en pouces (largeur, hauteur).
color (liste ou str): couleur des barres de valeur attendues.

[15]:

plot_state_paulivec(psi, title="My Paulivec", color=['purple', 'orange', 'green'])

[15]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_25_0.png

Options de plot_state_qsphere()

** figsize** (n-uplet): taille du diagramme en pouces (largeur, hauteur).

Options plot_bloch_multivector()

** title** (str): chaîne représentant le titre du diagramme
** figsize** (n-uplet): taille du diagramme en pouces (largeur, hauteur).

[16]:

plot_bloch_multivector(psi, title="My Bloch Spheres")

[16]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_28_0.png

Utilisation des paramètres retournés par les fonctionsde visualisation d’état¶

Lors de l’utilisation de plot_bloch_vector, la fonction renvoie un objet matplotlib.Figure pour la visualisation. Les notebooks Jupyter comprennent ce type de retour et sont utilisés dans ce tutoriel, mais en dehors de Jupyter, cette fonctionnalité n’est pas disponible automatiquement. Cependant, la classe matplotlib.Figure a des méthodes pour l’affichage et la sauvegarde de la visualisation. Vous pouvez appeler `` .show ()`` sur l’objet retourné pour ouvrir l’image dans une nouvelle fenêtre (en supposant que votre backend matplotlib configuré est interactif). Ou encore, vous pouvez appeler .savefig('out.png') pour enregistrer le diagramme``out.png`` dans le répertoire de travail en cours. La méthode `` savefig()`` accepte un chemin en paramètre afin que vous puissiez ajuster l’emplacement et le nom de fichier en sortie.

Tracer le vecteur de Bloch¶

Une façon standard d’afficher un système quantique est d’utiliser le vecteur de Bloch. Ceci ne fonctionne que pour un seul qubit et prend en paramètre d’entrée le vecteur de Bloch.

Le vecteur de Bloch est défini comme :math:` [ x = mathrm{Tr}[ X rho ], y = mathrm{Tr}[ Y rho ], z = mathrm{Tr}[ Z rho ] ] , où :math: X , :math: Y , et :math: Z ` sont les opérateurs de Pauli pour un seul qubit et :math:`rho ` est sa matrice d’état.

[19]:

from qiskit.visualization import plot_bloch_vector

[20]:

plot_bloch_vector([0,1,0])

[20]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_32_0.png

Options pour plot_bloch_vector()¶

** title** (str): chaîne représentant le titre du diagramme
** figsize** (n-uplet): taille du diagramme en pouces (largeur, hauteur).

[21]:

plot_bloch_vector([0,1,0], title='My Bloch Sphere')

[21]:

../../_images/tutorials_circuits_2_plotting_data_in_qiskit_34_0.png

Ajuster la sortie depuis plot_bloch_vector()¶

Lors de l’utilisation de plot_bloch_vector, la fonction renvoie un objet matplotlib.Figure pour la visualisation. Les notebooks Jupyter comprennent ce type de retour et sont utilisés dans ce tutoriel, mais en dehors de Jupyter, cette fonctionnalité n’est pas disponible automatiquement. Cependant, la classe matplotlib.Figure a des méthodes pour l’affichage et la sauvegarde de la visualisation. Vous pouvez appeler .show () sur l’objet retourné pour ouvrir l’image dans une nouvelle fenêtre (en supposant que votre backend matplotlib configuré est interactif). Ou encore, vous pouvez appeler .savefig('out.png') pour enregistrer le diagramme``out.png`` dans le répertoire de travail en cours. La méthode `` savefig()`` accepte un chemin en paramètre afin que vous puissiez ajuster l’emplacement et le nom de fichier en sortie.

[22]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	None
Terra	0.14.0
Aer	0.6.0
Ignis	None
Aqua	None
IBM Q Provider	0.6.1
System information
Python	3.7.7 (default, Mar 26 2020, 10:32:53) [Clang 4.0.1 (tags/RELEASE_401/final)]
OS	Darwin
CPUs	4
Memory (Gb)	16.0
Mon Apr 27 21:46:41 2020 EDT

This code is a part of Qiskit

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

[ ]: