French
Languages
English
Bengali
French
German
Japanese
Korean
Portuguese
Spanish
Tamil

Introduction à Qiskit

Lors de l’utilisation de Qiskit, on utilise généralement les quatre étapes principales suivantes :

  • Construction: mise au point d’un circuit quantique qui représente le problème à traiter.

  • Compilation : Compiler des circuits pour un service quantique spécifique, par exemple un système quantique ou un simulateur classique.

  • Exécution : Exécutez les circuits compilés sur le(s) service(s) quantique spécifié(s). Ces services peuvent être obtenus au travers du Cloud ou localement.

  • Analyse: calculer les valeurs statistiques et visualiser les résultats de l’exécution.

Voici un exemple de cette suite d’étapes, chacune sera expliquée en détails dans les sessions suivantes:

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': 498, '11': 502}
     ┌───┐     ┌─┐   
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1 
# Plot a histogram
plot_histogram(counts)
_images/intro_tutorial1_1_0.png

Étape par étape

Le programme ci-dessus peut-être découpé en six étapes :

  1. Importation des bibliothèques

  2. Initialisation des variables

  3. Ajout des portes quantiques

  4. Visualisation du circuit

  5. Execution du programme

  6. Visualisation des résultats

Etape 1 : Importation des bibliothèques

Les éléments nécessaires sont importés de cette manière :

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

Plus précisément les imports sont

  • QuantumCircuit : pour contenir les instructions pour le programme quantique. Il va regrouper l’ensemble des instructions quantiques à effectuer.

  • QasmSimulator: est le simulateur de circuit de haute performance Aer.

  • plot_histogram: pour créer des histogrammes.

Etape 2 : Initialisation des Variables

La ligne de code suivante

circuit = QuantumCircuit(2, 2)

A pour effet d’initialiser le circuit représenté par la variable circuit avec deux qubits à l’état initial 0, et deux bits classiques avec la valeur 0.

Syntaxe :

  • QuantumCircuit(int, int)

Etape 3 : Ajout de portes quantiques

Il est possible d’ajouter des portes (qui représentent des opérations) pour manipuler les registres du circuit.

Par exemple :

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

Les portes sont ajoutées au circuit, l’une après l’autre pour produire l’état de Bell

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

Le code utilise les portes suivantes :

  • QuantumCircuit.h(0) : Une porte de Hadamard \(H\) sur le qubit 0, qui le place en état de superposition.

  • QuantumCircuit.cx(0, 1): Une porte Control-Not (\(CNOT\)) avec le qubit de contrôle 0, agissant sur le qubit cible 1, ce qui a pour effet de mettre les deux qubits dans un état intriqué.

  • QuantumCircuit.measure([0,1], [0,1]): lorsque l’on passe en argument de measure l’intégralité du registre quantique et du registre classique alors le résultat de la mesure sur le qubit de rang i sera stocké dans le bit classique de même rang.

Étape 4 : Visualisation du circuit

Vous pouvez utiliser qiskit.circuit.QuantumCircuit.draw() afficher une représentation du circuit que vous avez conçu dans les différentes formes utilisées couramment dans les manuels et articles de recherche.

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

Dans ce circuit, le qubit 0 se trouve au dessus du qubit 1. Le circuit se lit de la gauche vers la droite, ce qui signifie que les portes qui se situent sur la gauche du circuit seront appliquées en premier.

Par défaut l’affichage issu de QuantumCircuit.draw() ou de qiskit.visualization.circuit_drawer() se fait en mode texte. Toutefois, selon l’environnement dans lequel vous opérez vous pourrez changer ce réglage afin d’obtenir un affichage plus adapté à votre besoin. Ceci se fait à l’aide du fichier de configuration utilisateur de type .ini qui se trouve dans le répertoire : ~/.qiskit/settings.conf.

Par exemple, pour que les visualisations utilisent un mode Matplotlib, le fichier``setting.conf`` doit contenir :

[default]
circuit_drawer = mpl

Vous pouvez utiliser les modes de visualisation suivants : text, mpl, latex, et latex_source.

Étape 5 : Emulation du calcul

Le module Aer de Qiskit fournit un environnement performant pour l’émulation de circuits quantiques. Il fournit la possibilité de travailler avec plusieurs plateformes selon les objectifs poursuivis.

En cas de difficulté avec l’installation du composant Aer de Qiskit , vous pouvez utiliser la plateforme Basic Aer en subsituant BasicAer à Aer. En effet, le composant Basic Aer est inclus dans le module Terra de Qiskit.

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

Pour émuler l’execution de ce circuit, il faudra utiliser qasm_simulator. Chaque exécution produira le résultat 00 ou 11 sur deux bits.

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: {'11': 510, '00': 490}

Comme on pouvait s’y attendre, la sortie 00 apparaît approximativement dans 50 pourcent des cas. Le nombre de fois où le circuit doit être exécuté peut être spécifié avec l’argument shots de la méthode execute. Par défaut cet argument à la valeur 1024, dans cet exemple sa valeur a été réglée à 1000.

Une fois que vous disposez de l’objet result`, vous pouvez obtenir le comptage des résultats par la méthode ``get_counts(circuit), qui renvoie les résultats agrégés du programme que vous avez exécuté.

Étape 6 : Visualisation des Résultats

Qiskit fournit de nombreux modes de visualisation,

parmi lesquels plot_histogram, pour afficher vos résultats.

plot_histogram(counts)
_images/intro_tutorial1_4_0.png

Les probabilités observées \(Pr(00)\) et \(Pr(11)\) sont calculées en divisant chaque quantité de résultat obtenu pour une valeur donnée du résultat par le nombre de tirs.

Note

Essayez de changer le mot clé shots dans la méthode run() pour voir comment les probabilités estimées changent.

Étapes Suivantes

Maintenant que vous avez acquis les bases, vous pouvez continuer avec ces contenus :