Note

Cette page a été générée à partir de `tutorials/algorithms/01_algorithms_introduction.ipynb`__.

Exécuter en mode interactif dans le IBM Quantum lab <https://quantum-computing.ibm.com/jupyter/tutorial/algorithms/01_algorithms_introduction.ipynb> _.

Introduction aux algorithmes dans Qiskit¶

Il s’agit d’une introduction aux algorithmes dans Qiskit et fournit une vue d’ensemble de haut niveau pour aider à comprendre les différents aspects de la fonctionnalité pour commencer. D’autres didacticiels fourniront un matériel plus approfondi, sur des algorithmes donnés, et sur des façons de les utiliser, etc.

Comment la bibliothèque d’algorithmes est-elle structurée ?¶

Qiskit fournit un certain nombre d”Algorithmes et ils sont regroupés par catégorie en fonction de la tâche qu’ils peuvent accomplir. Par exemple Minimum Eigensolvers pour trouver la plus petite valeur propre d’un opérateur, par exemple l’énergie de base d’une chimie Hamiltonienne ou une solution à un problème d’optimisation lorsqu’il est exprimé en tant qu’Hamiltonien d’Ising. Il y a des Classes pour les problèmes de classification d’apprentissage automatique et des Estimateurs d'amplitude pour l’estimation de la valeur qui peut être utilisée par exemple dans les applications financières. L’ensemble complet des catégories peut être vu dans le lien de documentation des algorithmes ci-dessus.

Les algorithmes sont configurables et font souvent partie de la configuration sous la forme de blocs de construction plus petits, dont différentes instances du type de bloc de construction peuvent être données. Par exemple avec le VQE, le Variational Quantum Eigensolver, il prend une fonction d’essai d’onde, sous la forme d’un QuantumCircuit et d’un optimiseur classique, entre autres. De tels blocs de construction peuvent être trouvés en tant que Components et en tant que circuits de la Bibliothèque Circuit.

Regardons un exemple pour construire une instance VQE. Ici, TwoLocal est la forme variationnelle (fonction d’essai d’onde), un circuit paramétré qui peut être varié, et SLSQP un optimiseur classique. Ceux-ci sont créées sous la forme d’instances séparées et passées à VQE quand elles sont construites. Essayer, par exemple, un optimiseur classique différent, ou une forme variationnelle revient simplement à créer l’instance voulue et à la passer au VQE.

[1]:

from qiskit.aqua.algorithms import VQE
from qiskit.aqua.components.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal

num_qubits = 2
ansatz = TwoLocal(num_qubits, 'ry', 'cz')
opt = SLSQP(maxiter=1000)
vqe = VQE(var_form=ansatz, optimizer=opt)

Nous allons dessiner l’ansatz afin de voir que c’est un QuantumCircuit où θ[0] à θ[7] seront les paramètres qui varieront afin que l’optimiseur VQE trouve la valeur propre minimale. Nous reviendrons plus tard sur les paramètres dans un exemple ci-dessous.

[2]:

ansatz.draw()

[2]:

../../_images/tutorials_algorithms_01_algorithms_introduction_4_0.png

Mais il faut plus de choses avant de pouvoir exécuter l’algorithme, alors passons à la suivante.

Comment exécuter un algorithme ?¶

Pour exécuter un algorithme, nous devons avoir un arrière plan, un simulateur ou un appareil réel, sur lequel les circuits qui composent l’algorithme peuvent être exécutés. Ainsi, par exemple, nous pouvons utiliser le statevector_simulator du fournisseur BasicAer.

[3]:

from qiskit import BasicAer

backend = BasicAer.get_backend('statevector_simulator')

Maintenant, un arrière plan seul ne dispose pas d’informations sur la façon dont vous pourriez vouloir exécuter les circuits, etc. Par exemple, combien de tirs, voulez-vous un modèle de bruit, même des options autour du transpileur pour les circuits. Pour cela Qiskit Aqua a un » QuantumInstance <https://qiskit.org/documentation/stubs/qiskit.aqua.QuantumInstance.html>` __ qui est fourni à la fois avec l’arrière plan ainsi que divers réglages autour du circuit de traitement et d’exécution, par exemple:

[4]:

from qiskit.aqua import QuantumInstance

backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend, shots=800, seed_simulator=99)

Note : si vous fournissez directement le backend, une instance QuantumInstance sera créée à partir de celui-ci, avec les paramètres par défaut, donc en tout temps les algorithmes fonctionnent à travers une QuantumInstance.

Nous pouvons à présent appeler la méthode `run()<https://qiskit.org/documentation/stubs/qiskit.aqua.algorithms.VQE.run.html>`__ , qui est commune à tous les algorithmes et renvoie un résultat spécifique pour l’algorithme. Dans ce cas, puisque VQE est un MinimumEigensolver nous pourrions utiliser la méthode compute_mininum_eigenvalue() . C’est l’interface de choix pour les modules d’application tels que Chimie et Optimisation, afin qu’ils puissent fonctionner de manière interchangeable avec n’importe quel algorithme de la même catégorie.

Voici un exemple complet¶

Let’s put what we have learned from above together and create a complete working example. VQE will find the minimum eigenvalue, i.e. minimum energy value of a Hamiltonian operator and hence we need such an operator for VQE to work with. Such an operator is given below. This was originally created by the Chemistry application module as the Hamiltonian for an H2 molecule at 0.735A interatomic distance. It’s a sum of Pauli terms as below, but for now I am not going to say anything further about it since the goal is to run the algorithm, but further information on operators can be found in other tutorials.

[5]:

from qiskit.aqua.operators import X, Z, I

H2_op = (-1.052373245772859 * I ^ I) + \
        (0.39793742484318045 * I ^ Z) + \
        (-0.39793742484318045 * Z ^ I) + \
        (-0.01128010425623538 * Z ^ Z) + \
        (0.18093119978423156 * X ^ X)

Alors construisons une instance VQE en passant au constructeur l’opérateur et un backend en utilisant une instance de QuantumInstance. Notons que VQE dispose de méthodes de type « setter » pour que l’opérateur et le backend puissent également être passés plus tard, ce qui peut être utile lors de la création d’un algorithme sans ces informations spécifiques, par exemple avec le module d’application de chimie, pour créer l’opérateur correspondant au problème spécifique de chimie en cours de résolution.

Note: Afin que vous puissiez exécuter ce bloc-notes et voir la même sortie, le générateur de nombres aléatoires utilisé dans Aqua dans aqua_globals, ainsi que le transpileur et le simulateur, au travers de QuantumInstance, sont ensemencés. Il n’est pas indispensable de le faire, sauf si vous voulez pouvoir reproduire exactement le même résultat à chaque fois.

Lançons donc VQE et affichons l’objet résultat qu’il retourne.

[6]:

from qiskit.aqua import aqua_globals
seed = 50
aqua_globals.random_seed = seed
qi = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)

ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(operator=H2_op, var_form=ansatz, optimizer=slsqp, quantum_instance=qi)
result = vqe.run()

import pprint
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(result)

{   'cost_function_evals': 72,
    'eigenstate': array([-9.55448660e-05+2.12037105e-17j,  9.93766273e-01+2.25293943e-16j,
       -1.11483565e-01+1.52657541e-16j, -1.77521351e-05+3.71607315e-17j]),
    'eigenvalue': (-1.857275017559769+0j),
    'optimal_parameters': {   Parameter(θ[0]): 4.296520551468743,
                              Parameter(θ[1]): 4.426962086704216,
                              Parameter(θ[2]): 0.5470753710293924,
                              Parameter(θ[7]): 0.3602072316165878,
                              Parameter(θ[6]): -4.717618235040379,
                              Parameter(θ[5]): 1.5683261371389359,
                              Parameter(θ[3]): 6.09294789784282,
                              Parameter(θ[4]): -2.598325857134344},
    'optimal_point': array([ 4.29652055,  4.42696209,  0.54707537,  6.0929479 , -2.59832586,
        1.56832614, -4.71761824,  0.36020723]),
    'optimal_value': -1.857275017559769,
    'optimizer_evals': 72,
    'optimizer_time': 1.310880184173584}

À partir du résultat ci-dessus, nous pouvons voir qu’il a pris les évaluations de l’optimiseur 72 des valeurs des paramètres jusqu’à ce qu’il trouve la valeur propre minimale de -1.85727 qui est l’énergie de l’état fondamental électronique de la molécule H2 donnée. Les paramètres optimaux de l’ansatz peuvent également être vus et sont les valeurs qui étaient dans l’ansatz à la valeur minimale.

Utiliser VQE comme MinimumEigensolver¶

Pour conclure nous utilisons l’interface MinimumEigensolver et créons également une instance VQE sans fournir ni l’opérateur ni QuantumInstance. Plus tard nous avons défini QuantumInstance et finalement passé l’opérateur sur la méthode compute_minimum_eigenvalue (bien que nous aurions pu le passer plus tôt via le setter à la place, à condition que le VQE fonctionne et qu’il y ait un opérateur).

[7]:

aqua_globals.random_seed = seed
qi = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)

ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(var_form=ansatz, optimizer=slsqp)

vqe.quantum_instance = qi
result = vqe.compute_minimum_eigenvalue(operator=H2_op)

pp.pprint(result)

{   'cost_function_evals': 72,
    'eigenstate': array([-9.55448660e-05+2.12037105e-17j,  9.93766273e-01+2.25293943e-16j,
       -1.11483565e-01+1.52657541e-16j, -1.77521351e-05+3.71607315e-17j]),
    'eigenvalue': (-1.857275017559769+0j),
    'optimal_parameters': {   Parameter(θ[4]): -2.598325857134344,
                              Parameter(θ[5]): 1.5683261371389359,
                              Parameter(θ[6]): -4.717618235040379,
                              Parameter(θ[7]): 0.3602072316165878,
                              Parameter(θ[1]): 4.426962086704216,
                              Parameter(θ[0]): 4.296520551468743,
                              Parameter(θ[2]): 0.5470753710293924,
                              Parameter(θ[3]): 6.09294789784282},
    'optimal_point': array([ 4.29652055,  4.42696209,  0.54707537,  6.0929479 , -2.59832586,
        1.56832614, -4.71761824,  0.36020723]),
    'optimal_value': -1.857275017559769,
    'optimizer_evals': 72,
    'optimizer_time': 2.8010470867156982}

Comme un amorçage identique a été utilisé comme l’exemple précédent, le résultat peut être considéré comme le même.

Ceci conclut cette introduction aux algorithmes dans Qiskit. Veuillez consulter les autres tutoriels d’algorithmes de cette série pour une couverture plus large et plus en profondeur des algorithmes.

[8]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.23.1
Terra	0.16.1
Aer	0.7.1
Ignis	0.5.1
Aqua	0.8.1
IBM Q Provider	0.11.1
System information
Python	3.7.8 \| packaged by conda-forge \| (default, Jul 31 2020, 02:25:08) [GCC 7.5.0]
OS	Linux
CPUs	8
Memory (Gb)	31.40900421142578
Fri Jan 15 12:11:24 2021 UTC

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.

[ ]: