Introduction aux algorithmes dans Qiskit¶

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

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

Qiskit fournit un certain nombre d”Algorithmes 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’un Hamiltonien en chimie ou une solution à un problème d’optimisation lorsqu’il est exprimé en tant qu’Hamiltonien d’Ising. Il y a des Solveurs Linéaires pour les problèmes de système linéaire d’équations 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 souvent une partie de la configuration sera sous la forme de blocs de construction plus petits, dont différentes instances peuvent être données. Par exemple l’algorithme VQE, le Variational Quantum Eigensolver, prend une fonction d’onde d’essai sous la forme d’une instance de QuantumCircuit et un optimiseur classique.

Regardons un exemple pour construire une instance VQE. Ici, TwoLocal est la forme variationnelle (fonction d’essai d’onde), un circuit paramétré que l’on peut faire varier, et SLSQP un optimiseur classique. Ils sont créés sous la forme d’instances séparées et passées à VQE quand elles sont construits. Essayer, par exemple, un optimiseur classique différent, ou une forme variationnelle est simplement un cas de création d’une instance de celle que vous voulez et de le/la passer au VQE.

[1]:

from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal

num_qubits = 2
ansatz = TwoLocal(num_qubits, "ry", "cz")
optimizer = SLSQP(maxiter=1000)

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.decompose().draw("mpl", style="iqx")

[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 ?¶

Les algorithmes s’appuient sur les primitives pour évaluer les valeurs de prévision ou les circuits d’échantillonnage. Les primitives peuvent être basées sur un simulateur ou un dispositif réel et peuvent être utilisées de façon interchangeable dans les algorithmes, car elles implémentent toutes la même interface.

Dans le VQE, nous devons évaluer les valeurs d’espérance, par exemple, nous pouvons utiliser le « `qiskit.primitives.Estimator » qui est livré avec l’installation Qiskit Terra par défaut.

[3]:

from qiskit.primitives import Estimator

estimator = Estimator()

Cet estimateur utilise une simulation exacte et vectorielle pour évaluer les valeurs de l’espérance. Nous pouvons également utiliser des simulateurs bruités ou de vrais backends à la place. Pour plus d’informations sur les simulateurs, vous pouvez consulter Qiskit Aer <https://qiskit.org/documentation/apidoc/aer_primitives.html>` __ et les backends réels ` Qiskit IBM Runtime <https://qiskit.org/documentation/partners/qiskit_ibm_runtime/>` __.

Ces ingrédients étant touts prêts, nous pouvons maintenant instancier le VQE:

[4]:

from qiskit.algorithms.minimum_eigensolvers import VQE

vqe = VQE(estimator, ansatz, optimizer)

Nous pouvons à présent appeler la méthode compute_mininum_eigenvalue(). Cette méthode est l’interface de choix pour les modules d’application, tels que Nature et Optimisation, afin qu’ils puissent fonctionner de manière interchangeable avec n’importe quel autre algorithme dans leur catégorie.

Voici un exemple complet¶

Utilisons ce que nous avons appris ci-dessus et créons un exemple complet qui fonctionne. VQE trouvera la valeur propre minimale, i.e. La valeur énergétique minimale d’un opérateur Hamiltonien et donc nous avons besoin d’un tel opérateur pour que VQE fonctionne. Un tel opérateur est fourni ci-dessous. Il a été créé à l’origine par le module d’application Nature en tant que Hamiltonien pour une molécule H2 à une distance interatomique de 0,735A. C’est la somme des termes de Pauli ci-dessous, mais pour l’instant, je ne vais pas dire quoi que ce soit de plus à ce sujet puisque l’objectif est d’exécuter l’algorithme, mais de plus amples informations sur les opérateurs peuvent être trouvées dans d’autres tutoriels.

[5]:

from qiskit.quantum_info import SparsePauliOp

H2_op = SparsePauliOp.from_list([
    ("II", -1.052373245772859),
    ("IZ", 0.39793742484318045),
    ("ZI", -0.39793742484318045),
    ("ZZ", -0.01128010425623538),
    ("XX", 0.18093119978423156)
])

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

[6]:

result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)

