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.
# Travailler avec Amazon Braket Hybrid Jobs
Amazon Braket Hybrid Jobs vous permet d'exécuter des algorithmes hybrides quantiques-classiques nécessitant à la fois des AWS ressources classiques et des unités de traitement quantiques (). QPUs Hybrid Jobs est conçu pour générer les ressources classiques demandées, exécuter votre algorithme et libérer les instances une fois celles-ci terminées, afin que vous ne payiez que pour *ce que vous utilisez*.
Hybrid Jobs est idéal pour les algorithmes itératifs de longue durée qui impliquent l'utilisation de ressources informatiques classiques et de ressources informatiques quantiques. Avec Hybrid Jobs, après avoir soumis votre algorithme à exécuter, Braket exécutera votre algorithme dans un environnement conteneurisé évolutif. Une fois l'algorithme terminé, vous pouvez récupérer les résultats.
De plus, les tâches quantiques créées à partir d'une tâche hybride bénéficient d'une mise en file d'attente plus prioritaire vers le périphérique QPU cible. Cette hiérarchisation garantit que vos calculs quantiques sont traités et exécutés avant les autres tâches en attente. Cela est particulièrement avantageux pour les algorithmes hybrides itératifs, dans lesquels les résultats d'une tâche quantique dépendent des résultats de tâches quantiques antérieures. [Des exemples de tels algorithmes incluent l'[algorithme d'optimisation approximative quantique (QAOA)](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_quantum_algorithms/QAOA/QAOA_braket.ipynb), le [solveur quantique variationnel ou l'apprentissage automatique quantique](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_quantum_algorithms/VQE_Chemistry/VQE_chemistry_braket.ipynb).](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs.ipynb) Vous pouvez également suivre la progression de votre algorithme en temps quasi réel, ce qui vous permet de suivre les coûts, le budget ou des indicateurs personnalisés tels que les pertes d'entraînement ou les valeurs attendues.
Vous pouvez accéder aux jobs hybrides dans Braket en utilisant :
+ Le [SDK Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python).
+ La [console Amazon Braket.](https://console.aws.amazon.com/braket/home)
+ L'Amazon BraketAPI.
**Topics**
+ [Quand utiliser Amazon Braket Hybrid Jobs](#braket-jobs-use)
+ [Exécution d'une tâche hybride avec Amazon Braket Hybrid Jobs](#braket-jobs-works)
+ [Concepts clés pour les emplois hybrides](braket-jobs-concepts.md)
+ [Conditions préalables](braket-jobs-prerequisites.md)
+ [Créez un Job hybride](braket-jobs-first.md)
+ [Annuler un Job hybride](braket-jobs-cancel.md)
+ [Personnalisation de votre Hybrid Job](braket-jobs-customize.md)
+ [Utilisation PennyLane avec Amazon Braket](hybrid.md)
+ [Utilisation de CUDA-Q avec Amazon Braket](braket-using-cuda-q.md)
## Quand utiliser Amazon Braket Hybrid Jobs
Amazon Braket Hybrid Jobs vous permet d'exécuter des algorithmes hybrides classiques et quantiques, tels que le variational Quantum Eigensolver (VQE) et l'algorithme d'optimisation quantique approximatif (QAOA), qui combinent des ressources de calcul classiques avec des dispositifs informatiques quantiques afin d'optimiser les performances des systèmes quantiques actuels. Amazon Braket Hybrid Jobs offre trois avantages principaux :
1. **Performances** : Amazon Braket Hybrid Jobs offre de meilleures performances que l'exécution d'algorithmes hybrides depuis votre propre environnement. Pendant que votre tâche est en cours d'exécution, elle dispose d'un accès prioritaire au QPU cible sélectionné. Les tâches de votre travail sont exécutées avant les autres tâches mises en file d'attente sur l'appareil. Cela se traduit par des temps d'exécution plus courts et plus prévisibles pour les algorithmes hybrides. Amazon Braket Hybrid Jobs prend également en charge la compilation paramétrique. Vous pouvez soumettre un circuit en utilisant des paramètres libres et Braket le compile une seule fois, sans qu'il soit nécessaire de le recompiler pour les mises à jour ultérieures des paramètres du même circuit, ce qui se traduit par des temps d'exécution encore plus rapides.
1. **Commodité** : Amazon Braket Hybrid Jobs simplifie la configuration et la gestion de votre environnement informatique et le fait fonctionner pendant que votre algorithme hybride s'exécute. Il vous suffit de fournir votre script d'algorithme et de sélectionner un dispositif quantique (une unité de traitement quantique ou un simulateur) sur lequel exécuter. Amazon Braket attend que l'appareil cible soit disponible, active les ressources classiques, exécute la charge de travail dans des environnements de conteneurs prédéfinis, renvoie les résultats à Amazon Simple Storage Service (Amazon S3) et libère les ressources de calcul.
1. **Métriques** : Amazon Braket Hybrid Jobs fournit des on-the-fly informations sur les algorithmes en cours d'exécution et fournit des métriques d'algorithmes personnalisables en temps quasi réel à Amazon CloudWatch et à la console Amazon Braket afin que vous puissiez suivre la progression de vos algorithmes.
## Exécution d'une tâche hybride avec Amazon Braket Hybrid Jobs
Pour exécuter une tâche hybride avec Amazon Braket Hybrid Jobs, vous devez d'abord définir votre algorithme. Vous pouvez le définir en écrivant le *script de l'algorithme* et, éventuellement, d'autres fichiers de dépendance à l'aide du [SDK Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python) ou. [PennyLane](https://pennylane.ai) Si vous souhaitez utiliser d'autres bibliothèques (open source ou propriétaires), vous pouvez définir votre propre image de conteneur personnalisée à l'aide de Docker, qui inclut ces bibliothèques. Pour plus d'informations, consultez [Bring your own container (BYOC).](braket-jobs-byoc.md)
Dans les deux cas, vous créez ensuite une tâche hybride à l'aide d'Amazon BraketAPI, dans laquelle vous fournissez votre script d'algorithme ou votre conteneur, sélectionnez le dispositif quantique cible que la tâche hybride doit utiliser, puis choisissez parmi une variété de paramètres facultatifs. Les valeurs par défaut fournies pour ces paramètres facultatifs fonctionnent dans la majorité des cas d'utilisation. Pour que l'appareil cible exécute votre Hybrid Job, vous avez le choix entre un QPU, un simulateur à la demande (tel queSV1, DM1 ouTN1) ou l'instance de tâche hybride classique elle-même. Avec un simulateur à la demande ou un QPU, votre conteneur de tâches hybride effectue des appels d'API vers un appareil distant. Avec les simulateurs intégrés, le simulateur est intégré dans le même conteneur que votre script d'algorithme. Les [simulateurs de foudre](https://github.com/PennyLaneAI/pennylane-lightning) PennyLane sont intégrés au conteneur de tâches hybrides prédéfini par défaut que vous pouvez utiliser. Si vous exécutez votre code à l'aide d'un PennyLane simulateur intégré ou d'un simulateur personnalisé, vous pouvez spécifier un type d'instance ainsi que le nombre d'instances que vous souhaitez utiliser. Consultez la [page de tarification d'Amazon Braket](https://aws.amazon.com/braket/pricing/) pour connaître les coûts associés à chaque choix.
![\[Schéma illustrant les interactions des utilisateurs avec les composants Amazon Braket, l'API, l'instance Jobs et les simulateurs pour les tâches hybrides, QPU, à la demande et intégrées. Les résultats sont stockés dans le bucket Amazon Simple Storage Service et analysés à l'aide d'Amazon CloudWatch sur la console Amazon Braket.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-hybrid-job-run.png)
Si votre appareil cible est un simulateur intégré ou à la demande, Amazon Braket commence immédiatement à exécuter la tâche hybride. Il lance l'instance de travail hybride (vous pouvez personnaliser le type d'instance dans l'APIappel), exécute votre algorithme, écrit les résultats sur Amazon S3 et libère vos ressources. Cette mise à disposition des ressources garantit que vous ne payez que pour ce que vous utilisez.
Le nombre total de tâches hybrides simultanées par unité de traitement quantique (QPU) est limité. Aujourd'hui, une seule tâche hybride peut être exécutée sur un QPU à la fois. Les files d'attente sont utilisées pour contrôler le nombre de tâches hybrides autorisées à s'exécuter afin de ne pas dépasser la limite autorisée. Si votre équipement cible est un QPU, votre tâche hybride entre d'abord dans la *file d'attente des tâches* du QPU sélectionné. Amazon Braket lance l'instance de tâche hybride requise et exécute votre tâche hybride sur l'appareil. Pendant toute la durée de votre algorithme, votre tâche hybride bénéficie d'un accès prioritaire, ce qui signifie que les tâches quantiques de votre tâche hybride devancent les autres tâches quantiques Braket mises en file d'attente sur l'appareil, à condition que les tâches quantiques de la tâche soient soumises au QPU une fois toutes les quelques minutes. Une fois votre projet hybride terminé, les ressources sont libérées, ce qui signifie que vous ne payez que pour ce que vous utilisez.
**Note**
Les appareils sont régionaux et votre tâche hybride s'exécute de la même manière Région AWS que votre appareil principal.
Dans les scénarios cibles du simulateur et du QPU, vous avez la possibilité de définir des métriques d'algorithme personnalisées, telles que l'énergie de votre hamiltonien, dans le cadre de votre algorithme. Ces statistiques sont automatiquement communiquées à Amazon CloudWatch et, à partir de là, elles s'affichent en temps quasi réel dans la console Amazon Braket.
**Note**
Si vous souhaitez utiliser une instance basée sur un GPU, veillez à utiliser l'un des simulateurs basés sur le GPU disponibles avec les simulateurs intégrés sur Braket (par exemple,). `lightning.gpu` Si vous choisissez l'un des simulateurs intégrés basés sur le processeur (par exemple, ou`braket:default-simulator`)`lightning.qubit`, le GPU ne sera pas utilisé et vous risquez d'encourir des coûts inutiles.
# Concepts clés pour les emplois hybrides
Cette section explique les concepts clés de la `AwsQuantumJob.create` fonction fournie par le SDK Amazon Braket Python et le mappage à la structure du fichier conteneur.
Outre le ou les fichiers qui constituent votre script d'algorithme complet, votre tâche hybride peut comporter des entrées et des sorties supplémentaires. Lorsque votre tâche hybride démarre, Amazon Braket copie les entrées fournies dans le cadre de la création de la tâche hybride dans le conteneur qui exécute le script d'algorithme. Lorsque la tâche hybride est terminée, toutes les sorties définies au cours de l'algorithme sont copiées vers l'emplacement Amazon S3 spécifié.
**Note**
Les *métriques de l'algorithme* sont rapportées en temps réel et ne suivent pas cette procédure de sortie.
Amazon Braket fournit également plusieurs variables d'environnement et fonctions d'assistance pour simplifier les interactions avec les entrées et sorties des conteneurs. *Pour plus d'informations, consultez le [package braket.jobs dans le SDK](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.jobs.html) Amazon Braket.*
**Topics**
+ [Inputs](#braket-jobs-inputs)
+ [Sorties](#braket-jobs-outputs)
+ [Variables d'environnement](#braket-jobs-environmental-variables)
+ [Fonctions d'assistance](#braket-jobs-helper-functions)
## Inputs
**Données d'**entrée : Les données d'entrée peuvent être fournies à l'algorithme hybride en spécifiant le fichier de données d'entrée, qui est configuré sous forme de dictionnaire, avec l'`input_data`argument. L'utilisateur définit l'`input_data`argument au sein de la `AwsQuantumJob.create` fonction dans le SDK. Cela copie les données d'entrée dans le système de fichiers conteneur à l'emplacement indiqué par la variable d'environnement`"AMZN_BRAKET_INPUT_DIR"`. Pour quelques exemples de la façon dont les données d'entrée sont utilisées dans un algorithme hybride, consultez le [QAOA avec Amazon Braket Hybrid Jobs PennyLane](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs/Using_PennyLane_with_Braket_Hybrid_Jobs.ipynb) [et l'apprentissage automatique quantique dans les blocs-notes Jupyter d'Amazon Braket](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs.ipynb) Hybrid Jobs.
**Note**
Lorsque les données d'entrée sont volumineuses (> 1 Go), le temps d'attente est long avant que la tâche hybride ne soit soumise. Cela est dû au fait que les données d'entrée locales seront d'abord téléchargées dans un compartiment S3, puis le chemin S3 sera ajouté à la demande de travail hybride et, enfin, la demande de travail hybride est soumise au service Braket.
**Hyperparamètres** : si vous les transmettez`hyperparameters`, ils sont disponibles sous la variable `"AMZN_BRAKET_HP_FILE"` d'environnement.
**Note**
[Pour plus d'informations sur la façon de créer des hyperparamètres et des données d'entrée, puis de transmettre ces informations au script de tâche hybride, consultez la section [Utiliser les hyperparamètres](braket-jobs-hyperparameters.md) et cette page github.](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/qcbm/qcbm.py)
**Points de contrôle** : pour spécifier `job-arn` le point de contrôle que vous souhaitez utiliser dans une nouvelle tâche hybride, utilisez la `copy_checkpoints_from_job` commande. Cette commande copie les données du point `checkpoint_configs3Uri` de contrôle vers la nouvelle tâche hybride, les rendant disponibles sur le chemin indiqué par la variable d'environnement `AMZN_BRAKET_CHECKPOINT_DIR` pendant l'exécution de la tâche. La valeur par défaut est`None`, ce qui signifie que les données de point de contrôle d'une autre tâche hybride ne seront pas utilisées dans la nouvelle tâche hybride.
## Sorties
**Tâches quantiques** : les résultats des tâches quantiques sont stockés dans l'emplacement S3`s3://amazon-braket--/jobs//tasks`.
**Résultats du job** : tout ce que votre script d'algorithme enregistre dans le répertoire indiqué par la variable d'environnement `"AMZN_BRAKET_JOB_RESULTS_DIR"` est copié vers l'emplacement S3 spécifié dans`output_data_config`. Si la valeur n'est pas spécifiée, elle est définie par défaut sur`s3://amazon-braket--/jobs///data`. Nous fournissons la fonction d'assistance du SDK **`save_job_result`**, que vous pouvez utiliser pour stocker facilement les résultats sous forme de dictionnaire lorsque vous les appelez à partir de votre script d'algorithme.
**Points de contrôle** : Si vous souhaitez utiliser des points de contrôle, vous pouvez les enregistrer dans le répertoire indiqué par la variable d'environnement. `"AMZN_BRAKET_CHECKPOINT_DIR"` Vous pouvez également utiliser la fonction d'assistance du SDK à la place. `save_job_checkpoint`
**Métriques d'algorithme** : vous pouvez définir des métriques d'algorithme dans le cadre de votre script d'algorithme qui sont envoyées à Amazon CloudWatch et affichées en temps réel dans la console Amazon Braket pendant l'exécution de votre tâche hybride. Pour un exemple d'utilisation des métriques d'algorithmes, consultez [Utiliser les tâches hybrides Amazon Braket pour exécuter un algorithme QAOA](braket-jobs-run-qaoa-algorithm.md).
Pour plus d'informations sur la sauvegarde des résultats de vos tâches, consultez la section [Enregistrer vos résultats](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-first.html#braket-jobs-save-results) dans la documentation relative aux tâches hybrides.
## Variables d'environnement
Amazon Braket fournit plusieurs variables d'environnement pour simplifier les interactions avec les entrées et sorties des conteneurs. Le code suivant répertorie les variables environnementales utilisées par Braket.
+ `AMZN_BRAKET_INPUT_DIR`— Le répertoire des données d'entréeopt/braket/input/data.
+ `AMZN_BRAKET_JOB_RESULTS_DIR`— Le répertoire de sortie dans lequel opt/braket/model écrire les résultats de la tâche.
+ `AMZN_BRAKET_JOB_NAME`— Le nom de la tâche.
+ `AMZN_BRAKET_CHECKPOINT_DIR`— Le répertoire des points de contrôle.
+ `AMZN_BRAKET_HP_FILE`— Le fichier contenant les hyperparamètres.
+ `AMZN_BRAKET_DEVICE_ARN`— L'ARN (nom de AWS ressource) de l'appareil.
+ `AMZN_BRAKET_OUT_S3_BUCKET`— Le compartiment Amazon S3 de sortie, tel que spécifié dans la `CreateJob` demande`OutputDataConfig`.
+ `AMZN_BRAKET_SCRIPT_ENTRY_POINT`— Le point d'entrée tel que spécifié dans la `CreateJob` demande`ScriptModeConfig`.
+ `AMZN_BRAKET_SCRIPT_COMPRESSION_TYPE`— Le type de compression tel que spécifié dans la `CreateJob` demande`ScriptModeConfig`.
+ `AMZN_BRAKET_SCRIPT_S3_URI`— L'emplacement du script de l'utilisateur sur Amazon S3, tel que spécifié dans la `CreateJob` demande`ScriptModeConfig`.
+ `AMZN_BRAKET_TASK_RESULTS_S3_URI`— L'emplacement Amazon S3 où le SDK stockerait les résultats de la tâche quantique par défaut pour la tâche.
+ `AMZN_BRAKET_JOB_RESULTS_S3_PATH`— L'emplacement Amazon S3 où les résultats de la tâche seraient stockés, comme indiqué dans les `CreateJob` demandes`OutputDataConfig`.
+ `AMZN_BRAKET_JOB_TOKEN`— Chaîne à transmettre au `jobToken` paramètre pour `CreateQuantumTask` les tâches quantiques créées dans le conteneur de tâches.
## Fonctions d'assistance
Amazon Braket propose plusieurs fonctions d'assistance pour simplifier les interactions avec les entrées et sorties des conteneurs. Ces fonctions d'assistance seraient appelées depuis le script d'algorithme utilisé pour exécuter votre Hybrid Job. L'exemple suivant montre comment les utiliser.
```
from braket.jobs import get_checkpoint_dir, get_hyperparameters, get_input_data_dir, get_job_device_arn, get_job_name, get_results_dir, save_job_result, save_job_checkpoint, load_job_checkpoint
get_checkpoint_dir() # Get the checkpoint directory
get_hyperparameters() # Get the hyperparameters as strings
get_input_data_dir() # Get the input data directory
get_job_device_arn() # Get the device specified by the hybrid job
get_job_name() # Get the name of the hybrid job.
get_results_dir() # Get the path to a results directory
save_job_result(result_data='data') # Save hybrid job results
save_job_checkpoint(checkpoint_data={'key': 'value'}) # Save a checkpoint
load_job_checkpoint() # Load a previously saved checkpoint
```
# Conditions préalables
Avant d'exécuter votre première tâche hybride, vous devez vous assurer que vous disposez des autorisations suffisantes pour effectuer cette tâche. Pour déterminer si vous disposez des autorisations appropriées, sélectionnez **Autorisations** dans le menu situé sur le côté gauche de la console Braket. La page de **gestion des autorisations pour Amazon Braket** vous permet de vérifier si l'un de vos rôles existants dispose d'autorisations suffisantes pour exécuter votre tâche hybride ou vous guide dans la création d'un rôle par défaut pouvant être utilisé pour exécuter votre tâche hybride si vous ne possédez pas déjà un tel rôle.
![\[Page d'autorisations et de paramètres pour le service Amazon Braket présentant un rôle lié au service et une option permettant de vérifier les rôles existants pour le rôle d'exécution des tâches hybrides.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-permissions.png)
Pour vérifier que vous disposez de rôles dotés d'autorisations suffisantes pour exécuter une tâche hybride, cliquez sur le bouton **Vérifier le rôle existant**. Si vous le faites, vous recevez un message indiquant que les rôles ont été trouvés. Pour voir les noms des rôles et leur rôle ARNs, cliquez sur le bouton **Afficher les rôles**.
![\[Écran des autorisations et des paramètres d'Amazon Braket indiquant qu'un rôle lié à un service a été trouvé et des rôles existants dotés d'autorisations suffisantes pour exécuter des tâches hybrides.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-yes.png)
Si vous ne disposez pas d'un rôle doté des autorisations suffisantes pour exécuter une tâche hybride, vous recevez un message indiquant qu'aucun rôle de ce type n'a été trouvé. Cliquez sur le bouton **Créer un rôle par défaut** pour obtenir un rôle avec des autorisations suffisantes.
![\[La page des autorisations et des paramètres Amazon Braket indique qu'un rôle lié à un service a été trouvé et qu'aucun rôle d'exécution de tâches hybrides n'a été trouvé.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-no.png)
Si le rôle a été créé avec succès, vous recevez un message le confirmant.
![\[Page d'autorisations et de paramètres Amazon Braket indiquant qu'un rôle lié à un service a été trouvé et qu'un rôle d'exécution de tâches hybrides a été créé avec succès.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-created.png)
Si vous n'êtes pas autorisé à effectuer cette demande, l'accès vous sera refusé. Dans ce cas, contactez votre AWS administrateur interne.
![\[AccessDenied message d'erreur indiquant que l'utilisateur n'est pas autorisé à exécuter iam : ListAttachedRolePolicies AmazonBraketJobsExecutionRole avec un refus explicite.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-permissions-access-denied.png)
# Créez un Job hybride
Cette section explique comment créer un Job hybride à l'aide d'un script Python. Vous pouvez également créer une tâche hybride à partir du code Python local, tel que votre environnement de développement intégré (IDE) préféré ou un bloc-notes Braket, voir[Exécutez votre code local en tant que tâche hybride](braket-hybrid-job-decorator.md).
**Topics**
+ [Créez et exécutez](#braket-jobs-first-create)
+ [Surveillez vos résultats](#braket-jobs-first-monitor-results)
+ [Enregistrez vos résultats](#braket-jobs-save-results)
+ [Utilisation des points de contrôle](#braket-jobs-checkpoints)
+ [Exécutez votre code local en tant que tâche hybride](braket-hybrid-job-decorator.md)
+ [Utilisation de l'API avec des tâches hybrides](braket-jobs-api.md)
+ [Création et débogage d'une tâche hybride en mode local](braket-jobs-local-mode.md)
## Créez et exécutez
Une fois que vous avez un rôle autorisé à exécuter une tâche hybride, vous êtes prêt à continuer. L'élément clé de votre première tâche hybride Braket est le *script d'algorithme*. Il définit l'algorithme que vous souhaitez exécuter et contient les tâches logiques et quantiques classiques qui font partie de votre algorithme. Outre votre script d'algorithme, vous pouvez fournir d'autres fichiers de dépendance. Le script d'algorithme ainsi que ses dépendances sont appelés *module source*. Le *point d'entrée* définit le premier fichier ou la première fonction à exécuter dans votre module source au démarrage de la tâche hybride.
![\[Schéma illustrant le flux de travail consistant à créer une tâche quantique à l'aide d'une console ou d'un bloc-notes, à exécuter le script de l'algorithme sur un appareil quantique et à analyser les résultats.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-workflow.jpg)
Tout d'abord, considérez l'exemple de base suivant d'un script d'algorithme qui crée cinq états de cloche et imprime les résultats de mesure correspondants.
```
import os
from braket.aws import AwsDevice
from braket.circuits import Circuit
def start_here():
print("Test job started!")
# Use the device declared in the job script
device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"])
bell = Circuit().h(0).cnot(0, 1)
for count in range(5):
task = device.run(bell, shots=100)
print(task.result().measurement_counts)
print("Test job completed!")
```
Enregistrez ce fichier sous le nom *algorithm\$1script.py* dans votre répertoire de travail actuel sur votre bloc-notes Braket ou dans votre environnement local. Le fichier algorithm\$1script.py a `start_here()` pour point d'entrée prévu.
Créez ensuite un fichier Python ou un bloc-notes Python dans le même répertoire que le fichier algorithm\$1script.py. Ce script lance la tâche hybride et gère tout traitement asynchrone, tel que l'impression du statut ou des principaux résultats qui nous intéressent. Ce script doit au minimum spécifier votre script de tâche hybride et votre appareil principal.
**Note**
Pour plus d'informations sur la façon de créer un bloc-notes Braket ou de télécharger un fichier, tel que le fichier *algorithm\$1script.py*, dans le même répertoire que les blocs-notes, consultez [Exécuter votre premier circuit à l'aide du SDK Amazon Braket Python](braket-get-started-run-circuit.md)
Dans ce premier cas de base, vous ciblez un simulateur. Quel que soit le type d'appareil quantique que vous ciblez, qu'il s'agisse d'un simulateur ou d'une véritable unité de traitement quantique (QPU), le périphérique que vous spécifiez `device` dans le script suivant est utilisé pour planifier la tâche hybride et est disponible pour les scripts d'algorithme en tant que variable `AMZN_BRAKET_DEVICE_ARN` d'environnement.
**Note**
Vous ne pouvez utiliser que les appareils disponibles dans le cadre Région AWS de votre tâche hybride. Le SDK Amazon Braket le sélectionne automatiquement. Région AWS Par exemple, une tâche hybride dans us-east-1 peut IonQ utiliserSV1,, TN1 et des appareilsDM1, mais pas des appareils. Rigetti
Si vous choisissez un ordinateur quantique plutôt qu'un simulateur, Braket planifie vos tâches hybrides pour exécuter toutes leurs tâches quantiques avec un accès prioritaire.
```
from braket.aws import AwsQuantumJob
from braket.devices import Devices
job = AwsQuantumJob.create(
Devices.Amazon.SV1,
source_module="algorithm_script.py",
entry_point="algorithm_script:start_here",
wait_until_complete=True
)
```
Le paramètre `wait_until_complete=True` définit un mode détaillé afin que votre tâche imprime le résultat de la tâche réelle pendant son exécution. Vous devriez voir une sortie similaire à l'exemple suivant.
```
Initializing Braket Job: arn:aws:braket:us-west-2:111122223333:job/braket-job-default-123456789012
Job queue position: 1
Job queue position: 1
Job queue position: 1
..............
.
.
.
Beginning Setup
Checking for Additional Requirements
Additional Requirements Check Finished
Running Code As Process
Test job started!
Counter({'00': 58, '11': 42})
Counter({'00': 55, '11': 45})
Counter({'11': 51, '00': 49})
Counter({'00': 56, '11': 44})
Counter({'11': 56, '00': 44})
Test job completed!
Code Run Finished
2025-09-24 23:13:40,962 sagemaker-training-toolkit INFO Reporting training SUCCESS
```
**Note**
Vous pouvez également utiliser votre module personnalisé avec la méthode [AwsQuantumJob.create](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.aws.aws_quantum_job.html#braket.aws.aws_quantum_job.AwsQuantumJob.create) en transmettant son emplacement (soit le chemin d'accès à un répertoire ou à un fichier local, soit l'URI S3 d'un fichier tar.gz). [Pour un exemple pratique, consultez le fichier [Parallelize\$1Training\$1for\$1qml.ipynb dans le dossier des tâches hybrides du référentiel Github](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) des exemples Amazon Braket.](https://github.com/amazon-braket/amazon-braket-examples/tree/main)
## Surveillez vos résultats
Vous pouvez également accéder à la sortie du journal depuis Amazon CloudWatch. Pour ce faire, accédez à l'onglet **Groupes de journaux** dans le menu de gauche de la page détaillée de la tâche, sélectionnez le groupe de journaux`aws/braket/jobs`, puis choisissez le flux de journaux contenant le nom de la tâche. Dans l'exemple ci-dessus, il s'agit de `braket-job-default-1631915042705/algo-1-1631915190`.
![\[CloudWatch groupe de journaux affichant la liste des événements du journal avec les chemins de fichiers et les horodatages pour les tests Python du SDK Amazon Braket.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-cw-log.png)
Vous pouvez également consulter l'état de la tâche hybride dans la console en sélectionnant la page **Tâches hybrides**, puis en choisissant **Paramètres**.
![\[Détails de la tâche hybride Amazon Braket indiquant le résumé, les heures des événements, le code source et la configuration de l'instance, ainsi que les conditions d'arrêt.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-jobs-first-console-status.png)
Votre tâche hybride produit des artefacts dans Amazon S3 pendant son exécution. Le nom du compartiment S3 par défaut est `amazon-braket--` et le contenu se trouve dans le `jobs//` répertoire. Vous pouvez configurer les emplacements S3 où ces artefacts sont stockés en spécifiant une autre `code_location` date de création de la tâche hybride avec le SDK Braket Python.
**Note**
Ce compartiment S3 doit se trouver au même endroit Région AWS que votre script de tâche.
Le `jobs//` répertoire contient un sous-dossier contenant le résultat du script du point d'entrée dans un `model.tar.gz` fichier. Il existe également un répertoire appelé `script` qui contient les artefacts de votre script d'algorithme dans un `source.tar.gz` fichier. Les résultats de vos tâches quantiques réelles se trouvent dans le répertoire nommé`jobs//tasks`.
## Enregistrez vos résultats
Vous pouvez enregistrer les résultats générés par le script d'algorithme afin qu'ils soient disponibles depuis l'objet de tâche hybride dans le script de tâche hybride ainsi que depuis le dossier de sortie dans Amazon S3 (dans un fichier compressé nommé model.tar.gz).
La sortie doit être enregistrée dans un fichier au format JSON ( JavaScript Object Notation). Si les données ne peuvent pas être facilement sérialisées en texte, comme dans le cas d'un tableau numpy, vous pouvez transmettre une option de sérialisation à l'aide d'un format de données décapé. Consultez le module [braket.jobs.data\$1persistence](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.jobs.data_persistence.html#braket.jobs.data_persistence.save_job_result) pour plus de détails.
Pour enregistrer les résultats des tâches hybrides, ajoutez les lignes suivantes commentées avec \$1ADD dans le fichier algorithm\$1script.py.
```
import os
from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.jobs import save_job_result # ADD
def start_here():
print("Test job started!")
device = AwsDevice(os.environ['AMZN_BRAKET_DEVICE_ARN'])
results = [] # ADD
bell = Circuit().h(0).cnot(0, 1)
for count in range(5):
task = device.run(bell, shots=100)
print(task.result().measurement_counts)
results.append(task.result().measurement_counts) # ADD
save_job_result({"measurement_counts": results}) # ADD
print("Test job completed!")
```
Vous pouvez ensuite afficher les résultats de la tâche à partir de votre script de tâche en ajoutant la ligne **`print(job.result())`**commentée avec \$1ADD.
```
import time
from braket.aws import AwsQuantumJob
job = AwsQuantumJob.create(
source_module="algorithm_script.py",
entry_point="algorithm_script:start_here",
device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
)
print(job.arn)
while job.state() not in AwsQuantumJob.TERMINAL_STATES:
print(job.state())
time.sleep(10)
print(job.state())
print(job.result()) # ADD
```
Dans cet exemple, nous avons supprimé `wait_until_complete=True` pour supprimer la sortie détaillée. Vous pouvez le rajouter pour le débogage. Lorsque vous exécutez cette tâche hybride, elle affiche l'identifiant et le`job-arn`, suivis de l'état de la tâche hybride toutes les 10 secondes jusqu'à ce que la tâche hybride soit `COMPLETED` terminée, après quoi elle vous montre les résultats du circuit en cloche. Consultez l'exemple suivant.
```
arn:aws:braket:us-west-2:111122223333:job/braket-job-default-123456789012
INITIALIZED
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
RUNNING
...
RUNNING
RUNNING
COMPLETED
{'measurement_counts': [{'11': 53, '00': 47},..., {'00': 51, '11': 49}]}
```
## Utilisation des points de contrôle
Vous pouvez enregistrer les itérations intermédiaires de vos tâches hybrides à l'aide de points de contrôle. Dans l'exemple de script d'algorithme de la section précédente, vous devez ajouter les lignes suivantes commentées avec \$1ADD pour créer des fichiers de points de contrôle.
```
from braket.aws import AwsDevice
from braket.circuits import Circuit
from braket.jobs import save_job_checkpoint # ADD
import os
def start_here():
print("Test job starts!")
device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"])
# ADD the following code
job_name = os.environ["AMZN_BRAKET_JOB_NAME"]
save_job_checkpoint(checkpoint_data={"data": f"data for checkpoint from {job_name}"}, checkpoint_file_suffix="checkpoint-1") # End of ADD
bell = Circuit().h(0).cnot(0, 1)
for count in range(5):
task = device.run(bell, shots=100)
print(task.result().measurement_counts)
print("Test hybrid job completed!")
```
Lorsque vous exécutez la tâche hybride, elle crée le fichier *-checkpoint-1.json* dans les artefacts de votre tâche hybride dans le répertoire des points de contrôle avec un chemin par défaut. `/opt/jobs/checkpoints` Le script de tâche hybride reste inchangé, sauf si vous souhaitez modifier ce chemin par défaut.
Si vous souhaitez charger une tâche hybride à partir d'un point de contrôle généré par une tâche hybride précédente, le script d'algorithme utilise`from braket.jobs import load_job_checkpoint`. La logique à charger dans votre script d'algorithme est la suivante.
```
from braket.jobs import load_job_checkpoint
checkpoint_1 = load_job_checkpoint(
"previous_job_name",
checkpoint_file_suffix="checkpoint-1",
)
```
Après avoir chargé ce point de contrôle, vous pouvez poursuivre votre logique en fonction du contenu chargé dans. `checkpoint-1`
**Note**
Le *checkpoint\$1file\$1suffix doit correspondre au suffixe précédemment spécifié* lors de la création du point de contrôle.
Votre script d'orchestration doit spécifier celui `job-arn` de la tâche hybride précédente avec la ligne commentée avec \$1ADD.
```
from braket.aws import AwsQuantumJob
job = AwsQuantumJob.create(
source_module="source_dir",
entry_point="source_dir.algorithm_script:start_here",
device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
copy_checkpoints_from_job="", #ADD
)
```
# Exécutez votre code local en tant que tâche hybride
Amazon Braket Hybrid Jobs fournit une orchestration entièrement gérée d'algorithmes hybrides quantiques-classiques, combinant les ressources de calcul Amazon EC2 avec l'accès à l'unité de traitement quantique (QPU) Amazon Braket. Les tâches quantiques créées dans le cadre d'une tâche hybride sont mises en file d'attente en priorité par rapport aux tâches quantiques individuelles afin que vos algorithmes ne soient pas interrompus par les fluctuations de la file d'attente des tâches quantiques. Chaque QPU gère une file d'attente de tâches hybrides distincte, ce qui garantit qu'une seule tâche hybride peut être exécutée à la fois.
**Topics**
+ [Création d'une tâche hybride à partir du code Python local](#create-hybrid-job-from-local-python-code)
+ [Installation de packages Python et de code source supplémentaires](#install-python-packages-and-code)
+ [Enregistrer et charger des données dans une instance de tâche hybride](#save-load-data-into-instance)
+ [Bonnes pratiques pour les décorateurs hybrides](#best-practices)
## Création d'une tâche hybride à partir du code Python local
Vous pouvez exécuter votre code Python local sous forme d'Amazon Braket Hybrid Job. Vous pouvez le faire en annotant votre code à l'aide d'un `@hybrid_job` décorateur, comme illustré dans l'exemple de code suivant. Pour les environnements personnalisés, vous pouvez choisir d'[utiliser un conteneur personnalisé d'](braket-jobs-byoc.md)Amazon Elastic Container Registry (ECR).
**Note**
Seul Python 3.12 est pris en charge par défaut.
Vous pouvez utiliser le `@hybrid_job` décorateur pour annoter une fonction. [Braket transforme le code contenu dans le décorateur en un script d'algorithme de travail hybride Braket.](braket-jobs-first.md) La tâche hybride invoque ensuite la fonction dans le décorateur sur une instance Amazon EC2. Vous pouvez suivre la progression de la tâche avec `job.state()` ou avec la console Braket. L'exemple de code suivant montre comment exécuter une séquence de cinq états sur leState Vector Simulator (SV1) device.
```
from braket.aws import AwsDevice
from braket.circuits import Circuit, FreeParameter, Observable
from braket.devices import Devices
from braket.jobs.hybrid_job import hybrid_job
from braket.jobs.metrics import log_metric
device_arn = Devices.Amazon.SV1
@hybrid_job(device=device_arn) # Choose priority device
def run_hybrid_job(num_tasks=1):
device = AwsDevice(device_arn) # Declare AwsDevice within the hybrid job
# Create a parametric circuit
circ = Circuit()
circ.rx(0, FreeParameter("theta"))
circ.cnot(0, 1)
circ.expectation(observable=Observable.X(), target=0)
theta = 0.0 # Initial parameter
for i in range(num_tasks):
task = device.run(circ, shots=100, inputs={"theta": theta}) # Input parameters
exp_val = task.result().values[0]
theta += exp_val # Modify the parameter (possibly gradient descent)
log_metric(metric_name="exp_val", value=exp_val, iteration_number=i)
return {"final_theta": theta, "final_exp_val": exp_val}
```
Vous créez la tâche hybride en invoquant la fonction comme vous le feriez pour les fonctions Python normales. Cependant, la fonction de décorateur renvoie le descripteur de tâche hybride plutôt que le résultat de la fonction. Pour récupérer les résultats une fois l'opération terminée, utilisez`job.result()`.
```
job = run_hybrid_job(num_tasks=1)
result = job.result()
```
L'argument device dans le `@hybrid_job` décorateur indique le périphérique auquel la tâche hybride a un accès prioritaire, dans ce cas, le SV1 simulateur. Pour obtenir la priorité QPU, vous devez vous assurer que l'ARN du périphérique utilisé dans la fonction correspond à celui spécifié dans le décorateur. Pour plus de commodité, vous pouvez utiliser la fonction d'assistance `get_job_device_arn()` pour capturer l'ARN du périphérique déclaré dans`@hybrid_job`.
**Note**
Chaque tâche hybride a un temps de démarrage d'au moins une minute car elle crée un environnement conteneurisé sur Amazon EC2. Ainsi, pour des charges de travail très courtes, telles qu'un circuit unique ou un lot de circuits, il peut suffire d'utiliser des tâches quantiques.
**Hyperparamètres**
La `run_hybrid_job()` fonction utilise l'argument `num_tasks` pour contrôler le nombre de tâches quantiques créées. La tâche hybride le capture automatiquement sous forme d'[hyperparamètre](braket-jobs-hyperparameters.md).
**Note**
Les hyperparamètres sont affichés dans la console Braket sous forme de chaînes limitées à 2 500 caractères.
**Métriques et journalisation**
Dans la `run_hybrid_job()` fonction, les métriques issues d'algorithmes itératifs sont enregistrées avec`log_metrics`. Les métriques sont automatiquement tracées sur la page de la console Braket, sous l'onglet Job hybride. Vous pouvez utiliser des métriques pour suivre les coûts quantiques des tâches en temps quasi réel pendant l'exécution d'une tâche hybride avec le système de suivi des [coûts Braket](braket-pricing.md). L'exemple ci-dessus utilise le nom de métrique « probabilité » qui enregistre la première probabilité du [type de résultat](braket-result-types.md).
**Récupération des résultats**
Une fois la tâche hybride terminée, vous pouvez `job.result()` récupérer les résultats des tâches hybrides. Tous les objets figurant dans le relevé de retour sont automatiquement capturés par Braket. Notez que les objets renvoyés par la fonction doivent être un tuple, chaque élément étant sérialisable. Par exemple, le code suivant montre un exemple de fonctionnement et un exemple d'échec.
```
import numpy as np
# Working example
@hybrid_job(device=Devices.Amazon.SV1)
def passing():
np_array = np.random.rand(5)
return np_array # Serializable
# # Failing example
# @hybrid_job(device=Devices.Amazon.SV1)
# def failing():
# return MyObject() # Not serializable
```
**Nom du job**
Par défaut, le nom de cette tâche hybride est déduit du nom de la fonction. Vous pouvez également spécifier un nom personnalisé d'une longueur maximale de 50 caractères. Par exemple, dans le code suivant, le nom de la tâche est « my-job-name ».
```
@hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name")
def function():
pass
```
**Mode local**
Les [tâches locales](braket-jobs-local-mode.md) sont créées en ajoutant l'argument `local=True` au décorateur. Cela exécute la tâche hybride dans un environnement conteneurisé sur votre environnement informatique local, tel que votre ordinateur portable. Les emplois locaux **ne sont pas** prioritaires dans les files d'attente pour les tâches quantiques. Dans les cas avancés tels que le multi-nœuds ou le MPI, les tâches locales peuvent avoir accès aux variables d'environnement Braket requises. Le code suivant crée une tâche hybride locale avec le périphérique comme SV1 simulateur.
```
@hybrid_job(device=Devices.Amazon.SV1, local=True)
def run_hybrid_job(num_tasks=1):
return ...
```
Toutes les autres options d'emploi hybrides sont prises en charge. Pour une liste des options, consultez le module [braket.jobs.quantum\$1job\$1creation](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.jobs.quantum_job_creation.html).
## Installation de packages Python et de code source supplémentaires
Vous pouvez personnaliser votre environnement d'exécution pour utiliser vos packages Python préférés. Vous pouvez utiliser un `requirements.txt` fichier, une liste de noms de paquets ou [apporter votre propre conteneur (BYOC)](braket-jobs-byoc.md). Par exemple, le `requirements.txt` fichier peut inclure d'autres packages à installer.
```
qiskit
pennylane >= 0.31
mitiq == 0.29
```
Pour personnaliser un environnement d'exécution à l'aide d'un `requirements.txt` fichier, reportez-vous à l'exemple de code suivant.
```
@hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt")
def run_hybrid_job(num_tasks=1):
return ...
```
Vous pouvez également fournir les noms des packages sous forme de liste Python comme suit.
```
@hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"])
def run_hybrid_job(num_tasks=1):
return ...
```
Le code source supplémentaire peut être spécifié sous la forme d'une liste de modules ou d'un seul module, comme dans l'exemple de code suivant.
```
@hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"])
def run_hybrid_job(num_tasks=1):
return ...
```
## Enregistrer et charger des données dans une instance de tâche hybride
**Spécification des données d'entraînement en entrée**
Lorsque vous créez une tâche hybride, vous pouvez fournir des ensembles de données de formation en entrée en spécifiant un bucket Amazon Simple Storage Service (Amazon S3). Vous pouvez également spécifier un chemin local, puis Braket télécharge automatiquement les données vers Amazon S3 à l'adresse. `s3:///jobs///data/` Si vous spécifiez un chemin local, le nom du canal est par défaut « input ». Le code suivant montre un fichier numpy à partir du chemin `data/file.npy` local.
```
import numpy as np
@hybrid_job(device=Devices.Amazon.SV1, input_data="data/file.npy")
def run_hybrid_job(num_tasks=1):
data = np.load("data/file.npy")
return ...
```
Pour S3, vous devez utiliser la fonction `get_input_data_dir()` d'assistance.
```
import numpy as np
from braket.jobs import get_input_data_dir
s3_path = "s3://amazon-braket-us-east-1-123456789012/job-data/file.npy"
@hybrid_job(device=None, input_data=s3_path)
def job_s3_input():
np.load(get_input_data_dir() + "/file.npy")
@hybrid_job(device=None, input_data={"channel": s3_path})
def job_s3_input_channel():
np.load(get_input_data_dir("channel") + "/file.npy")
```
Vous pouvez spécifier plusieurs sources de données d'entrée en fournissant un dictionnaire des valeurs de canal et des chemins S3 URIs ou locaux.
```
import numpy as np
from braket.jobs import get_input_data_dir
input_data = {
"input": "data/file.npy",
"input_2": "s3://amzn-s3-demo-bucket/data.json"
}
@hybrid_job(device=None, input_data=input_data)
def multiple_input_job():
np.load(get_input_data_dir("input") + "/file.npy")
np.load(get_input_data_dir("input_2") + "/data.json")
```
**Note**
Lorsque les données d'entrée sont volumineuses (> 1 Go), le temps d'attente est long avant que la tâche ne soit créée. Cela est dû aux données d'entrée locales lorsqu'elles sont téléchargées pour la première fois dans un compartiment S3, puis le chemin S3 est ajouté à la demande de travail. Enfin, la demande d'emploi est soumise au service Braket.
**Sauvegarde des résultats dans S3**
Pour enregistrer les résultats non inclus dans l'instruction de retour de la fonction décorée, vous devez ajouter le répertoire approprié à toutes les opérations d'écriture de fichiers. L'exemple suivant montre la sauvegarde d'un tableau numpy et d'une figure matplotlib.
```
import matplotlib.pyplot as plt
import numpy as np
@hybrid_job(device=Devices.Amazon.SV1)
def run_hybrid_job(num_tasks=1):
result = np.random.rand(5)
# Save a numpy array
np.save("result.npy", result)
# Save a matplotlib figure
plt.plot(result)
plt.savefig("fig.png")
return ...
```
Tous les résultats sont compressés dans un fichier nommé`model.tar.gz`. Vous pouvez télécharger les résultats à l'aide de la fonction `job.result()` Python ou en accédant au dossier des résultats depuis la page des tâches hybrides dans la console de gestion Braket.
**Sauvegarde et reprise depuis les points de contrôle**
Pour les tâches hybrides de longue durée, il est recommandé de sauvegarder régulièrement l'état intermédiaire de l'algorithme. Vous pouvez utiliser la fonction d'`save_job_checkpoint()`assistance intégrée ou enregistrer des fichiers dans le `AMZN_BRAKET_JOB_RESULTS_DIR` chemin. Ce dernier est disponible avec la fonction d'assistance. `get_job_results_dir()`
Voici un exemple pratique minimal pour enregistrer et charger des points de contrôle avec un décorateur de tâches hybride :
```
from braket.jobs import save_job_checkpoint, load_job_checkpoint, hybrid_job
@hybrid_job(device=None, wait_until_complete=True)
def function():
save_job_checkpoint({"a": 1})
job = function()
job_name = job.name
job_arn = job.arn
@hybrid_job(device=None, wait_until_complete=True, copy_checkpoints_from_job=job_arn)
def continued_function():
load_job_checkpoint(job_name)
continued_job = continued_function()
```
Dans le premier job hybride, `save_job_checkpoint()` il est appelé avec un dictionnaire contenant les données que nous voulons enregistrer. Par défaut, chaque valeur doit être sérialisable sous forme de texte. Pour le pointage d'objets Python plus complexes, tels que des tableaux numpy, vous pouvez définir. `data_format = PersistedJobDataFormat.PICKLED_V4` Ce code crée et remplace un fichier de point de contrôle portant le nom par défaut `.json` dans vos artefacts de tâches hybrides dans un sous-dossier appelé « points de contrôle ».
Pour créer une nouvelle tâche hybride afin de continuer depuis le point de contrôle, nous devons indiquer `copy_checkpoints_from_job=job_arn` où se `job_arn` trouve l'ARN de la tâche hybride de la tâche précédente. Ensuite, nous `load_job_checkpoint(job_name)` chargeons depuis le point de contrôle.
## Bonnes pratiques pour les décorateurs hybrides
**Adoptez l'asynchronicité**
Les tâches hybrides créées avec l'annotation du décorateur sont asynchrones : elles s'exécutent une fois que les ressources classiques et quantiques sont disponibles. Vous surveillez la progression de l'algorithme à l'aide de Braket Management Console ou Amazon CloudWatch. Lorsque vous soumettez votre algorithme à exécuter, Braket l'exécute dans un environnement conteneurisé évolutif et les résultats sont récupérés lorsque l'algorithme est terminé.
**Exécuter des algorithmes variationnels itératifs**
Les tâches hybrides vous fournissent les outils nécessaires pour exécuter des algorithmes classiques quantiques itératifs. Pour les problèmes purement quantiques, utilisez [des tâches quantiques](braket-submit-tasks.md) ou un [lot de tâches quantiques](braket-batching-tasks.md). L'accès prioritaire à certains QPUs est particulièrement avantageux pour les algorithmes variationnels de longue durée nécessitant plusieurs appels itératifs QPUs avec un traitement classique entre les deux.
**Déboguer en mode local**
Avant d'exécuter une tâche hybride sur un QPU, il est recommandé de l'exécuter d'abord sur le simulateur SV1 pour vérifier qu'elle fonctionne comme prévu. Pour les tests à petite échelle, vous pouvez les exécuter en mode local pour une itération et un débogage rapides.
**Améliorez la reproductibilité avec [Bring your own container (BYOC)](braket-jobs-byoc.md)**
Créez une expérience reproductible en encapsulant votre logiciel et ses dépendances dans un environnement conteneurisé. En regroupant l'ensemble de votre code, de vos dépendances et de vos paramètres dans un conteneur, vous évitez les conflits potentiels et les problèmes de version.
**Simulateurs distribués multi-instances**
Pour exécuter un grand nombre de circuits, pensez à utiliser le support MPI intégré pour exécuter des simulateurs locaux sur plusieurs instances dans le cadre d'une seule tâche hybride. Pour plus d'informations, consultez la section [Simulateurs intégrés](pennylane-embedded-simulators.md).
**Utiliser des circuits paramétriques**
Les circuits paramétriques que vous soumettez à partir d'une tâche hybride sont automatiquement compilés sur certains à QPUs l'aide d'une [compilation paramétrique](braket-jobs-parametric-compilation.md) afin d'améliorer les temps d'exécution de vos algorithmes.
**Point de contrôle périodique**
Pour les tâches hybrides de longue durée, il est recommandé de sauvegarder régulièrement l'état intermédiaire de l'algorithme.
**Pour plus d'exemples, de cas d'utilisation et de bonnes pratiques, consultez les exemples [d'Amazon GitHub Braket](https://github.com/amazon-braket/amazon-braket-examples).**
# Utilisation de l'API avec des tâches hybrides
Vous pouvez accéder et interagir avec Amazon Braket Hybrid Jobs directement à l'aide du. API Cependant, les valeurs par défaut et les méthodes pratiques ne sont pas disponibles lors de l'utilisation API directe du.
**Note**
Nous vous recommandons vivement d'interagir avec Amazon Braket Hybrid Jobs à l'aide du SDK Amazon [Braket Python](https://github.com/aws/amazon-braket-sdk-python). Il propose des paramètres par défaut et des protections pratiques qui contribuent au bon fonctionnement de vos tâches hybrides.
Cette rubrique décrit les principes de base de l'utilisation duAPI. Si vous choisissez d'utiliser l'API, n'oubliez pas que cette approche peut être plus complexe et qu'elle doit être prête à plusieurs itérations pour exécuter votre tâche hybride.
Pour utiliser l'API, votre compte doit avoir un rôle dans la politique `AmazonBraketFullAccess` gérée.
**Note**
Pour plus d'informations sur la manière d'obtenir un rôle avec la politique `AmazonBraketFullAccess` gérée, consultez la [page Activer Amazon Braket](braket-enable-overview.md).
De plus, vous avez besoin d'un **rôle d'exécution**. Ce rôle sera transmis au service. Vous pouvez créer le rôle à l'aide de la **console Amazon Braket**. Utilisez l'onglet **Rôles d'exécution** de la page **Autorisations et paramètres** pour créer un rôle par défaut pour les tâches hybrides.
Vous devez spécifier tous les paramètres requis pour la tâche hybride. `CreateJob` API Pour utiliser Python, compressez les fichiers de script de votre algorithme dans un bundle tar, tel qu'un fichier input.tar.gz, et exécutez le script suivant. Mettez à jour les parties du code entre crochets (`<>`) pour qu'elles correspondent aux informations de votre compte et au point d'entrée qui spécifient le chemin, le fichier et la méthode par lesquels votre tâche hybride commence.
```
from braket.aws import AwsDevice, AwsSession
import boto3
from datetime import datetime
s3_client = boto3.client("s3")
client = boto3.client("braket")
project_name = "job-test"
job_name = project_name + "-" + datetime.strftime(datetime.now(), "%Y%m%d%H%M%S")
bucket = "amazon-braket-"
s3_prefix = job_name
job_script = "input.tar.gz"
job_object = f"{s3_prefix}/script/{job_script}"
s3_client.upload_file(job_script, bucket, job_object)
input_data = "inputdata.csv"
input_object = f"{s3_prefix}/input/{input_data}"
s3_client.upload_file(input_data, bucket, input_object)
job = client.create_job(
jobName=job_name,
roleArn="arn:aws:iam:::role/service-role/AmazonBraketJobsExecutionRole", # https://docs.aws.amazon.com/braket/latest/developerguide/braket-manage-access.html#about-amazonbraketjobsexecution
algorithmSpecification={
"scriptModeConfig": {
"entryPoint": ":",
"containerImage": {"uri": "292282985366.dkr.ecr.us-west-1.amazonaws.com/amazon-braket-base-jobs:1.0-cpu-py37-ubuntu18.04"}, # Change to the specific region you are using
"s3Uri": f"s3://{bucket}/{job_object}",
"compressionType": "GZIP"
}
},
inputDataConfig=[
{
"channelName": "hellothere",
"compressionType": "NONE",
"dataSource": {
"s3DataSource": {
"s3Uri": f"s3://{bucket}/{s3_prefix}/input",
"s3DataType": "S3_PREFIX"
}
}
}
],
outputDataConfig={
"s3Path": f"s3://{bucket}/{s3_prefix}/output"
},
instanceConfig={
"instanceType": "ml.m5.large",
"instanceCount": 1,
"volumeSizeInGb": 1
},
checkpointConfig={
"s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints",
"localPath": "/opt/omega/checkpoints"
},
deviceConfig={
"priorityAccess": {
"devices": [
"arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3"
]
}
},
hyperParameters={
"hyperparameter key you wish to pass": "",
},
stoppingCondition={
"maxRuntimeInSeconds": 1200,
"maximumTaskLimit": 10
},
)
```
Une fois que vous avez créé votre tâche hybride, vous pouvez accéder aux détails de la tâche hybride via la console `GetJob` API ou la console. Pour obtenir les détails de la tâche hybride à partir de la session Python dans laquelle vous avez exécuté le `createJob` code comme dans l'exemple précédent, utilisez la commande Python suivante.
```
getJob = client.get_job(jobArn=job["jobArn"])
```
Pour annuler une tâche hybride, appelez le `CancelJob` API with the Amazon Resource Name of the job ('JobArn').
```
cancelJob = client.cancel_job(jobArn=job["jobArn"])
```
Vous pouvez spécifier des points de contrôle dans le cadre de l'`createJob`APIutilisation du `checkpointConfig` paramètre.
```
checkpointConfig = {
"localPath" : "/opt/omega/checkpoints",
"s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints"
},
```
**Note**
Le LocalPath de `checkpointConfig` ne peut démarrer par aucun des chemins réservés suivants :`/opt/ml`, `/opt/braket``/tmp`, ou`/usr/local/nvidia`.
# Création et débogage d'une tâche hybride en mode local
Lorsque vous créez un nouvel algorithme hybride, le mode local vous permet de déboguer et de tester votre script d'algorithme. Le mode local est une fonctionnalité qui vous permet d'exécuter le code que vous prévoyez d'utiliser dans Amazon Braket Hybrid Jobs, mais sans avoir besoin de Braket pour gérer l'infrastructure nécessaire à l'exécution de la tâche hybride. Exécutez plutôt des tâches hybrides localement sur votre instance Amazon Braket Notebook ou sur un client préféré, tel qu'un ordinateur portable ou de bureau.
En mode local, vous pouvez toujours envoyer des tâches quantiques à des appareils réels, mais vous ne bénéficiez pas des avantages en termes de performances lorsque vous les exécutez contre une unité de traitement quantique (QPU) réelle en mode local.
Pour utiliser le mode local, `AwsQuantumJob` modifiez-le à l'`LocalQuantumJob`endroit où il apparaît dans votre programme. Par exemple, pour exécuter l'exemple de [Create your first hybrid job](braket-jobs-first.md), modifiez le script de job hybride dans le code comme suit.
```
from braket.jobs.local import LocalQuantumJob
job = LocalQuantumJob.create(
device="arn:aws:braket:::device/quantum-simulator/amazon/sv1",
source_module="algorithm_script.py",
entry_point="algorithm_script:start_here",
)
```
**Note**
Docker, qui est déjà préinstallé dans les blocs-notes Amazon Braket, doit être installé dans votre environnement local pour utiliser cette fonctionnalité. Les instructions d'installation de Docker se trouvent sur la page [Get Docker](https://docs.docker.com/get-started/get-docker/). De plus, tous les paramètres ne sont pas pris en charge en mode local.
# Annuler un Job hybride
Il se peut que vous deviez annuler une tâche hybride dans un état non terminal. Cela peut être fait dans la console ou avec du code.
Pour annuler votre tâche hybride dans la console, sélectionnez la tâche hybride à annuler sur la page **Tâches hybrides**, puis sélectionnez **Annuler la tâche hybride** dans le menu déroulant **Actions**.
![\[Tableau des tâches hybrides Amazon Braket avec 4 tâches indiquant leur nom, leur statut, les informations relatives à l'appareil et leur horodatage. La liste déroulante Actions contient des options permettant d'afficher les nouvelles tâches hybrides, d'annuler ou de gérer les balises.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-hybrid-cancel-job.png)
Pour confirmer l'annulation, saisissez *Annuler* dans le champ de saisie lorsque vous y êtes invité, puis sélectionnez **OK**.
![\[Boîte de dialogue permettant d'annuler une tâche spécifique avec des avertissements concernant le processus d'annulation et un champ de saisie de texte pour confirmer en saisissant « annuler ».\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/braket-hybrid-cancel-job-confirm.png)
Pour annuler votre tâche hybride à l'aide du code du SDK Braket Python, utilisez le `job_arn` pour identifier la tâche hybride, puis appelez la `cancel` commande correspondante comme indiqué dans le code suivant.
```
job = AwsQuantumJob(arn=job_arn)
job.cancel()
```
La `cancel` commande met immédiatement fin au conteneur de tâches hybrides classique et fait de son mieux pour annuler toutes les tâches quantiques associées qui sont toujours dans un état non terminal.
# Personnalisation de votre Hybrid Job
Amazon Braket propose plusieurs méthodes pour personnaliser le fonctionnement de vos tâches hybrides, ce qui vous permet d'adapter l'environnement à vos besoins spécifiques. Cette section explore les options permettant de personnaliser les tâches hybrides, qu'il s'agisse de définir l'environnement de script d'algorithme ou d'apporter votre propre conteneur. Vous apprendrez à optimiser votre flux de travail à l'aide d'hyperparamètres, à configurer des instances de travail et à tirer parti de la compilation paramétrique pour améliorer les performances. Ces techniques de personnalisation vous aident à optimiser le potentiel de vos calculs quantiques hybrides sur Amazon Braket.
**Topics**
+ [Définissez l'environnement de votre script d'algorithme](braket-jobs-script-environment.md)
+ [Utilisation d'hyperparamètres](braket-jobs-hyperparameters.md)
+ [Configurez votre instance de tâche hybride](braket-jobs-configure-job-instance-for-script.md)
+ [Utilisation de la compilation paramétrique pour accélérer les tâches hybrides](braket-jobs-parametric-compilation.md)
# Définissez l'environnement de votre script d'algorithme
Amazon Braket prend en charge les environnements définis par des conteneurs pour votre script d'algorithme :
+ Un conteneur de base (par défaut, si aucun conteneur n'`image_uri`est spécifié)
+ Un conteneur avec CUDA-Q
+ Un conteneur avec Tensorflow et PennyLane
+ Un conteneur avec PyTorch, PennyLane, et CUDA-Q
Le tableau suivant fournit des informations détaillées sur les conteneurs et les bibliothèques qu'ils incluent.
**Conteneurs Amazon Braket**
| Type | Base | CUDA-Q | TensorFlow | PyTorch |
| --- | --- | --- | --- | --- |
| **URI de l'image** | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-base-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-cudaq-jobs | 292282985366.dkr. ecr.us-east-1.amazonaws.com /:latest amazon-braket-tensorflow-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-pytorch-jobs |
| **Bibliothèques héritées** | | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) |
| **Bibliothèques supplémentaires** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/braket-jobs-script-environment.html) |
Vous pouvez consulter et accéder aux définitions de conteneurs open source sur [aws/ amazon-braket-containers](https://github.com/aws/amazon-braket-containers). Choisissez le contenant qui correspond le mieux à votre cas d'utilisation. Vous pouvez utiliser n'importe laquelle des AWS régions disponibles dans Braket (us-east-1, us-west-1, us-west-2, eu-north-1, eu-west-2), mais la région du conteneur doit correspondre à la région correspondant à votre tâche hybride. Spécifiez l'image du conteneur lorsque vous créez une tâche hybride en ajoutant l'un des trois arguments suivants à votre `create(…)` appel dans le script de tâche hybride. Vous pouvez installer des dépendances supplémentaires dans le conteneur que vous choisissez lors de l'exécution (au prix du démarrage ou de l'exécution) car les conteneurs Amazon Braket sont connectés à Internet. L'exemple suivant concerne la région us-west-2.
+ **Image de base :** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest » amazon-braket-base-jobs
+ Image **CUDA-Q : image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest** » amazon-braket-cudaq-jobs
+ Image de **Tensorflow : image\$1uri="292282985366.dkr**. ecr.us-west-2.amazonaws.com /:latest » amazon-braket-tensorflow-jobs
+ **PyTorch image :** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest » amazon-braket-pytorch-jobs
Ils `image-uris` peuvent également être récupérés à l'aide de la `retrieve_image()` fonction du SDK Amazon Braket. L'exemple suivant montre comment les récupérer depuis l'us-west-2 Région AWS.
```
from braket.jobs.image_uris import retrieve_image, Framework
image_uri_base = retrieve_image(Framework.BASE, "us-west-2")
image_uri_cudaq = retrieve_image(Framework.CUDAQ, "us-west-2")
image_uri_tf = retrieve_image(Framework.PL_TENSORFLOW, "us-west-2")
image_uri_pytorch = retrieve_image(Framework.PL_PYTORCH, "us-west-2")
```
# Apport de votre propre conteneur
Amazon Braket Hybrid Jobs fournit trois conteneurs prédéfinis pour exécuter du code dans différents environnements. Si l'un de ces conteneurs prend en charge votre cas d'utilisation, il vous suffit de fournir votre script d'algorithme lorsque vous créez une tâche hybride. Les dépendances manquantes mineures peuvent être ajoutées à partir de votre script d'algorithme ou d'un `requirements.txt` fichier à l'aide de`pip`.
Si aucun de ces conteneurs ne correspond à votre cas d'utilisation, ou si vous souhaitez les développer, Braket Hybrid Jobs prend en charge l'exécution de tâches hybrides avec votre propre image de Docker conteneur personnalisée, ou le Bring Your Own Container (BYOC). Assurez-vous qu'il s'agit de la fonctionnalité adaptée à votre cas d'utilisation.
**Topics**
+ [Quand est-ce qu'apporter mon propre contenant est la bonne décision ?](#bring-own-container-decision)
+ [Recette pour apporter votre propre contenant](bring-own-container-recipe.md)
+ [Exécution de tâches hybrides avec Braket dans votre propre conteneur](running-hybrid-jobs-in-own-container.md)
## Quand est-ce qu'apporter mon propre contenant est la bonne décision ?
Bringing your own container (BYOC) to Braket Hybrid Jobs offre la flexibilité d'utiliser votre propre logiciel en l'installant dans un environnement packagé. En fonction de vos besoins spécifiques, il existe peut-être des moyens d'obtenir la même flexibilité sans avoir à passer par le cycle complet de BYOC Docker compilation (téléchargement Amazon ECR) et d'URI d'image personnalisée.
**Note**
Le BYOC n'est peut-être pas le bon choix si vous souhaitez ajouter un petit nombre de packages Python supplémentaires (généralement moins de 10) accessibles au public. Par exemple, si vous utilisez PyPi.
Dans ce cas, vous pouvez utiliser l'une des images Braket prédéfinies, puis inclure un `requirements.txt` fichier dans votre répertoire source lors de la soumission de la tâche. Le fichier est automatiquement lu et `pip` installera les packages avec les versions spécifiées comme d'habitude. Si vous installez un grand nombre de packages, le temps d'exécution de vos tâches peut être considérablement augmenté. Vérifiez la version Python et, le cas échéant, la version CUDA du conteneur prédéfini que vous souhaitez utiliser pour tester le fonctionnement de votre logiciel.
Le BYOC est nécessaire lorsque vous souhaitez utiliser un langage autre que Python (comme C\$1\$1 ou Rust) pour votre script de travail, ou si vous souhaitez utiliser une version de Python non disponible dans les conteneurs prédéfinis de Braket. C'est également un bon choix si :
+ Vous utilisez un logiciel doté d'une clé de licence, et vous devez authentifier cette clé auprès d'un serveur de licences pour exécuter le logiciel. Avec BYOC, vous pouvez intégrer la clé de licence dans votre Docker image et inclure du code pour l'authentifier.
+ Vous utilisez un logiciel qui n'est pas accessible au public. Par exemple, le logiciel est hébergé sur un dépôt privé GitLab ou un GitHub dépôt auquel vous avez besoin d'une clé SSH spécifique pour accéder.
+ Vous devez installer une vaste suite de logiciels qui n'est pas incluse dans les conteneurs fournis par Braket. Le BYOC vous permettra d'éliminer les longs délais de démarrage de vos conteneurs de tâches hybrides en raison de l'installation de logiciels.
Le BYOC vous permet également de mettre votre SDK ou algorithme personnalisé à la disposition des clients en créant un Docker conteneur avec votre logiciel et en le mettant à la disposition de vos utilisateurs. Vous pouvez le faire en définissant les autorisations appropriées dans Amazon ECR.
**Note**
Vous devez respecter toutes les licences logicielles applicables.
# Recette pour apporter votre propre contenant
Dans cette section, nous fournissons un step-by-step guide expliquant ce dont vous avez besoin bring your own container (BYOC) pour Braket Hybrid Jobs : les scripts, les fichiers et les étapes à suivre pour les combiner afin de les utiliser avec vos Docker images personnalisées. Les recettes pour deux cas courants :
1. Installez des logiciels supplémentaires dans une Docker image et utilisez uniquement des scripts d'algorithme Python dans vos tâches.
1. Utilisez des scripts d'algorithme écrits dans un langage autre que Python avec Hybrid Jobs, ou une architecture de processeur autre que x86.
La définition du *script de saisie du conteneur* est plus complexe dans le cas 2.
Lorsque Braket exécute votre Hybrid Job, il lance le nombre et le type d'instances Amazon EC2 demandés, puis exécute Docker l'image spécifiée par l'URI de l'image pour créer la tâche sur celles-ci. Lorsque vous utilisez la fonctionnalité BYOC, vous spécifiez un URI d'image hébergé dans un [référentiel Amazon ECR privé](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) auquel vous avez accès en lecture. Braket Hybrid Jobs utilise cette image personnalisée pour exécuter le job.
Les composants spécifiques dont vous avez besoin pour créer une Docker image utilisable avec Hybrid Jobs. [Si vous n'êtes pas familiarisé avec l'écriture et la construction`Dockerfiles`, reportez-vous à la documentation [Dockerfile et à la Amazon ECR CLI documentation](https://docs.docker.com/reference/dockerfile/).](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html)
**Topics**
+ [Une image de base pour votre Dockerfile](#base-image-dockerfile)
+ [(Facultatif) Script de point d'entrée du conteneur modifié](#modified-container-entry-point)
+ [Installez le logiciel et le script de conteneur nécessaires avec `Dockerfile`](#install-docketfile)
## Une image de base pour votre Dockerfile
Si vous utilisez Python et que vous souhaitez installer un logiciel en plus de ce qui est fourni dans les conteneurs fournis par Braket, une option pour une image de base est l'une des images de conteneur Braket, hébergées dans notre [GitHub dépôt et sur Amazon ECR](https://github.com/amazon-braket/amazon-braket-containers). Vous devrez vous [authentifier auprès d'Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry) pour extraire l'image et créer dessus. Par exemple, la première ligne de votre Docker fichier BYOC pourrait être : `FROM [IMAGE_URI_HERE]`
Ensuite, remplissez le reste Dockerfile pour installer et configurer le logiciel que vous souhaitez ajouter au conteneur. Les images Braket prédéfinies contiennent déjà le script de point d'entrée du conteneur approprié, vous n'avez donc pas à vous soucier de l'inclure.
Si vous souhaitez utiliser un langage autre que Python, tel que C\$1\$1, Rust ou Julia, ou si vous souhaitez créer une image pour une architecture de processeur autre que x86, comme ARM, vous devrez peut-être créer à partir d'une image publique simple. Vous trouverez de nombreuses images de ce type dans la [galerie publique d'Amazon Elastic Container Registry](https://gallery.ecr.aws/). Assurez-vous d'en choisir un qui convient à l'architecture du processeur et, si nécessaire, au processeur graphique que vous souhaitez utiliser.
## (Facultatif) Script de point d'entrée du conteneur modifié
**Note**
Si vous ajoutez uniquement un logiciel supplémentaire à une image Braket prédéfinie, vous pouvez ignorer cette section.
Pour exécuter du code autre que Python dans le cadre de votre tâche hybride, modifiez le script Python qui définit le point d'entrée du conteneur. Par exemple, le [script `braket_container.py` python sur le Github d'Amazon Braket](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py). Il s'agit du script que les images précréées par Braket utilisent pour lancer votre script d'algorithme et définir les variables d'environnement appropriées. Le script du point d'entrée du conteneur lui-même **doit** être en Python, mais il peut lancer des scripts autres que Python. Dans l'exemple prédéfini, vous pouvez voir que les scripts d'algorithme Python sont lancés soit en tant que [sous-processus Python, soit en tant que processus](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L274) [entièrement nouveau](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L257). En modifiant cette logique, vous pouvez permettre au script du point d'entrée de lancer des scripts d'algorithmes autres que Python. Par exemple, vous pouvez modifier la [https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L139](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L139)fonction pour lancer des processus Rust en fonction de la fin de l'extension du fichier.
Vous pouvez également choisir d'en écrire un tout nouveau`braket_container.py`. Il doit copier les données d'entrée, les archives sources et les autres fichiers nécessaires depuis Amazon S3 dans le conteneur, et définir les variables d'environnement appropriées.
## Installez le logiciel et le script de conteneur nécessaires avec `Dockerfile`
**Note**
Si vous utilisez une image Braket prédéfinie comme image de Docker base, le script de conteneur est déjà présent.
Si vous avez créé un script de conteneur modifié à l'étape précédente, vous devez le copier dans le conteneur **et** définir la variable d'environnement `SAGEMAKER_PROGRAM` to`braket_container.py`, ou le nom que vous avez donné à votre nouveau script de point d'entrée de conteneur.
Voici un exemple `Dockerfile` qui vous permet d'utiliser Julia sur des instances de Jobs accélérées par GPU :
```
FROM nvidia/cuda:12.2.0-devel-ubuntu22.04
ARG DEBIAN_FRONTEND=noninteractive
ARG JULIA_RELEASE=1.8
ARG JULIA_VERSION=1.8.3
ARG PYTHON=python3.11
ARG PYTHON_PIP=python3-pip
ARG PIP=pip
ARG JULIA_URL = https://julialang-s3.julialang.org/bin/linux/x64/${JULIA_RELEASE}/
ARG TAR_NAME = julia-${JULIA_VERSION}-linux-x86_64.tar.gz
ARG PYTHON_PKGS = # list your Python packages and versions here
RUN curl -s -L ${JULIA_URL}/${TAR_NAME} | tar -C /usr/local -x -z --strip-components=1 -f -
RUN apt-get update \
&& apt-get install -y --no-install-recommends \
build-essential \
tzdata \
openssh-client \
openssh-server \
ca-certificates \
curl \
git \
libtemplate-perl \
libssl1.1 \
openssl \
unzip \
wget \
zlib1g-dev \
${PYTHON_PIP} \
${PYTHON}-dev \
RUN ${PIP} install --no-cache --upgrade ${PYTHON_PKGS}
RUN ${PIP} install --no-cache --upgrade sagemaker-training==4.1.3
# Add EFA and SMDDP to LD library path
ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH
# Julia specific installation instructions
COPY Project.toml /usr/local/share/julia/environments/v${JULIA_RELEASE}/
RUN JULIA_DEPOT_PATH=/usr/local/share/julia \
julia -e 'using Pkg; Pkg.instantiate(); Pkg.API.precompile()'
# generate the device runtime library for all known and supported devices
RUN JULIA_DEPOT_PATH=/usr/local/share/julia \
julia -e 'using CUDA; CUDA.precompile_runtime()'
# Open source compliance scripts
RUN HOME_DIR=/root \
&& curl -o ${HOME_DIR}/oss_compliance.zip https://aws-dlinfra-utilities.s3.amazonaws.com/oss_compliance.zip \
&& unzip ${HOME_DIR}/oss_compliance.zip -d ${HOME_DIR}/ \
&& cp ${HOME_DIR}/oss_compliance/test/testOSSCompliance /usr/local/bin/testOSSCompliance \
&& chmod +x /usr/local/bin/testOSSCompliance \
&& chmod +x ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh \
&& ${HOME_DIR}/oss_compliance/generate_oss_compliance.sh ${HOME_DIR} ${PYTHON} \
&& rm -rf ${HOME_DIR}/oss_compliance*
# Copying the container entry point script
COPY braket_container.py /opt/ml/code/braket_container.py
ENV SAGEMAKER_PROGRAM braket_container.py
```
Cet exemple télécharge et exécute des scripts fournis par AWS pour garantir la conformité avec toutes les licences Open Source pertinentes. Par exemple, en attribuant correctement tout code installé régi par unMIT license.
Si vous devez inclure du code non public, par exemple du code hébergé dans un dépôt privé GitHub ou dans un GitLab dépôt, **n'intégrez pas** de clés SSH dans l'Dockerimage pour y accéder. Utilisez-le plutôt Docker Compose lorsque vous créez pour autoriser l'accès Docker à SSH sur la machine hôte sur laquelle il est construit. Pour plus d'informations, consultez le guide [Utilisation sécurisée des clés SSH dans Docker pour accéder aux référentiels Github privés](https://www.fastruby.io/blog/docker/docker-ssh-keys.html).
**Création et téléchargement de votre image Docker**
Une fois correctement défini`Dockerfile`, vous êtes maintenant prêt à suivre les étapes pour [créer un référentiel Amazon ECR privé](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html), s'il n'en existe pas déjà un. Vous pouvez également créer, étiqueter et télécharger votre image de conteneur dans le référentiel.
Vous êtes prêt à créer, étiqueter et publier l'image. Consultez la [documentation de compilation de Docker](https://docs.docker.com/reference/cli/docker/buildx/build/) pour une explication complète des options `docker build` et quelques exemples.
Pour le fichier d'exemple défini ci-dessus, vous pouvez exécuter :
```
aws ecr get-login-password --region ${your_region} | docker login --username AWS --password-stdin ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com
docker build -t braket-julia .
docker tag braket-julia:latest ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest
docker push ${aws_account_id}.dkr.ecr.${your_region}.amazonaws.com/braket-julia:latest
```
**Attribution des autorisations Amazon ECR appropriées**
Braket Hybrid Jobs Dockerles images doivent être hébergées dans des référentiels Amazon ECR privés. Par défaut, un dépôt Amazon ECR privé ne fournit **pas** d'accès en lecture aux utilisateurs qui souhaitent utiliser votre image, tels qu'un collaborateur Braket Hybrid Jobs IAM role ou un étudiant. Vous devez [définir une politique de dépôt](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) pour accorder les autorisations appropriées. En général, autorisez uniquement les utilisateurs et les IAM rôles spécifiques auxquels vous souhaitez accéder à vos images, plutôt que de permettre image URI à toute personne possédant le droit de les récupérer.
# Exécution de tâches hybrides avec Braket dans votre propre conteneur
Pour créer une tâche hybride avec votre propre conteneur, appelez `AwsQuantumJob.create()` avec l'argument `image_uri` spécifié. Vous pouvez utiliser un QPU, un simulateur à la demande ou exécuter votre code localement sur le processeur classique disponible avec Braket Hybrid Jobs. Nous vous recommandons de tester votre code sur un simulateur SV1 DM1, ou TN1 avant de l'exécuter sur un véritable QPU.
Pour exécuter votre code sur le processeur classique, spécifiez le `instanceType` et `instanceCount` que vous utilisez en mettant à jour le`InstanceConfig`. Notez que si vous spécifiez un `instance_count` > 1, vous devez vous assurer que votre code peut être exécuté sur plusieurs hôtes. La limite supérieure du nombre d'instances que vous pouvez choisir est de 5. Par exemple :
```
job = AwsQuantumJob.create(
source_module="source_dir",
entry_point="source_dir.algorithm_script:start_here",
image_uri="111122223333.dkr.ecr.us-west-2.amazonaws.com/my-byoc-container:latest",
instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3),
device="local:braket/braket.local.qubit",
# ...)
```
**Note**
Utilisez l'ARN de l'appareil pour suivre le simulateur que vous avez utilisé comme métadonnées de tâches hybrides. Les valeurs acceptables doivent respecter le format`device = "local:/"`. N'oubliez pas cela `` et ne `` devez être composé que de lettres`_`, de chiffres`-`, et`.`. La chaîne est limitée à 256 caractères.
Si vous envisagez d'utiliser le BYOC et que vous n'utilisez pas le SDK Braket pour créer des tâches quantiques, vous devez transmettre la valeur de la variable environnementale `AMZN_BRAKET_JOB_TOKEN` au `jobToken` paramètre de la demande. `CreateQuantumTask` Si vous ne le faites pas, les tâches quantiques ne sont pas prioritaires et sont facturées comme des tâches quantiques autonomes ordinaires.
# Utilisation d'hyperparamètres
Vous pouvez définir les hyperparamètres nécessaires à votre algorithme, tels que le taux d'apprentissage ou la taille des étapes, lorsque vous créez une tâche hybride. Les valeurs des hyperparamètres sont généralement utilisées pour contrôler différents aspects de l'algorithme et peuvent souvent être ajustées pour optimiser les performances de l'algorithme. Pour utiliser des hyperparamètres dans une tâche hybride Braket, vous devez spécifier leurs noms et leurs valeurs de manière explicite sous forme de dictionnaire. Spécifiez les valeurs des hyperparamètres à tester lors de la recherche de l'ensemble de valeurs optimal. La première étape de l'utilisation des hyperparamètres consiste à configurer et à définir les hyperparamètres sous forme de dictionnaire, comme le montre le code suivant.
```
from braket.devices import Devices
device_arn = Devices.Amazon.SV1
hyperparameters = {"shots": 1_000}
```
Passez ensuite les hyperparamètres définis dans l'extrait de code ci-dessus à utiliser dans l'algorithme de votre choix. Pour exécuter l'exemple de code suivant, créez un répertoire nommé « src » dans le même chemin que votre fichier d'hyperparamètres. [https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py)
```
import time
from braket.aws import AwsQuantumJob
job = AwsQuantumJob.create(
device=device_arn,
source_module="src",
entry_point="src.notebook_runner:run_notebook",
input_data="src/0_Getting_started_papermill.ipynb",
hyperparameters=hyperparameters,
job_name=f"papermill-job-demo-{int(time.time())}",
)
# Print job to record the ARN
print(job)
```
*Pour accéder à vos hyperparamètres depuis votre script de tâche hybride, consultez la `load_jobs_hyperparams()` fonction dans le fichier python [notebook\$1runner.py](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py).* Pour accéder à vos hyperparamètres *en dehors* de votre script de tâche hybride, exécutez le code suivant.
```
from braket.aws import AwsQuantumJob
# Get the job using the ARN
job_arn = "arn:aws:braket:us-east-1:111122223333:job/5eabb790-d3ff-47cc-98ed-b4025e9e296f" # Replace with your job ARN
job = AwsQuantumJob(arn=job_arn)
# Access the hyperparameters
job_metadata = job.metadata()
hyperparameters = job_metadata.get("hyperParameters", {})
print(hyperparameters)
```
Pour plus d'informations sur l'apprentissage de l'utilisation des hyperparamètres, consultez les didacticiels [QAOA avec Amazon Braket Hybrid Jobs PennyLane et Quantum Machine [Learning dans Amazon Braket](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/1_Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs/Quantum_machine_learning_in_Amazon_Braket_Hybrid_Jobs.ipynb) Hybrid Jobs](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs/Using_PennyLane_with_Braket_Hybrid_Jobs.ipynb).
# Configurez votre instance de tâche hybride
En fonction de votre algorithme, vous pouvez avoir des exigences différentes. Par défaut, Amazon Braket exécute votre script d'algorithme sur une `ml.m5.large` instance. Toutefois, vous pouvez personnaliser ce type d'instance lorsque vous créez une tâche hybride à l'aide de l'argument d'importation et de configuration suivant.
```
from braket.jobs.config import InstanceConfig
job = AwsQuantumJob.create(
...
instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"), # Use NVIDIA T4 instance with 4 GPUs.
...
),
```
Si vous exécutez une simulation intégrée et que vous avez spécifié un périphérique local dans la configuration de l'appareil, vous pouvez également demander plusieurs instances dans le en `InstanceConfig` spécifiant le `instanceCount` et en le définissant pour qu'il soit supérieur à un. La limite supérieure est de 5. Par exemple, vous pouvez choisir 3 instances comme suit.
```
from braket.jobs.config import InstanceConfig
job = AwsQuantumJob.create(
...
instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3), # Use 3 NVIDIA T4 instances
...
),
```
Lorsque vous utilisez plusieurs instances, pensez à distribuer votre tâche hybride à l'aide de la fonctionnalité data parallel. Consultez l'exemple de bloc-notes suivant pour plus de détails sur la façon de voir cet exemple de [formation Parallelize](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) pour QML.
Les trois tableaux suivants répertorient les types d'instances et les spécifications disponibles pour les instances standard, hautes performances et accélérées par GPU.
**Note**
Pour consulter les quotas d'instances de calcul classiques par défaut pour les tâches hybrides, consultez la page [Amazon Braket Quotas](braket-quotas.md).
| Instances standard | vCPU | Mémoire (Gio) |
| --- | --- | --- |
| ml.m5.large (par défaut) | 4 | 16 |
| ml.m5.xlarge | 4 | 16 |
| ml.m5.2xlarge | 8 | 32 |
| ml.m5.4xlarge | 16 | 64 |
| ml.m5.12xlarge | 48 | 192 |
| ml.m5.24xlarge | 96 | 384 |
| Instances à hautes performances | vCPU | Mémoire (Gio) |
| --- | --- | --- |
| ml.c5.xlarge | 4 | 8 |
| ml.c5.2xlarge | 8 | 16 |
| ml.c5.4xlarge | 16 | 32 |
| ml.c5.9xlarge | 36 | 72 |
| ml.c5.18xlarge | 72 | 144 |
| ml.c5n.xlarge | 4 | 10,5 |
| ml.c5n.2xlarge | 8 | 21 |
| ml.c5n.4xlarge | 16 | 32 |
| ml.c5n.9xlarge | 36 | 72 |
| ml.c5n.18xlarge | 72 | 192 |
| Instances accélérées par GPU | GPUs | vCPU | Mémoire (Gio) | Mémoire GPU (Gio) |
| --- | --- | --- | --- | --- |
| ml.p4d.24xlarge | 8 | 96 | 1 152 | 320 |
| ml.g4dn.xlarge | 1 | 4 | 16 | 16 |
| ml.g4dn.2xlarge | 1 | 8 | 32 | 16 |
| ml.g4dn.4xlarge | 1 | 16 | 64 | 16 |
| ml.g4dn.8xlarge | 1 | 32 | 128 | 16 |
| ml.g4dn.12xlarge | 4 | 48 | 192 | 64 |
| ml.g4dn.16xlarge | 1 | 64 | 256 | 16 |
Chaque instance utilise une configuration de stockage de données (SSD) par défaut de 30 Go. Mais vous pouvez régler le stockage de la même manière que vous configurez le`instanceType`. L'exemple suivant montre comment augmenter le stockage total à 50 Go.
```
from braket.jobs.config import InstanceConfig
job = AwsQuantumJob.create(
...
instance_config=InstanceConfig(
instanceType="ml.g4dn.xlarge",
volumeSizeInGb=50,
),
...
),
```
## Configurez le bucket par défaut dans `AwsSession`
L'utilisation de votre propre `AwsSession` instance vous offre une flexibilité accrue, notamment la possibilité de spécifier un emplacement personnalisé pour votre compartiment Amazon S3 par défaut. Par défaut, an `AwsSession` possède un emplacement de compartiment Amazon S3 préconfiguré de`"amazon-braket-{id}-{region}"`. Cependant, vous avez la possibilité de remplacer l'emplacement par défaut du compartiment Amazon S3 lors de la création d'un`AwsSession`. Les utilisateurs peuvent éventuellement transmettre un `AwsSession` objet dans la `AwsQuantumJob.create()` méthode, en fournissant le `aws_session` paramètre comme illustré dans l'exemple de code suivant.
```
aws_session = AwsSession(default_bucket="amazon-braket-s3-demo-bucket")
# Then you can use that AwsSession when creating a hybrid job
job = AwsQuantumJob.create(
...
aws_session=aws_session
)
```
# Utilisation de la compilation paramétrique pour accélérer les tâches hybrides
Amazon Braket prend en charge la compilation paramétrique sur certains. QPUs Cela vous permet de réduire la surcharge associée à l'étape de compilation coûteuse en calculant un circuit une seule fois et non pour chaque itération de votre algorithme hybride. Cela peut améliorer considérablement les temps d'exécution des tâches hybrides, car vous évitez d'avoir à recompiler votre circuit à chaque étape. Soumettez simplement des circuits paramétrés à l'un de nos Job hybrides pris en charge en QPUs tant que Braket. Pour les travaux hybrides de longue durée, Braket utilise automatiquement les données d'étalonnage mises à jour fournies par le fournisseur de matériel lors de la compilation de votre circuit afin de garantir des résultats de la plus haute qualité.
Pour créer un circuit paramétrique, vous devez d'abord fournir des paramètres en tant qu'entrées dans votre script d'algorithme. Dans cet exemple, nous utilisons un petit circuit paramétrique et ignorons tout traitement classique entre chaque itération. Pour les charges de travail classiques, vous devez soumettre de nombreux circuits par lots et effectuer un traitement classique tel que la mise à jour des paramètres à chaque itération.
```
import os
from braket.aws import AwsDevice
from braket.circuits import Circuit, FreeParameter
def start_here():
print("Test job started.")
# Use the device declared in the job script
device = AwsDevice(os.environ["AMZN_BRAKET_DEVICE_ARN"])
circuit = Circuit().rx(0, FreeParameter("theta"))
parameter_list = [0.1, 0.2, 0.3]
for parameter in parameter_list:
result = device.run(circuit, shots=1000, inputs={"theta": parameter})
print("Test job completed.")
```
Vous pouvez soumettre le script d'algorithme à exécuter en tant que Job hybride avec le script de travail suivant. Lorsque vous exécutez le Job hybride sur un QPU qui prend en charge la compilation paramétrique, le circuit est compilé uniquement lors de la première exécution. Lors des exécutions suivantes, le circuit compilé est réutilisé, ce qui augmente les performances d'exécution du Hybrid Job sans aucune ligne de code supplémentaire.
```
from braket.aws import AwsQuantumJob
job = AwsQuantumJob.create(
device=device_arn,
source_module="algorithm_script.py",
)
```
**Note**
La compilation paramétrique est prise en charge sur tous les modèles supraconducteurs basés sur des portes, QPUs à l'Rigetti Computingexception des programmes de niveau d'impulsion.
# 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 (QPUs) fonctionnent comme des coprocesseurs pour les algorithmes classiques CPUs, notamment pour accélérer certains calculs dans un algorithme classique. Les exécutions des circuits deviennent beaucoup plus courtes, à la portée des capacités des appareils actuels.
**Topics**
+ [Amazon Braket avec PennyLane](#pennylane-option)
+ [Exemples d'algorithmes hybrides dans les carnets de notes 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 QPUs 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/aws/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 de notes 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 simulateurs intégrés hautes performances basés sur le processeur et le GPU 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 SV1 la fonctionnalité de différenciation adjointe lorsque vous exécutez QAOA à partir dePennyLane, vous devez reconstruire l'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)`
# Utilisation de tâches hybrides et exécution PennyLane d'un algorithme QAOA
Dans cette section, vous utiliserez ce que vous avez appris pour écrire un véritable programme hybride à l' PennyLane aide d'une compilation paramétrique. Vous utilisez le script d'algorithme pour résoudre un problème d'algorithme d'optimisation approximative quantique (QAOA). Le programme crée une fonction de coût correspondant à un problème d'optimisation Max Cut classique, spécifie un circuit quantique paramétré et utilise une méthode de descente par gradient pour optimiser les paramètres afin de minimiser la fonction de coût. Dans cet exemple, nous générons le graphe du problème dans le script de l'algorithme pour des raisons de simplicité, mais pour les cas d'utilisation les plus courants, la meilleure pratique consiste à fournir la spécification du problème via un canal dédié dans la configuration des données d'entrée. L'indicateur est `parametrize_differentiable` défini par défaut pour `True` que vous puissiez bénéficier automatiquement des avantages d'une amélioration des performances d'exécution grâce à la compilation paramétrique si elle est prise en charge. QPUs
```
import os
import json
import time
from braket.jobs import save_job_result
from braket.jobs.metrics import log_metric
import networkx as nx
import pennylane as qml
from pennylane import numpy as np
from matplotlib import pyplot as plt
def init_pl_device(device_arn, num_nodes, shots, max_parallel):
return qml.device(
"braket.aws.qubit",
device_arn=device_arn,
wires=num_nodes,
shots=shots,
# Set s3_destination_folder=None to output task results to a default folder
s3_destination_folder=None,
parallel=True,
max_parallel=max_parallel,
parametrize_differentiable=True, # This flag is True by default.
)
def start_here():
input_dir = os.environ["AMZN_BRAKET_INPUT_DIR"]
output_dir = os.environ["AMZN_BRAKET_JOB_RESULTS_DIR"]
job_name = os.environ["AMZN_BRAKET_JOB_NAME"]
checkpoint_dir = os.environ["AMZN_BRAKET_CHECKPOINT_DIR"]
hp_file = os.environ["AMZN_BRAKET_HP_FILE"]
device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"]
# Read the hyperparameters
with open(hp_file, "r") as f:
hyperparams = json.load(f)
p = int(hyperparams["p"])
seed = int(hyperparams["seed"])
max_parallel = int(hyperparams["max_parallel"])
num_iterations = int(hyperparams["num_iterations"])
stepsize = float(hyperparams["stepsize"])
shots = int(hyperparams["shots"])
# Generate random graph
num_nodes = 6
num_edges = 8
graph_seed = 1967
g = nx.gnm_random_graph(num_nodes, num_edges, seed=graph_seed)
# Output figure to file
positions = nx.spring_layout(g, seed=seed)
nx.draw(g, with_labels=True, pos=positions, node_size=600)
plt.savefig(f"{output_dir}/graph.png")
# Set up the QAOA problem
cost_h, mixer_h = qml.qaoa.maxcut(g)
def qaoa_layer(gamma, alpha):
qml.qaoa.cost_layer(gamma, cost_h)
qml.qaoa.mixer_layer(alpha, mixer_h)
def circuit(params, **kwargs):
for i in range(num_nodes):
qml.Hadamard(wires=i)
qml.layer(qaoa_layer, p, params[0], params[1])
dev = init_pl_device(device_arn, num_nodes, shots, max_parallel)
np.random.seed(seed)
cost_function = qml.ExpvalCost(circuit, cost_h, dev, optimize=True)
params = 0.01 * np.random.uniform(size=[2, p])
optimizer = qml.GradientDescentOptimizer(stepsize=stepsize)
print("Optimization start")
for iteration in range(num_iterations):
t0 = time.time()
# Evaluates the cost, then does a gradient step to new params
params, cost_before = optimizer.step_and_cost(cost_function, params)
# Convert cost_before to a float so it's easier to handle
cost_before = float(cost_before)
t1 = time.time()
if iteration == 0:
print("Initial cost:", cost_before)
else:
print(f"Cost at step {iteration}:", cost_before)
# Log the current loss as a metric
log_metric(
metric_name="Cost",
value=cost_before,
iteration_number=iteration,
)
print(f"Completed iteration {iteration + 1}")
print(f"Time to complete iteration: {t1 - t0} seconds")
final_cost = float(cost_function(params))
log_metric(
metric_name="Cost",
value=final_cost,
iteration_number=num_iterations,
)
# We're done with the hybrid job, so save the result.
# This will be returned in job.result()
save_job_result({"params": params.numpy().tolist(), "cost": final_cost})
```
**Note**
La compilation paramétrique est prise en charge sur tous les modèles supraconducteurs basés sur des portes, QPUs à l'Rigetti Computingexception des programmes de niveau d'impulsion.
# Exécutez des charges de travail hybrides avec des simulateurs PennyLane intégrés
Voyons comment utiliser les simulateurs intégrés disponibles PennyLane sur Amazon Braket Hybrid Jobs pour exécuter des charges de travail hybrides. Le simulateur intégré basé sur le GPU de Pennylane utilise la [bibliothèque Nvidia CuQuantum pour accélérer](https://developer.nvidia.com/cuquantum-sdk) les simulations de circuits. `lightning.gpu` Le simulateur GPU intégré est préconfiguré dans tous les [conteneurs de tâches](https://github.com/amazon-braket/amazon-braket-containers) Braket que les utilisateurs peuvent utiliser immédiatement. Dans cette page, nous vous montrons comment l'utiliser `lightning.gpu` pour accélérer vos charges de travail hybrides.
## Utilisation `lightning.gpu` pour les charges de travail QAOA
[Examinez les exemples d'algorithmes d'optimisation approximative quantique (QAOA) présentés dans ce bloc-notes.](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs) Pour sélectionner un simulateur intégré, vous devez spécifier que l'`device`argument doit être une chaîne de la forme :`"local:/"`. Par exemple, vous devez définir `"local:pennylane/lightning.gpu"` pour`lightning.gpu`. La chaîne de périphérique que vous donnez au Job hybride lorsque vous le lancez est transmise au job en tant que variable d'environnement`"AMZN_BRAKET_DEVICE_ARN"`.
```
device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"]
prefix, device_name = device_string.split("/")
device = qml.device(simulator_name, wires=n_wires)
```
Dans cette page, comparez les deux simulateurs de vecteurs PennyLane d'état intégrés `lightning.qubit` (basés sur le processeur) et `lightning.gpu` (basés sur le GPU). Fournissez aux simulateurs des décompositions de portes personnalisées pour calculer différents dégradés.
Vous êtes maintenant prêt à préparer le script de lancement de la tâche hybride. Exécutez l'algorithme QAOA à l'aide de deux types d'instances : `ml.m5.2xlarge` et. `ml.g4dn.xlarge` Le type d'`ml.m5.2xlarge`instance est comparable à celui d'un ordinateur portable de développeur standard. `ml.g4dn.xlarge`Il s'agit d'une instance de calcul accéléré dotée d'un seul GPU NVIDIA T4 avec 16 Go de mémoire.
Pour exécuter le GPU, nous devons d'abord spécifier une image compatible et l'instance correcte (qui est par défaut une `ml.m5.2xlarge` instance).
```
from braket.aws import AwsSession
from braket.jobs.image_uris import Framework, retrieve_image
image_uri = retrieve_image(Framework.PL_PYTORCH, AwsSession().region)
instance_config = InstanceConfig(instanceType="ml.g4dn.xlarge")
```
Nous devons ensuite les saisir dans le décorateur de tâches hybrides, ainsi que les paramètres de périphérique mis à jour dans les arguments du système et des tâches hybrides.
```
@hybrid_job(
device="local:pennylane/lightning.gpu",
input_data=input_file_path,
image_uri=image_uri,
instance_config=instance_config)
def run_qaoa_hybrid_job_gpu(p=1, steps=10):
params = np.random.rand(2, p)
braket_task_tracker = Tracker()
graph = nx.read_adjlist(input_file_path, nodetype=int)
wires = list(graph.nodes)
cost_h, _mixer_h = qaoa.maxcut(graph)
device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"]
prefix, device_name = device_string.split("/")
dev= qml.device(simulator_name, wires=len(wires))
...
```
**Note**
Si vous spécifiez le `instance_config` comme utilisant une instance basée sur le GPU, mais que vous choisissez le `device` simulateur intégré basé sur le processeur (`lightning.qubit`), le GPU ne sera pas utilisé. Assurez-vous d'utiliser le simulateur intégré basé sur le GPU si vous souhaitez cibler le GPU \$1
Le temps d'itération moyen pour l'`m5.2xlarge`instance est d'environ 73 secondes, tandis que pour l'`ml.g4dn.xlarge`instance, il est d'environ 0,6 seconde. Pour ce flux de travail à 21 qubits, l'instance GPU nous permet d'être 100 fois plus rapide. Si vous consultez la [page de tarification](https://aws.amazon.com/braket/pricing/) d'Amazon Braket Hybrid Jobs, vous pouvez constater que le coût par minute pour une `m5.2xlarge` instance est de 0,00768 USD, alors que pour l'instance, il est de 0,01227 `ml.g4dn.xlarge` USD. Dans ce cas, il est plus rapide et moins coûteux de l'exécuter sur l'instance GPU.
## Apprentissage automatique quantique et parallélisme des données
Si votre type de charge de travail est l'apprentissage automatique quantique (QML) qui s'entraîne sur des ensembles de données, vous pouvez encore accélérer votre charge de travail grâce au parallélisme des données. Dans QML, le modèle contient un ou plusieurs circuits quantiques. Le modèle peut également contenir ou non des réseaux neuronaux classiques. Lors de l'entraînement du modèle avec le jeu de données, les paramètres du modèle sont mis à jour afin de minimiser la fonction de perte. Une fonction de perte est généralement définie pour un seul point de données, et la perte totale est définie pour la perte moyenne sur l'ensemble de données. En QML, les pertes sont généralement calculées en série avant d'être moyennées par rapport à la perte totale pour les calculs de gradient. Cette procédure prend beaucoup de temps, en particulier lorsqu'il existe des centaines de points de données.
Comme la perte d'un point de données ne dépend pas des autres points de données, les pertes peuvent être évaluées en parallèle \$1 Les pertes et les gradients associés à différents points de données peuvent être évalués en même temps. C'est ce que l'on appelle le parallélisme des données. Grâce à SageMaker sa bibliothèque de données parallèles distribuées, Amazon Braket Hybrid Jobs vous permet d'utiliser plus facilement le parallélisme des données pour accélérer votre entraînement.
Considérez la charge de travail QML suivante pour le parallélisme des données, qui utilise le jeu de [données Sonar](https://archive.ics.uci.edu/dataset/151/connectionist+bench+sonar+mines+vs+rocks) du célèbre référentiel UCI comme exemple de classification binaire. L'ensemble de données Sonar comprend 208 points de données, chacun avec 60 caractéristiques collectées à partir des signaux du sonar rebondissant sur les matériaux. Chaque point de données est étiqueté « M » pour les mines ou « R » pour les roches. Notre modèle QML se compose d'une couche d'entrée, d'un circuit quantique en tant que couche cachée et d'une couche de sortie. Les couches d'entrée et de sortie sont des réseaux neuronaux classiques implémentés dans PyTorch. Le circuit quantique est intégré PyTorch aux réseaux neuronaux à l'aide PennyLane du module qml.qnn. Consultez nos [exemples de blocs-notes](https://github.com/aws/amazon-braket-examples) pour plus de détails sur la charge de travail. Comme dans l'exemple QAOA ci-dessus, vous pouvez exploiter la puissance du GPU en utilisant des simulateurs intégrés basés sur le GPU tels que PennyLane ceux `lightning.gpu` pour améliorer les performances par rapport aux simulateurs intégrés basés sur le processeur.
Pour créer une tâche hybride, vous pouvez appeler `AwsQuantumJob.create` et spécifier le script de l'algorithme, le périphérique et d'autres configurations via ses arguments de mots clés.
```
instance_config = InstanceConfig(instanceType='ml.g4dn.xlarge')
hyperparameters={"nwires": "10",
"ndata": "32",
...
}
job = AwsQuantumJob.create(
device="local:pennylane/lightning.gpu",
source_module="qml_source",
entry_point="qml_source.train_single",
hyperparameters=hyperparameters,
instance_config=instance_config,
...
)
```
Pour utiliser le parallélisme des données, vous devez modifier quelques lignes de code dans le script d'algorithme de la bibliothèque SageMaker distribuée afin de paralléliser correctement l'apprentissage. Tout d'abord, vous importez le `smdistributed` package qui effectue le plus gros du travail pour répartir vos charges de travail sur de multiples instances GPUs . Ce package est préconfiguré dans le Braket PyTorch et TensorFlow les conteneurs. Le `dist` module indique à notre script d'algorithme le nombre total de points GPUs pour l'entraînement (`world_size`) ainsi que la fin `rank` `local_rank` d'un cœur de GPU. `rank`est l'indice absolu d'un GPU pour toutes les instances, tandis `local_rank` que l'indice d'un GPU au sein d'une instance. Par exemple, s'il y a quatre instances dont huit chacune est GPUs allouée à la formation, les `rank` valeurs sont comprises entre 0 et 31 et `local_rank` entre 0 et 7.
```
import smdistributed.dataparallel.torch.distributed as dist
dp_info = {
"world_size": dist.get_world_size(),
"rank": dist.get_rank(),
"local_rank": dist.get_local_rank(),
}
batch_size //= dp_info["world_size"] // 8
batch_size = max(batch_size, 1)
```
Ensuite, vous définissez un `DistributedSampler` en fonction du `world_size` `rank` et puis vous le transmettez au chargeur de données. Cet échantillonneur évite d' GPUs accéder à la même tranche d'un ensemble de données.
```
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=dp_info["world_size"],
rank=dp_info["rank"]
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=0,
pin_memory=True,
sampler=train_sampler,
)
```
Ensuite, vous utilisez la `DistributedDataParallel` classe pour activer le parallélisme des données.
```
from smdistributed.dataparallel.torch.parallel.distributed import DistributedDataParallel as DDP
model = DressedQNN(qc_dev).to(device)
model = DDP(model)
torch.cuda.set_device(dp_info["local_rank"])
model.cuda(dp_info["local_rank"])
```
Les modifications ci-dessus sont nécessaires pour utiliser le parallélisme des données. Dans QML, vous souhaitez souvent enregistrer les résultats et imprimer la progression de l'entraînement. Si chaque GPU exécute la commande d'enregistrement et d'impression, le journal sera inondé d'informations répétées et les résultats se remplaceront mutuellement. Pour éviter cela, vous ne pouvez enregistrer et imprimer qu'à partir du GPU dont la valeur est `rank` 0.
```
if dp_info["rank"]==0:
print('elapsed time: ', elapsed)
torch.save(model.state_dict(), f"{output_dir}/test_local.pt")
save_job_result({"last loss": loss_before})
```
Amazon Braket Hybrid Jobs prend en charge les types d'`ml.g4dn.12xlarge`instances pour la bibliothèque parallèle de données SageMaker distribuées. Vous configurez le type d'instance via l'`InstanceConfig`argument dans Hybrid Jobs. Pour que la bibliothèque de données parallèles SageMaker distribuées sache que le parallélisme des données est activé, vous devez ajouter deux hyperparamètres supplémentaires, définis `"true"` et `"sagemaker_instance_type"` définis `"sagemaker_distributed_dataparallel_enabled"` en fonction du type d'instance que vous utilisez. Ces deux hyperparamètres sont utilisés par le `smdistributed` package. Votre script d'algorithme n'a pas besoin de les utiliser explicitement. Dans le SDK Amazon Braket, il fournit un argument de mot clé pratique. `distribution` `distribution="data_parallel"`Dans le cadre de la création de tâches hybrides, le SDK Amazon Braket insère automatiquement les deux hyperparamètres pour vous. Si vous utilisez l'API Amazon Braket, vous devez inclure ces deux hyperparamètres.
Une fois le parallélisme des instances et des données configuré, vous pouvez désormais soumettre votre tâche hybride. Il y en a 4 GPUs dans une `ml.g4dn.12xlarge` instance. Lorsque vous définissez`instanceCount=1`, la charge de travail est répartie sur les 8 GPUs de l'instance. Lorsque vous définissez une `instanceCount` valeur supérieure à un, la charge de travail est répartie sur toutes les instances GPUs disponibles. Lorsque vous utilisez plusieurs instances, chaque instance est facturée en fonction de la durée pendant laquelle vous l'utilisez. Par exemple, lorsque vous utilisez quatre instances, le temps facturable est quatre fois supérieur au temps d'exécution par instance, car quatre instances exécutent vos charges de travail en même temps.
```
instance_config = InstanceConfig(instanceType='ml.g4dn.12xlarge',
instanceCount=1,
)
hyperparameters={"nwires": "10",
"ndata": "32",
...,
}
job = AwsQuantumJob.create(
device="local:pennylane/lightning.gpu",
source_module="qml_source",
entry_point="qml_source.train_dp",
hyperparameters=hyperparameters,
instance_config=instance_config,
distribution="data_parallel",
...
)
```
**Note**
Dans la création de tâches hybrides ci-dessus, `train_dp.py` se trouve le script d'algorithme modifié pour utiliser le parallélisme des données. N'oubliez pas que le parallélisme des données ne fonctionne correctement que lorsque vous modifiez votre script d'algorithme conformément à la section ci-dessus. Si l'option de parallélisme des données est activée sans qu'un script d'algorithme soit correctement modifié, la tâche hybride peut générer des erreurs ou chaque GPU peut traiter à plusieurs reprises la même tranche de données, ce qui est inefficace.
Si elle est utilisée correctement, l'utilisation de plusieurs instances peut entraîner une réduction de plusieurs ordres de grandeur en termes de temps et de coûts. Consultez l'[exemple de bloc-notes pour plus de détails](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb).
# Utilisation de CUDA-Q avec Amazon Braket
NVIDIA's CUDA-Qest une bibliothèque logicielle conçue pour programmer des algorithmes quantiques hybrides combinant CPUs, GPUs, et des unités de traitement quantiques (QPUs). Il fournit un modèle de programmation unifié, permettant aux développeurs d'exprimer des instructions classiques et quantiques dans un seul programme, rationalisant ainsi les flux de travail. CUDA-Qaccélère la simulation et l'exécution de programmes quantiques grâce à ses simulateurs CPU et GPU intégrés. CUDA-Qest disponible avec les instances natives de bloc-notes Braket (NBIs) et Amazon Braket Hybrid Jobs.
**Topics**
+ [CUDA-Q en NBIs](#braket-cuda-q-nbis)
+ [CUDA-Q dans les emplois hybrides](#braket-cuda-q-hybrid-jobs)
## CUDA-Q en NBIs
CUDA-Qest installé par défaut dans l'environnement Braket NBI. Vous pouvez ouvrir un CUDA-Q exemple de bloc-notes en accédant à la page du lanceur Jupyter et en sélectionnant la CUDA-Q vignette et Braket. Cela ouvre le bloc-notes d'exemple `0_Getting_started_with_CUDA-Q.ipynb` dans la fenêtre principale. Pour plus d'CUDA-Qexemples, consultez le panneau de gauche du `nvidia_cuda_q/` répertoire.
Vous pouvez également vérifier la version de CUDA-Q ou de tout autre package tiers installé dans votre NBI. Par exemple, vous pouvez exécuter la commande suivante dans une cellule de code de bloc-notes pour vérifier les versions des CUDA-Q packages Qiskit et Braket installées dans l'environnement. PennyLane
```
%pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket
```
## CUDA-Q dans les emplois hybrides
L'utilisation CUDA-Q d'[Amazon Braket Hybrid Jobs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html) offre un environnement informatique flexible et à la demande. Les instances de calcul ne s'exécutent que pendant la durée de votre charge de travail, ce qui garantit que vous ne payez que pour ce que vous utilisez. Amazon Braket Hybrid Jobs propose également une expérience évolutive. Les utilisateurs peuvent commencer par des instances plus petites pour le prototypage et les tests, puis passer à des instances plus grandes capables de gérer des charges de travail plus importantes pour des expériences complètes.
Le support Amazon Braket Hybrid Jobs GPUs est essentiel pour optimiser le potentielCUDA-Q. GPUs accélère considérablement les simulations de programmes quantiques par rapport aux simulateurs basés sur un processeur, en particulier lorsque vous travaillez avec des circuits à nombre de bits quantiques élevé. La parallélisation devient simple lorsque vous utilisez Amazon Braket CUDA-Q Hybrid Jobs. Hybrid Jobs simplifie la distribution de l'échantillonnage des circuits et des évaluations observables sur plusieurs nœuds de calcul. Cette parallélisation fluide des CUDA-Q charges de travail permet aux utilisateurs de se concentrer davantage sur le développement de leurs charges de travail plutôt que sur la mise en place d'une infrastructure pour des expériences à grande échelle.
Pour commencer, consultez l'[exemple de CUDA-Q démarrage](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/0_Getting_started_with_CUDA-Q.ipynb) sur le Github d'Amazon Braket pour utiliser un conteneur de tâches CUDA-Q hybrides fourni par Braket.
L'extrait de code suivant est un `hello-world` exemple d'exécution d'un CUDA-Q programme avec Amazon Braket Hybrid Jobs.
```
image_uri = retrieve_image(Framework.CUDAQ, AwsSession().region)
@hybrid_job(device='local:nvidia/qpp-cpu', image_uri=image_uri)
def hello_quantum():
import cudaq
# define the backend
device=get_job_device_arn()
cudaq.set_target(device.split('/')[-1])
# define the Bell circuit
kernel = cudaq.make_kernel()
qubits = kernel.qalloc(2)
kernel.h(qubits[0])
kernel.cx(qubits[0], qubits[1])
# sample the Bell circuit
result = cudaq.sample(kernel, shots_count=1000)
measurement_probabilities = dict(result.items())
return measurement_probabilities
```
L'exemple ci-dessus simule un circuit Bell sur un simulateur de processeur. Cet exemple s'exécute localement sur votre ordinateur portable ou sur votre bloc-notes Braket Jupyter. En raison de ce `local=True` paramètre, lorsque vous exécutez ce script, un conteneur démarre dans votre environnement local pour exécuter le CUDA-Q programme à des fins de test et de débogage. Une fois le test terminé, vous pouvez supprimer le `local=True` drapeau et exécuter votre tâche AWS. Pour en savoir plus, consultez l'article [Travailler avec Amazon Braket Hybrid Jobs](braket-jobs.md).
Si vos charges de travail comportent un nombre de qubits élevé, un grand nombre de circuits ou un grand nombre d'itérations, vous pouvez utiliser des ressources de calcul CPU plus puissantes en spécifiant le paramètre. `instance_config` L'extrait de code suivant montre comment configurer le `instance_config` paramètre dans le `hybrid_job` décorateur. Pour plus d'informations sur les types d'instances pris en charge, consultez [Configurer votre instance de tâche hybride](braket-jobs-configure-job-instance-for-script.md). Pour obtenir la liste des types d'instances, consultez la section Types d'[instances Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
```
@hybrid_job(
device="local:nvidia/qpp-cpu",
image_uri=image_uri,
instance_config=InstanceConfig(instanceType="ml.c5.2xlarge"),
)
def my_job_script():
...
```
Pour les charges de travail plus exigeantes, vous pouvez exécuter vos charges de travail sur un simulateur de CUDA-Q GPU. Pour activer un simulateur de GPU, utilisez le nom `nvidia` du backend. Le `nvidia` backend fonctionne comme un simulateur de CUDA-Q GPU. Ensuite, sélectionnez un type d'instance Amazon EC2 qui prend en charge un NVIDIA GPU. L'extrait de code suivant montre le décorateur configuré par GPU`hybrid_job`.
```
@hybrid_job(
device="local:nvidia/nvidia",
image_uri=image_uri,
instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"),
)
def my_job_script():
...
```
Amazon Braket Hybrid Jobs et prend en charge les simulations de GPU NBIs parallèles avec. CUDA-Q Vous pouvez paralléliser l'évaluation de plusieurs observables ou de plusieurs circuits pour améliorer les performances de votre charge de travail. Pour paralléliser plusieurs observables, apportez les modifications suivantes à votre script d'algorithme.
Définissez l'`mgpu`option du `nvidia` backend. Cela est nécessaire pour paralléliser les observables. La parallélisation utilise le MPI pour la communication entre les deux GPUs. Le MPI doit donc être initialisé avant l'exécution et finalisé après celle-ci.
Ensuite, spécifiez le mode d'exécution en réglant`execution=cudaq.parallel.mpi`. L'extrait de code suivant montre ces modifications.
```
cudaq.set_target("nvidia", option="mqpu")
cudaq.mpi.initialize()
result = cudaq.observe(
kernel, hamiltonian, shots_count=n_shots, execution=cudaq.parallel.mpi
)
cudaq.mpi.finalize()
```
Dans le `hybrid_job` décorateur, spécifiez un type d'instance qui héberge plusieurs instances GPUs , comme indiqué dans l'extrait de code suivant.
```
@hybrid_job(
device="local:nvidia/nvidia-mqpu",
instance_config=InstanceConfig(instanceType="ml.g4dn.12xlarge", instanceCount=1),
image_uri=image_uri,
)
def parallel_observables_gpu_job(sagemaker_mpi_enabled=True):
...
```
Le [carnet de simulations parallèles](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/5_Multiple_GPU_simulations.ipynb) du Github consacré aux exemples d'Amazon Braket fournit des end-to-end exemples qui montrent comment exécuter des simulations de programmes quantiques sur des backends GPU et effectuer des simulations parallèles d'observables et de lots de circuits.
### Exécution de vos charges de travail sur des ordinateurs quantiques
Après avoir terminé les tests du simulateur, vous pouvez passer à l'exécution d'expériences sur QPUs. Il suffit de passer de la cible à un QPU Amazon Braket, tel que les appareils IQMIonQ, ou. Rigetti L'extrait de code suivant montre comment définir la cible sur le périphérique. IQM Garnet Pour obtenir la liste des produits disponibles QPUs, consultez la [console Amazon Braket](https://console.aws.amazon.com/braket/home).
```
device_arn = "arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet"
cudaq.set_target("braket", machine=device_arn)
```
Pour plus d'informations sur les jobs hybrides, consultez la section [Working with Amazon Braket Hybrid Jobs](braket-jobs.md) dans le guide du développeur. Pour en savoir plus sur CUDA-Q, consultez [Documentation NVIDIA CUDA-Q](https://nvidia.github.io/cuda-quantum/latest/index.html).