Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation PennyLane avec Amazon Braket
Les algorithmes hybrides sont des algorithmes qui contiennent à la fois des instructions classiques et quantiques. Les instructions classiques sont exécutées sur du matériel classique (une instance EC2 ou votre ordinateur portable), et les instructions quantiques sont exécutées sur un simulateur ou sur un ordinateur quantique. Nous vous recommandons d'exécuter des algorithmes hybrides à l'aide de la fonctionnalité Hybrid Jobs. Pour plus d'informations, consultez [Quand utiliser Amazon Braket](braket-jobs.md#braket-jobs-use) Jobs.
Amazon Braket vous permet de configurer et d'exécuter des algorithmes quantiques hybrides à l'aide du plugin Amazon **Braket ou du SDK Python Amazon PennyLane Braket** **et de référentiels d'exemples de blocs-notes**. Des exemples de blocs-notes Amazon Braket, basés sur le SDK, vous permettent de configurer et d'exécuter certains algorithmes hybrides sans le plug-in. PennyLane Cependant, nous le recommandons PennyLane car cela offre une expérience plus riche.
**À propos des algorithmes quantiques hybrides**
Les algorithmes quantiques hybrides sont importants pour l'industrie aujourd'hui, car les dispositifs informatiques quantiques contemporains produisent généralement du bruit et, par conséquent, des erreurs. Chaque porte quantique ajoutée à un calcul augmente le risque d'ajouter du bruit ; par conséquent, les algorithmes de longue durée peuvent être submergés par le bruit, ce qui entraîne des erreurs de calcul.
Les algorithmes quantiques purs tels que ceux de Shor [(exemple d'estimation de phase quantique)](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Quantum_Phase_Estimation) ou de Grover [(exemple de Grover)](https://github.com/aws/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Grover) nécessitent des milliers, voire des millions, d'opérations. Pour cette raison, ils peuvent être peu pratiques pour les dispositifs quantiques existants, généralement appelés dispositifs quantiques *bruyants à échelle intermédiaire (NISQ*).
Dans les algorithmes quantiques hybrides, les unités de traitement quantique (QPU) fonctionnent comme des coprocesseurs pour les processeurs classiques, notamment pour accélérer certains calculs dans un algorithme classique. Les exécutions des circuits deviennent beaucoup plus courtes, ce qui est à la portée des capacités des appareils actuels.
**Topics**
+ [Amazon Braket avec PennyLane](#pennylane-option)
+ [Exemples d'algorithmes hybrides dans les carnets Amazon Braket](#braket-hybrid-workflow)
+ [Algorithmes hybrides avec PennyLane simulateurs intégrés](#hybrid-alorithms-pennylane)
+ [Dégradé adjoint activé PennyLane avec les simulateurs Amazon Braket](#adjoint-gradient-pennylane)
+ [Utilisation de tâches hybrides et exécution PennyLane d'un algorithme QAOA](braket-jobs-run-qaoa-algorithm.md)
+ [Exécutez des charges de travail hybrides avec des simulateurs PennyLane intégrés](pennylane-embedded-simulators.md)
## Amazon Braket avec PennyLane
Amazon Braket fournit un support pour [PennyLane](https://pennylane.ai)un framework logiciel open source construit autour du concept de programmation différentiable *quantique*. Vous pouvez utiliser ce cadre pour entraîner des circuits quantiques de la même manière que vous entraînerez un réseau neuronal afin de trouver des solutions à des problèmes de calcul en chimie quantique, en apprentissage automatique quantique et en optimisation.
La PennyLane bibliothèque fournit des interfaces vers des outils d'apprentissage automatique familiers, notamment PyTorch et TensorFlow pour rendre l'apprentissage des circuits quantiques rapide et intuitif.
+ **La PennyLane bibliothèque** -— PennyLane est préinstallée dans les blocs-notes Amazon Braket. Pour accéder aux appareils Amazon Braket depuis PennyLane, ouvrez un bloc-notes et importez la PennyLane bibliothèque à l'aide de la commande suivante.
```
import pennylane as qml
```
Les carnets de didacticiels vous aident à démarrer rapidement. Vous pouvez également l'utiliser PennyLane sur Amazon Braket à partir de l'IDE de votre choix.
+ **Le PennyLane plugin Amazon Braket** — Pour utiliser votre propre IDE, vous pouvez installer le PennyLane plugin Amazon Braket manuellement. Le plugin se connecte PennyLane au [SDK Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python), afin que vous puissiez exécuter des circuits PennyLane sur Amazon les appareils Braket. Pour installer le PennyLane plugin, utilisez la commande suivante.
```
pip install amazon-braket-pennylane-plugin
```
L'exemple suivant montre comment configurer l'accès aux appareils Amazon Braket dans PennyLane :
```
# to use SV1
import pennylane as qml
sv1 = qml.device("braket.aws.qubit", device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", wires=2)
# to run a circuit:
@qml.qnode(sv1)
def circuit(x):
qml.RZ(x, wires=0)
qml.CNOT(wires=[0,1])
qml.RY(x, wires=1)
return qml.expval(qml.PauliZ(1))
result = circuit(0.543)
#To use the local sim:
local = qml.device("braket.local.qubit", wires=2)
```
Pour des exemples de didacticiels et plus d'informations à ce sujet PennyLane, consultez le [référentiel d'exemples Amazon Braket](https://github.com/aws/amazon-braket-examples/tree/main/examples/pennylane).
Le PennyLane plugin Amazon Braket vous permet de basculer entre Amazon Braket QPU et les dispositifs de simulation intégrés en PennyLane une seule ligne de code. Il propose deux appareils quantiques Amazon Braket avec PennyLane lesquels travailler :
+ `braket.aws.qubit`pour fonctionner avec les appareils quantiques Amazon du service Braket, y compris les QPU et les simulateurs
+ `braket.local.qubit`pour fonctionner avec le Amazon simulateur local du SDK Braket
Le PennyLane plugin Amazon Braket est open source. Vous pouvez l'installer depuis le [ GitHub dépôt des PennyLane plugins](https://github.com/amazon-braket/amazon-braket-pennylane-plugin-python).
Pour plus d'informations PennyLane, consultez la documentation sur le [PennyLane site Web](https://pennylane.ai).
## Exemples d'algorithmes hybrides dans les carnets Amazon Braket
Amazon Braket fournit une variété d'exemples de blocs-notes qui ne s'appuient pas sur le PennyLane plugin pour exécuter des algorithmes hybrides. Vous pouvez commencer avec n'importe lequel de ces [carnets hybrides Amazon Braket](https://github.com/aws/amazon-braket-examples/tree/main/examples/hybrid_quantum_algorithms) illustrant des *méthodes variationnelles*, comme l'algorithme d'optimisation approximative quantique (QAOA) ou le solveur quantique variationnel (VQE).
Les carnets d'exemple Amazon Braket s'appuient sur le SDK Amazon [Braket](https://github.com/aws/amazon-braket-sdk-python) Python. Le SDK fournit un cadre permettant d'interagir avec les dispositifs matériels informatiques quantiques via Amazon Braket. Il s'agit d'une bibliothèque open source conçue pour vous aider à gérer la partie quantique de votre flux de travail hybride.
Vous pouvez explorer Amazon Braket plus en détail avec nos [exemples de carnets](https://github.com/aws/amazon-braket-examples) de notes.
## Algorithmes hybrides avec PennyLane simulateurs intégrés
Amazon Braket Hybrid Jobs est désormais livré avec des processeurs hautes performances et des simulateurs GPU-based intégrés de. [PennyLane](https://github.com/PennyLaneAI/pennylane-lightning) Cette famille de simulateurs intégrés peut être intégrée directement dans votre conteneur de tâches hybrides et inclut le `lightning.qubit` simulateur vectoriel d'état rapide, le simulateur accéléré à l'`lightning.gpu`aide de la [bibliothèque cuQuantum](https://developer.nvidia.com/cuquantum-sdk) de NVIDIA, etc. Ces simulateurs intégrés sont parfaitement adaptés aux algorithmes variationnels tels que l'apprentissage automatique quantique, qui peuvent bénéficier de méthodes avancées telles que la méthode de [différenciation adjointe](https://docs.pennylane.ai/en/stable/introduction/interfaces.html#simulation-based-differentiation). Vous pouvez exécuter ces simulateurs intégrés sur une ou plusieurs instances de CPU ou de GPU.
Avec Hybrid Jobs, vous pouvez désormais exécuter le code de votre algorithme variationnel en combinant un coprocesseur classique et un QPU, un simulateur à la demande Amazon Braket tel queSV1, ou directement en utilisant le simulateur intégré de. PennyLane
Le simulateur intégré est déjà disponible avec le conteneur Hybrid Jobs, vous devez décorer votre fonction Python principale avec le `@hybrid_job` décorateur. Pour utiliser le PennyLane `lightning.gpu` simulateur, vous devez également spécifier une instance de GPU dans le, `InstanceConfig` comme indiqué dans l'extrait de code suivant :
```
import pennylane as qml
from braket.jobs import hybrid_job
from braket.jobs.config import InstanceConfig
@hybrid_job(device="local:pennylane/lightning.gpu", instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"))
def function(wires):
dev = qml.device("lightning.gpu", wires=wires)
...
```
Reportez-vous à l'[exemple de bloc-notes](https://github.com/aws/amazon-braket-examples/blob/main/examples/hybrid_jobs/4_Embedded_simulators_in_Braket_Hybrid_Jobs/Embedded_simulators_in_Braket_Hybrid_Jobs.ipynb) pour commencer à utiliser un simulateur PennyLane intégré avec Hybrid Jobs.
## Dégradé adjoint activé PennyLane avec les simulateurs Amazon Braket
Avec le PennyLane plugin pour Amazon Braket, vous pouvez calculer les dégradés à l'aide de la méthode de différenciation adjointe lorsque vous l'exécutez sur le simulateur de vecteur d'état local ou SV1.
**Remarque :** Pour utiliser la méthode de différenciation adjointe, vous devez spécifier `diff_method='device'` dans votre `qnode` et **non**`diff_method='adjoint'`. Consultez l'exemple suivant.
```
device_arn = "arn:aws:braket:::device/quantum-simulator/amazon/sv1"
dev = qml.device("braket.aws.qubit", wires=wires, shots=0, device_arn=device_arn)
@qml.qnode(dev, diff_method="device")
def cost_function(params):
circuit(params)
return qml.expval(cost_h)
gradient = qml.grad(circuit)
initial_gradient = gradient(params0)
```
**Note**
Actuellement, je PennyLane vais calculer des indices de regroupement pour les hamiltoniens QAOA et les utiliser pour diviser l'hamiltonien en plusieurs valeurs attendues. Si vous souhaitez utiliser la fonctionnalité de différenciation adjointe de SV1 lorsque vous exécutez QAOA à partir dePennyLane, vous devez reconstruire le hamiltonien des coûts en supprimant les indices de regroupement, comme suit : `cost_h, mixer_h = qml.qaoa.max_clique(g, constrained=False) cost_h = qml.Hamiltonian(cost_h.coeffs, cost_h.ops)`