{   'aux_operators_evaluated': None,
    'cost_function_evals': 102,
    'eigenvalue': -1.857275020719397,
    'optimal_circuit': <qiskit.circuit.library.n_local.two_local.TwoLocal object at 0x7f96da26a470>,
    'optimal_parameters': {   ParameterVectorElement(θ[0]): -2.403507257619715,
                              ParameterVectorElement(θ[5]): 1.7060524493254914,
                              ParameterVectorElement(θ[1]): 3.085467047665086,
                              ParameterVectorElement(θ[2]): -2.1949965223522487,
                              ParameterVectorElement(θ[3]): 4.276089268519914,
                              ParameterVectorElement(θ[4]): -3.098644972035885,
                              ParameterVectorElement(θ[6]): 0.032773583818940334,
                              ParameterVectorElement(θ[7]): 2.8861019033185396},
    'optimal_point': array([-2.40350726,  3.08546705, -2.19499652,  4.27608927, -3.09864497,
        1.70605245,  0.03277358,  2.8861019 ]),
    'optimal_value': -1.857275020719397,
    'optimizer_evals': None,
    'optimizer_result': <qiskit.algorithms.optimizers.optimizer.OptimizerResult object at 0x7f96da2a4d60>,
    'optimizer_time': 0.29071593284606934}

À partir du résultat ci-dessus, nous pouvons voir le nombre d’évaluations de la fonction de coût (=energie) que l’optimiseur a nécessitéavant de trouver la valeur propre minimale de \(\approx -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.

Mise à jour de la primitive dans VQE¶

Pour terminer nous allons aussi changer l’estimateur primitif à l’intérieur d’un VQE. Peut-être que vous êtes satisfait des résultats de la simulation et que vous voulez maintenant utiliser un émulateur ou exécuter sur du matériel !

Dans cet exemple, nous passons à un estimateur basé sur les tirs, toujours en utilisant la primitive de référence de Qiskit Terra. Cependant, vous pourriez remplacer la primitive par exemple l’estimateur Qiskit Aer(qiskit_aer.primitives.Estimator) ou même un réel backend (qiskit_ibm_runtime.Estimator).

Pour les fonctions de perte bruitées, l’optimiseur SPSA s’exécute généralement bien, de sorte que nous mettez également à jour l’optimiseur. Voir aussi le tutoriel « VQE avec du bruit » <https://qiskit.org/documentation/tutorials/algorithms/03_vqe_simulation_with_noise.html>` __ pour plus de détails sur les simulations par shot buitées.

[7]:

from qiskit.algorithms.optimizers import SPSA

estimator = Estimator(options={"shots": 1000})

vqe.estimator = estimator
vqe.optimizer = SPSA(maxiter=100)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)

{   'aux_operators_evaluated': None,
    'cost_function_evals': 200,
    'eigenvalue': -1.8574503552440247,
    'optimal_circuit': <qiskit.circuit.library.n_local.two_local.TwoLocal object at 0x7f96da2f4250>,
    'optimal_parameters': {   ParameterVectorElement(θ[0]): -7.7940259581467375,
                              ParameterVectorElement(θ[5]): 0.28827257835035214,
                              ParameterVectorElement(θ[1]): -1.8091021117029589,
                              ParameterVectorElement(θ[2]): -2.460381278734678,
                              ParameterVectorElement(θ[3]): -7.725013961075425,
                              ParameterVectorElement(θ[4]): -1.3793338621798832,
                              ParameterVectorElement(θ[6]): -2.4148423942537587,
                              ParameterVectorElement(θ[7]): -1.8555574263247812},
    'optimal_point': array([-7.79402596, -1.80910211, -2.46038128, -7.72501396, -1.37933386,
        0.28827258, -2.41484239, -1.85555743]),
    'optimal_value': -1.8574503552440247,
    'optimizer_evals': None,
    'optimizer_result': <qiskit.algorithms.optimizers.optimizer.OptimizerResult object at 0x7f96da26a5f0>,
    'optimizer_time': 0.8142139911651611}

Note : Nous n’utilisons pas une graine (seed) fixée pour le générateur de nombre pseudo aléatoires, c’est pourquoi nous obtenons des résultats légèrement différents.

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-terra`	0.23.0.dev0+f52bb33
`qiskit-aer`	0.11.1
`qiskit-ignis`	0.7.1
`qiskit-ibmq-provider`	0.19.2
`qiskit-nature`	0.5.0
`qiskit-optimization`	0.5.0
`qiskit-machine-learning`	0.6.0
System information
Python version	3.10.4
Python compiler	Clang 12.0.0
Python build	main, Mar 31 2022 03:38:35
OS	Darwin
CPUs	4
Memory (Gb)	32.0
Wed Dec 07 11:02:26 2022 CET

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.

[ ]: