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.
# 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)
+ [Utiliser les 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.
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\_script.py* dans votre répertoire de travail actuel sur votre bloc-notes Braket ou dans votre environnement local. Le fichier algorithm\_script.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\_script.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\_script.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 [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)méthode 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\_training\_for\_QML.ipynb](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) dans le dossier des tâches hybrides du référentiel Github d'[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`.
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**.
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\_persistence](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 \#ADD dans le fichier algorithm\_script.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 \#ADD.
```
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}]}
```
## Utiliser les 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 \#ADD 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\_file\_suffix 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 \#ADD.
```
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
)
```