Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten mit Amazon Braket Hybrid Jobs
Amazon Braket Hybrid Jobs bietet Ihnen die Möglichkeit, hybride quantenklassische Algorithmen auszuführen, die sowohl klassische AWS Ressourcen als auch Quantenverarbeitungseinheiten () erfordern. QPUs *Hybrid Jobs ist darauf ausgelegt, die angeforderten klassischen Ressourcen hochzufahren, Ihren Algorithmus auszuführen und die Instances nach Abschluss freizugeben, sodass Sie nur für das bezahlen, was Sie tatsächlich nutzen.*
Hybrid Jobs ist ideal für lang andauernde, iterative Algorithmen, bei denen sowohl klassische Computerressourcen als auch Quantencomputer-Ressourcen verwendet werden. Bei Hybrid Jobs führt Braket Ihren Algorithmus, nachdem Sie ihn zur Ausführung eingereicht haben, in einer skalierbaren, containerisierten Umgebung aus. Sobald der Algorithmus abgeschlossen ist, können Sie die Ergebnisse abrufen.
Darüber hinaus profitieren Quantenaufgaben, die aus einem Hybrid-Job erstellt werden, von einer Warteschlange mit höherer Priorität für das QPU-Zielgerät. Diese Priorisierung stellt sicher, dass Ihre Quantenberechnungen verarbeitet und vor anderen Aufgaben ausgeführt werden, die in der Warteschlange warten. Dies ist besonders vorteilhaft für iterative Hybridalgorithmen, bei denen die Ergebnisse einer Quantenaufgabe von den Ergebnissen früherer Quantenaufgaben abhängen. [Beispiele für solche Algorithmen sind der [Quantum Approximate Optimization Algorithm (QAOA)](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_quantum_algorithms/QAOA/QAOA_braket.ipynb), der [Variational Quantum Eigensolver](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_quantum_algorithms/VQE_Chemistry/VQE_chemistry_braket.ipynb) oder das quantenmechanische Lernen.](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) Sie können den Fortschritt Ihres Algorithmus auch nahezu in Echtzeit überwachen, sodass Sie Kosten, Budget oder benutzerdefinierte Kennzahlen wie Trainingsverlust oder Erwartungswerte im Auge behalten können.
Sie können auf hybride Jobs in Braket zugreifen, indem Sie:
+ Das [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python).
+ Die [Amazon Braket-Konsole](https://console.aws.amazon.com/braket/home).
+ Das Amazon BraketAPI.
**Topics**
+ [Wann sollten Sie Amazon Braket Hybrid Jobs verwenden](#braket-jobs-use)
+ [Einen Hybrid-Job mit Amazon Braket Hybrid Jobs ausführen](#braket-jobs-works)
+ [Schlüsselkonzepte für hybride Jobs](braket-jobs-concepts.md)
+ [Voraussetzungen](braket-jobs-prerequisites.md)
+ [Erstellen Sie einen Hybrid-Job](braket-jobs-first.md)
+ [Einen Hybrid-Job stornieren](braket-jobs-cancel.md)
+ [Personalisieren Sie Ihren Hybrid-Job](braket-jobs-customize.md)
+ [Verwendung PennyLane mit Amazon Braket](hybrid.md)
+ [CUDA-Q mit Amazon Braket verwenden](braket-using-cuda-q.md)
## Wann sollten Sie Amazon Braket Hybrid Jobs verwenden
Mit Amazon Braket Hybrid Jobs können Sie hybride quantenklassische Algorithmen wie den Variational Quantum Eigensolver (VQE) und den Quantum Approximate Optimization Algorithm (QAOA) ausführen, die klassische Rechenressourcen mit Quantencomputern kombinieren, um die Leistung der heutigen Quantensysteme zu optimieren. Amazon Braket Hybrid Jobs bietet drei Hauptvorteile:
1. **Leistung**: Amazon Braket Hybrid Jobs bietet eine bessere Leistung als das Ausführen von Hybrid-Algorithmen aus Ihrer eigenen Umgebung. Während Ihr Job ausgeführt wird, hat er vorrangigen Zugriff auf die ausgewählte Ziel-QPU. Aufgaben aus Ihrem Job werden vor anderen Aufgaben ausgeführt, die sich auf dem Gerät in der Warteschlange befinden. Dies führt zu kürzeren und besser vorhersehbaren Laufzeiten für hybride Algorithmen. Amazon Braket Hybrid Jobs unterstützt auch die parametrische Kompilierung. Sie können eine Schaltung mit freien Parametern einreichen und Braket kompiliert die Schaltung einmal, ohne dass für nachfolgende Parameter-Aktualisierungen derselben Schaltung erneut kompiliert werden muss, was zu noch schnelleren Laufzeiten führt.
1. **Komfort**: Amazon Braket Hybrid Jobs vereinfacht die Einrichtung und Verwaltung Ihrer Computerumgebung und deren Betrieb, während Ihr Hybrid-Algorithmus ausgeführt wird. Sie stellen einfach Ihr Algorithmus-Skript bereit und wählen ein Quantengerät (entweder eine Quantenverarbeitungseinheit oder einen Simulator) aus, auf dem es ausgeführt werden soll. Amazon Braket wartet, bis das Zielgerät verfügbar ist, aktiviert die klassischen Ressourcen, führt die Arbeitslast in vorgefertigten Container-Umgebungen aus, gibt die Ergebnisse an Amazon Simple Storage Service (Amazon S3) zurück und gibt die Rechenressourcen frei.
1. **Metriken**: Amazon Braket Hybrid Jobs bietet on-the-fly Einblicke in laufende Algorithmen und stellt anpassbare Algorithmusmetriken nahezu in Echtzeit an Amazon CloudWatch und die Amazon Braket-Konsole bereit, sodass Sie den Fortschritt Ihrer Algorithmen verfolgen können.
## Einen Hybrid-Job mit Amazon Braket Hybrid Jobs ausführen
Um einen Hybrid-Job mit Amazon Braket Hybrid Jobs auszuführen, müssen Sie zunächst Ihren Algorithmus definieren. Sie können es definieren, indem Sie das *Algorithmus-Skript* und optional andere Abhängigkeitsdateien mit dem [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python) oder [PennyLane](https://pennylane.ai)schreiben. Wenn Sie andere (Open-Source-oder proprietäre) Bibliotheken verwenden möchten, können Sie mithilfe von Docker, das diese Bibliotheken enthält, Ihr eigenes benutzerdefiniertes Container-Image definieren. Weitere Informationen finden Sie unter [Bring Your Own Container (BYOC)](braket-jobs-byoc.md).
In beiden Fällen erstellen Sie als Nächstes einen Hybrid-Job mithilfe von Amazon BraketAPI, wobei Sie Ihr Algorithmus-Skript oder Ihren Container angeben, das Ziel-Quantengerät auswählen, das der Hybrid-Job verwenden soll, und dann aus einer Vielzahl optionaler Einstellungen wählen. Die für diese optionalen Einstellungen bereitgestellten Standardwerte funktionieren für die meisten Anwendungsfälle. Damit das Zielgerät Ihren Hybrid-Job ausführen kann, haben Sie die Wahl zwischen einer QPU, einem On-Demand-Simulator (wieSV1, DM1 oderTN1) oder der klassischen Hybrid-Job-Instanz selbst. Bei einem On-Demand-Simulator oder einer QPU führt Ihr Hybrid-Job-Container API-Aufrufe an ein Remote-Gerät durch. Bei den eingebetteten Simulatoren ist der Simulator in denselben Container eingebettet wie Ihr Algorithmus-Skript. Die [Blitzsimulatoren](https://github.com/PennyLaneAI/pennylane-lightning) von PennyLane sind in den vorgefertigten Standard-Container für Hybrid-Jobs eingebettet, den Sie verwenden können. Wenn Sie Ihren Code mit einem eingebetteten PennyLane Simulator oder einem benutzerdefinierten Simulator ausführen, können Sie einen Instanztyp sowie die Anzahl der Instanzen angeben, die Sie verwenden möchten. Die mit den einzelnen Optionen verbundenen Kosten finden Sie auf der [Seite mit den Amazon Braket-Preisen](https://aws.amazon.com/braket/pricing/).
![\[Flussdiagramm, das die Benutzerinteraktionen mit Amazon Braket-Komponenten, API, Jobs Instance und Simulatoren für Hybrid-, QPU-, On-Demand-Aufgaben und eingebettete Aufgaben zeigt. Die Ergebnisse werden im Amazon Simple Storage Service-Bucket gespeichert und mit Amazon CloudWatch auf der Amazon Braket-Konsole analysiert.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-hybrid-job-run.png)
Wenn es sich bei Ihrem Zielgerät um einen On-Demand-Simulator oder einen eingebetteten Simulator handelt, beginnt Amazon Braket sofort mit der Ausführung des Hybrid-Jobs. Es startet die Hybrid-Job-Instance (Sie können den Instance-Typ im API Aufruf anpassen), führt Ihren Algorithmus aus, schreibt die Ergebnisse in Amazon S3 und gibt Ihre Ressourcen frei. Diese Ressourcenfreigabe stellt sicher, dass Sie nur für das bezahlen, was Sie tatsächlich nutzen.
Die Gesamtzahl der gleichzeitigen Hybrid-Jobs pro Quantenverarbeitungseinheit (QPU) ist begrenzt. Heute kann jeweils nur ein Hybrid-Job auf einer QPU ausgeführt werden. Warteschlangen werden verwendet, um die Anzahl der Hybrid-Jobs zu kontrollieren, die ausgeführt werden dürfen, sodass das zulässige Limit nicht überschritten wird. Wenn es sich bei Ihrem Zielgerät um eine QPU handelt, wird Ihr Hybrid-Job zuerst in die *Job-Warteschlange* der ausgewählten QPU aufgenommen. Amazon Braket startet die benötigte Hybrid-Job-Instance und führt Ihren Hybrid-Job auf dem Gerät aus. Für die Dauer Ihres Algorithmus hat Ihr Hybrid-Job bevorzugten Zugriff. Das bedeutet, dass Quantenaufgaben aus Ihrem Hybrid-Job vor anderen Braket-Quantenaufgaben in der Warteschlange auf dem Gerät ausgeführt werden, vorausgesetzt, die Job-Quantenaufgaben werden alle paar Minuten an die QPU übermittelt. Sobald Ihr Hybrid-Job abgeschlossen ist, werden Ressourcen freigegeben, was bedeutet, dass Sie nur für das bezahlen, was Sie tatsächlich nutzen.
**Anmerkung**
Die Geräte sind regional und Ihr Hybrid-Job wird auf demselben Gerät ausgeführt AWS-Region wie Ihr primäres Gerät.
Sowohl im Simulator- als auch im QPU-Zielszenario haben Sie die Möglichkeit, benutzerdefinierte Algorithmusmetriken, z. B. die Energie Ihres Hamiltonian, als Teil Ihres Algorithmus zu definieren. Diese Metriken werden automatisch an Amazon gemeldet CloudWatch und von dort aus nahezu in Echtzeit in der Amazon Braket-Konsole angezeigt.
**Anmerkung**
Wenn Sie eine GPU-basierte Instance verwenden möchten, stellen Sie sicher, dass Sie einen der GPU-basierten Simulatoren verwenden, die mit den eingebetteten Simulatoren auf Braket verfügbar sind (z. B.). `lightning.gpu` Wenn Sie sich für einen der CPU-basierten eingebetteten Simulatoren entscheiden (z. B., oder`braket:default-simulator`)`lightning.qubit`, wird die GPU nicht verwendet und es können Ihnen unnötige Kosten entstehen.
# Schlüsselkonzepte für hybride Jobs
In diesem Abschnitt werden die wichtigsten Konzepte der vom Amazon Braket Python SDK bereitgestellten `AwsQuantumJob.create` Funktion und die Zuordnung zur Container-Dateistruktur erklärt.
Zusätzlich zu der Datei oder den Dateien, aus denen Ihr komplettes Algorithmus-Skript besteht, kann Ihr Hybrid-Job zusätzliche Eingaben und Ausgaben haben. Wenn Ihr Hybrid-Job gestartet wird, kopiert Amazon Braket die Eingaben, die im Rahmen der Hybrid-Job-Erstellung bereitgestellt wurden, in den Container, in dem das Algorithmus-Skript ausgeführt wird. Wenn der Hybrid-Job abgeschlossen ist, werden alle während des Algorithmus definierten Ausgaben an den angegebenen Amazon S3 S3-Speicherort kopiert.
**Anmerkung**
*Algorithmus-Metriken* werden in Echtzeit gemeldet und folgen nicht diesem Ausgabeverfahren.
Amazon Braket bietet auch mehrere Umgebungsvariablen und Hilfsfunktionen, um die Interaktionen mit Container-Eingaben und -Ausgaben zu vereinfachen. Weitere Informationen finden Sie im [Paket braket.jobs](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.jobs.html) im *Amazon* Braket SDK.
**Topics**
+ [Eingaben](#braket-jobs-inputs)
+ [Outputs](#braket-jobs-outputs)
+ [Umgebungsvariablen](#braket-jobs-environmental-variables)
+ [Hilfsfunktionen](#braket-jobs-helper-functions)
## Eingaben
**Eingabedaten**: Eingabedaten können dem Hybrid-Algorithmus zur Verfügung gestellt werden, indem die Eingabedatendatei, die als Wörterbuch eingerichtet ist, mit dem `input_data` Argument angegeben wird. Der Benutzer definiert das `input_data` Argument innerhalb der `AwsQuantumJob.create` Funktion im SDK. Dadurch werden die Eingabedaten in das Container-Dateisystem an dem in der Umgebungsvariablen angegebenen Speicherort kopiert`"AMZN_BRAKET_INPUT_DIR"`. Einige Beispiele dafür, wie Eingabedaten in einem hybriden Algorithmus verwendet werden, finden Sie unter [QAOA mit Amazon Braket Hybrid Jobs PennyLane und](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) [Quantum Machine Learning in Amazon Braket Hybrid](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) Jobs Jupyter-Notebooks.
**Anmerkung**
Wenn die Eingabedaten groß sind (> 1 GB), dauert es eine lange Wartezeit, bis der Hybrid-Job eingereicht wird. Dies liegt an der Tatsache, dass die lokalen Eingabedaten zuerst in einen S3-Bucket hochgeladen werden, dann der S3-Pfad zur Hybrid-Job-Anfrage hinzugefügt wird und schließlich die Hybrid-Job-Anfrage an den Braket-Service übermittelt wird.
**Hyperparameter**: Wenn Sie sie weitergeben`hyperparameters`, sind sie unter der Umgebungsvariablen verfügbar. `"AMZN_BRAKET_HP_FILE"`
**Anmerkung**
[Weitere Informationen darüber, wie Sie Hyperparameter und Eingabedaten erstellen und diese Informationen dann an das Hybrid-Job-Skript übergeben, finden Sie im Abschnitt [Hyperparameter verwenden](braket-jobs-hyperparameters.md) und auf dieser Github-Seite.](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)
**Checkpoints**: Um einen Checkpoint anzugeben`job-arn`, dessen Checkpoint Sie in einem neuen Hybrid-Job verwenden möchten, verwenden Sie den Befehl. `copy_checkpoints_from_job` Mit diesem Befehl werden die Checkpoint-Daten in den `checkpoint_configs3Uri` des neuen Hybrid-Jobs kopiert, sodass sie `AMZN_BRAKET_CHECKPOINT_DIR` während der Ausführung des Jobs unter dem in der Umgebungsvariablen angegebenen Pfad verfügbar sind. Die Standardeinstellung ist`None`, was bedeutet, dass Checkpoint-Daten aus einem anderen Hybrid-Job im neuen Hybrid-Job nicht verwendet werden.
## Outputs
**Quantenaufgaben**: Die Ergebnisse der Quantenaufgaben werden am S3-Standort `s3://amazon-braket--/jobs//tasks` gespeichert.
**Arbeitsergebnisse**: Alles, was Ihr Algorithmus-Skript in dem von der Umgebungsvariablen angegebenen Verzeichnis speichert, `"AMZN_BRAKET_JOB_RESULTS_DIR"` wird an den unter angegebenen S3-Speicherort kopiert`output_data_config`. Wenn der Wert nicht angegeben ist, ist er standardmäßig. `s3://amazon-braket--/jobs///data` Wir bieten die SDK-Hilfsfunktion **`save_job_result`**, mit der Sie Ergebnisse bequem in Form eines Wörterbuchs speichern können, wenn Sie sie von Ihrem Algorithmus-Skript aus aufrufen.
**Checkpoints**: Wenn Sie Checkpoints verwenden möchten, können Sie diese in dem durch die Umgebungsvariable angegebenen Verzeichnis speichern. `"AMZN_BRAKET_CHECKPOINT_DIR"` Sie können stattdessen auch die SDK-Hilfsfunktion `save_job_checkpoint` verwenden.
**Algorithmus-Metriken**: Sie können Algorithmus-Metriken als Teil Ihres Algorithmus-Skripts definieren, die an Amazon gesendet CloudWatch und in Echtzeit in der Amazon Braket-Konsole angezeigt werden, während Ihr Hybrid-Job ausgeführt wird. Ein Beispiel für die Verwendung von Algorithmus-Metriken finden Sie unter [Verwenden von Amazon Braket-Hybrid-Jobs zur Ausführung eines QAOA-Algorithmus](braket-jobs-run-qaoa-algorithm.md).
Weitere Informationen zum Speichern Ihrer Job-Ausgaben finden Sie unter [Speichern Ihrer Ergebnisse](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-first.html#braket-jobs-save-results) in der Dokumentation zu Hybrid-Jobs.
## Umgebungsvariablen
Amazon Braket bietet mehrere Umgebungsvariablen, um die Interaktionen mit Container-Eingaben und -Ausgaben zu vereinfachen. Der folgende Code listet die Umgebungsvariablen auf, die Braket verwendet.
+ `AMZN_BRAKET_INPUT_DIR`— Das Eingabedatenverzeichnis. opt/braket/input/data
+ `AMZN_BRAKET_JOB_RESULTS_DIR`— Das Ausgabeverzeichnisopt/braket/model, in das die Job-Ergebnisse geschrieben werden sollen.
+ `AMZN_BRAKET_JOB_NAME`— Der Name des Jobs.
+ `AMZN_BRAKET_CHECKPOINT_DIR`— Das Checkpoint-Verzeichnis.
+ `AMZN_BRAKET_HP_FILE`— Die Datei, die die Hyperparameter enthält.
+ `AMZN_BRAKET_DEVICE_ARN`— Der Geräte-ARN (AWS Ressourcenname).
+ `AMZN_BRAKET_OUT_S3_BUCKET`— Der Amazon S3 S3-Ausgabe-Bucket, wie in der `CreateJob` Anfrage angegeben`OutputDataConfig`.
+ `AMZN_BRAKET_SCRIPT_ENTRY_POINT`— Der Einstiegspunkt, wie in der `CreateJob` Anfrage angegeben`ScriptModeConfig`.
+ `AMZN_BRAKET_SCRIPT_COMPRESSION_TYPE`— Der in der `CreateJob` Anfrage angegebene Komprimierungstyp`ScriptModeConfig`.
+ `AMZN_BRAKET_SCRIPT_S3_URI`— Der Amazon S3 S3-Speicherort des Benutzerskripts, wie in der `CreateJob` Anfrage angegeben`ScriptModeConfig`.
+ `AMZN_BRAKET_TASK_RESULTS_S3_URI`— Der Amazon S3 S3-Speicherort, an dem das SDK standardmäßig die Ergebnisse der Quantenaufgabe für den Job speichern würde.
+ `AMZN_BRAKET_JOB_RESULTS_S3_PATH`— Der Amazon S3 S3-Standort, an dem die Auftragsergebnisse gespeichert würden, wie in den `CreateJob` Anfragen angegeben`OutputDataConfig`.
+ `AMZN_BRAKET_JOB_TOKEN`— Die Zeichenfolge, die an `CreateQuantumTask` den `jobToken` Parameter für Quantenaufgaben übergeben werden soll, die im Jobcontainer erstellt wurden.
## Hilfsfunktionen
Amazon Braket bietet mehrere Hilfsfunktionen, um die Interaktionen mit Container-Eingaben und -Ausgaben zu vereinfachen. Diese Hilfsfunktionen würden innerhalb des Algorithmus-Skripts aufgerufen, das zur Ausführung Ihres Hybrid-Jobs verwendet wird. Das folgende Beispiel zeigt, wie sie verwendet werden.
```
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
```
# Voraussetzungen
Bevor Sie Ihren ersten Hybridauftrag ausführen, müssen Sie sicherstellen, dass Sie über ausreichende Berechtigungen verfügen, um mit dieser Aufgabe fortzufahren. Um festzustellen, ob Sie über die richtigen Berechtigungen verfügen, wählen Sie im Menü auf der linken Seite der Braket-Konsole die Option **Berechtigungen** aus. Auf der Seite „**Berechtigungsverwaltung für Amazon Braket**“ können Sie überprüfen, ob eine Ihrer vorhandenen Rollen über ausreichende Berechtigungen verfügt, um Ihren Hybrid-Job auszuführen, oder führt Sie durch die Erstellung einer Standardrolle, die zur Ausführung Ihres Hybrid-Jobs verwendet werden kann, falls Sie noch nicht über eine solche Rolle verfügen.
![\[Seite mit Berechtigungen und Einstellungen für den Amazon Braket-Service, auf der eine serviceverknüpfte Rolle und die Option zur Überprüfung vorhandener Rollen für die Ausführungsrolle Hybrid Jobs angezeigt werden.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-permissions.png)
Um zu überprüfen, ob Sie über Rollen mit ausreichenden Berechtigungen für die Ausführung eines Hybrid-Jobs verfügen, klicken Sie auf die Schaltfläche **Bestehende Rolle überprüfen**. Wenn Sie dies tun, erhalten Sie eine Meldung, dass die Rollen gefunden wurden. Um die Namen der Rollen und ihrer Rollen zu sehen ARNs, klicken Sie auf die Schaltfläche **Rollen anzeigen**.
![\[Der Bildschirm mit den Berechtigungen und Einstellungen von Amazon Braket zeigt eine gefundene serviceverknüpfte Rolle und bestehende Rollen mit ausreichenden Berechtigungen zur Ausführung hybrider Jobs an.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-yes.png)
Wenn Sie nicht über eine Rolle mit ausreichenden Berechtigungen verfügen, um einen Hybrid-Job auszuführen, erhalten Sie eine Meldung, dass keine solche Rolle gefunden wurde. Wählen Sie die Schaltfläche **Standardrolle erstellen**, um eine Rolle mit ausreichenden Berechtigungen zu erhalten.
![\[Die Seite mit den Berechtigungen und Einstellungen von Amazon Braket zeigt, dass eine serviceverknüpfte Rolle gefunden wurde und keine Rollen zur Ausführung hybrider Jobs gefunden wurden.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-no.png)
Wenn die Rolle erfolgreich erstellt wurde, erhalten Sie eine Bestätigungsnachricht.
![\[Die Seite mit den Berechtigungen und Einstellungen von Amazon Braket zeigt, dass eine serviceverknüpfte Rolle gefunden und eine Hybrid-Job-Ausführungsrolle erfolgreich erstellt wurde.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-permissions-verify-created.png)
Wenn Sie nicht berechtigt sind, diese Anfrage zu stellen, wird Ihnen der Zugriff verweigert. Wenden Sie sich in diesem Fall an Ihren internen AWS Administrator.
![\[AccessDenied Fehlermeldung, die darauf hinweist, dass der Benutzer nicht berechtigt ist, iam: ListAttachedRolePolicies auf einem AmazonBraketJobsExecutionRole mit einer ausdrücklichen Ablehnung auszuführen.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-permissions-access-denied.png)
# Erstellen Sie einen Hybrid-Job
In diesem Abschnitt erfahren Sie, wie Sie mit einem Python-Skript einen Hybrid-Job erstellen. Informationen zum Erstellen eines Hybrid-Jobs aus lokalem Python-Code, z. B. Ihrer bevorzugten integrierten Entwicklungsumgebung (IDE) oder einem Braket-Notizbuch, finden Sie alternativ unter[Führen Sie Ihren lokalen Code als Hybrid-Job aus](braket-hybrid-job-decorator.md).
**Topics**
+ [Erstellen und ausführen](#braket-jobs-first-create)
+ [Überwachen Sie Ihre Ergebnisse](#braket-jobs-first-monitor-results)
+ [Speichern Sie Ihre Ergebnisse](#braket-jobs-save-results)
+ [Checkpoints verwenden](#braket-jobs-checkpoints)
+ [Führen Sie Ihren lokalen Code als Hybrid-Job aus](braket-hybrid-job-decorator.md)
+ [Verwendung der API mit Hybrid-Jobs](braket-jobs-api.md)
+ [Erstellen und debuggen Sie einen Hybrid-Job im lokalen Modus](braket-jobs-local-mode.md)
## Erstellen und ausführen
Sobald Sie über eine Rolle mit den Berechtigungen zur Ausführung eines Hybrid-Jobs verfügen, können Sie fortfahren. Das Herzstück Ihres ersten Braket-Hybrid-Jobs ist das *Algorithmus-Skript*. Es definiert den Algorithmus, den Sie ausführen möchten, und enthält die klassischen Logik- und Quantenaufgaben, die Teil Ihres Algorithmus sind. Zusätzlich zu Ihrem Algorithmus-Skript können Sie weitere Abhängigkeitsdateien bereitstellen. Das Algorithmusskript zusammen mit seinen Abhängigkeiten wird als *Quellmodul* bezeichnet. Der *Einstiegspunkt* definiert die erste Datei oder Funktion, die in Ihrem Quellmodul ausgeführt wird, wenn der Hybrid-Job gestartet wird.
![\[Diagramm, das den Arbeitsablauf bei der Erstellung eines Quantenjobs mithilfe einer Konsole oder eines Notebooks, der Ausführung des Algorithmus-Skripts auf einem Quantengerät und der Analyse der Ergebnisse zeigt.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-workflow.jpg)
Betrachten Sie zunächst das folgende grundlegende Beispiel für ein Algorithmus-Skript, das fünf Glockenzustände erzeugt und die entsprechenden Messergebnisse ausgibt.
```
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!")
```
Speichern Sie diese Datei mit dem Namen *algorithm\$1script.py* in Ihrem aktuellen Arbeitsverzeichnis auf Ihrem Braket-Notebook oder in der lokalen Umgebung. Die Datei algorithm\$1script.py hat `start_here()` den geplanten Einstiegspunkt.
Erstellen Sie als Nächstes eine Python-Datei oder ein Python-Notebook im selben Verzeichnis wie die Datei algorithm\$1script.py. Dieses Skript startet den Hybrid-Job und kümmert sich um jede asynchrone Verarbeitung, z. B. das Drucken des Status oder der wichtigsten Ergebnisse, an denen wir interessiert sind. Dieses Skript muss mindestens Ihr Hybrid-Job-Skript und Ihr primäres Gerät angeben.
**Anmerkung**
Weitere Informationen darüber, wie Sie ein Braket-Notizbuch erstellen oder eine Datei, z. B. die Datei *algorithm\$1script.py*, in dasselbe Verzeichnis wie die Notizbücher hochladen, finden Sie unter [Run your first circuit using the Amazon Braket Python SDK](braket-get-started-run-circuit.md)
In diesem grundlegenden ersten Fall zielen Sie auf einen Simulator ab. Welchen Typ von Quantengerät Sie auch anvisieren, ob es sich um einen Simulator oder eine tatsächliche Quantenverarbeitungseinheit (QPU) handelt, das Gerät, das Sie `device` im folgenden Skript angeben, wird zur Planung des Hybrid-Jobs verwendet und steht den Algorithmus-Skripten als Umgebungsvariable zur Verfügung. `AMZN_BRAKET_DEVICE_ARN`
**Anmerkung**
Sie können nur Geräte verwenden, die in Ihrem Hybrid-Job AWS-Region verfügbar sind. Das Amazon Braket SDK wählt dies AWS-Region auto aus. Beispielsweise kann ein Hybrid-Job in us-east-1 GeräteIonQ,SV1, und verwendenDM1, aber keine TN1 Rigetti Geräte.
Wenn Sie sich für einen Quantencomputer anstelle eines Simulators entscheiden, plant Braket Ihre Hybrid-Jobs so, dass alle ihre Quantenaufgaben mit bevorzugtem Zugriff ausgeführt werden.
```
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
)
```
Der Parameter `wait_until_complete=True` legt einen ausführlichen Modus fest, sodass Ihr Job die Ausgabe des aktuellen Jobs ausgibt, während dieser ausgeführt wird. Sie sollten eine Ausgabe sehen, die dem folgenden Beispiel ähnelt.
```
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
```
**Anmerkung**
Sie können Ihr maßgeschneidertes Modul auch mit der Methode [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) verwenden, indem Sie dessen Speicherort übergeben (entweder den Pfad zu einem lokalen Verzeichnis oder einer lokalen Datei oder einen S3-URI einer Datei tar.gz). [Ein funktionierendes Beispiel finden Sie in der Datei [Parallelize\$1Training\$1for\$1Qml.ipynb im Ordner für hybride Jobs im Github-Repository](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) für Amazon Braket-Beispiele.](https://github.com/amazon-braket/amazon-braket-examples/tree/main)
## Überwachen Sie Ihre Ergebnisse
Alternativ können Sie auf die Protokollausgabe von Amazon zugreifen CloudWatch. Gehen Sie dazu im linken Menü der Jobdetailseite zur Registerkarte **Protokollgruppen**, wählen Sie die Protokollgruppe und dann den Protokollstream aus`aws/braket/jobs`, der den Jobnamen enthält. Im obigen Beispiel ist dies `braket-job-default-1631915042705/algo-1-1631915190`.
![\[CloudWatch Protokollgruppe mit einer Liste von Protokollereignissen mit Dateipfaden und Zeitstempeln für Amazon Braket SDK-Python-Tests.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-cw-log.png)
**Sie können den Status des Hybrid-Jobs auch in der Konsole einsehen, indem Sie die Seite **Hybrid-Jobs** und dann Einstellungen auswählen.**
![\[Details zum Amazon Braket-Hybrid-Job mit Zusammenfassung, Ereigniszeiten, Quellcode- und Instance-Konfiguration sowie Stoppbedingungen.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-jobs-first-console-status.png)
Ihr Hybrid-Job erzeugt einige Artefakte in Amazon S3, während er ausgeführt wird. Der Standardname für den S3-Bucket lautet `amazon-braket--` und der Inhalt befindet sich im `jobs//` Verzeichnis. Sie können die S3-Speicherorte konfigurieren, an denen diese Artefakte gespeichert werden, indem Sie `code_location` bei der Erstellung des Hybrid-Jobs mit dem Braket Python SDK einen anderen angeben.
**Anmerkung**
Dieser S3-Bucket muss sich im selben Verzeichnis befinden AWS-Region wie Ihr Job-Skript.
Das `jobs//` Verzeichnis enthält einen Unterordner mit der Ausgabe des Einstiegspunktskripts in einer `model.tar.gz` Datei. Es gibt auch ein Verzeichnis namens`script`, das Ihre Algorithmus-Skriptartefakte in einer `source.tar.gz` Datei enthält. Die Ergebnisse Ihrer eigentlichen Quantenaufgaben befinden sich in dem Verzeichnis mit dem Namen`jobs//tasks`.
## Speichern Sie Ihre Ergebnisse
Sie können die vom Algorithmus-Skript generierten Ergebnisse speichern, sodass sie sowohl im Hybrid-Job-Objekt im Hybrid-Job-Skript als auch im Ausgabeordner in Amazon S3 (in einer TAR-ZIP-Datei namens model.tar.gz) verfügbar sind.
Die Ausgabe muss in einer Datei im JSON-Format ( JavaScript Object Notation) gespeichert werden. Wenn die Daten nicht ohne Weiteres in Text serialisiert werden können, wie im Fall eines Numpy-Arrays, können Sie eine Option zur Serialisierung mit einem ausgewählten Datenformat angeben. Weitere Informationen finden Sie im Modul [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).
Um die Ergebnisse der Hybridjobs zu speichern, fügen Sie der Datei algorithm\$1script.py die folgenden Zeilen hinzu, die mit \$1ADD kommentiert sind.
```
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!")
```
Sie können dann die Ergebnisse des Jobs aus Ihrem Jobskript anzeigen, indem Sie die mit \$1ADD **`print(job.result())`**kommentierte Zeile anhängen.
```
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
```
In diesem Beispiel haben wir die Option entfernt, `wait_until_complete=True` um ausführliche Ausgaben zu unterdrücken. Sie können es zum Debuggen wieder hinzufügen. Wenn Sie diesen Hybrid-Job ausführen, gibt er alle 10 Sekunden den Bezeichner und den`job-arn`, gefolgt vom Status des Hybrid-Jobs, aus`COMPLETED`, bis der Hybrid-Job fertig ist. Danach werden Ihnen die Ergebnisse der Glockenschaltung angezeigt. Sehen Sie sich das folgende Beispiel an.
```
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}]}
```
## Checkpoints verwenden
Mithilfe von Checkpoints können Sie Zwischeniterationen Ihrer Hybrid-Jobs speichern. Im Beispiel für ein Algorithmus-Skript aus dem vorherigen Abschnitt würden Sie die folgenden Zeilen hinzufügen, die mit \$1ADD kommentiert sind, um Checkpoint-Dateien zu erstellen.
```
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!")
```
Wenn Sie den Hybrid-Job ausführen, erstellt er die Datei *-checkpoint-1.json* in Ihren Hybrid-Job-Artefakten im Checkpoints-Verzeichnis mit einem Standardpfad. `/opt/jobs/checkpoints` Das Hybrid-Job-Skript bleibt unverändert, es sei denn, Sie möchten diesen Standardpfad ändern.
Wenn Sie einen Hybrid-Job von einem Checkpoint laden möchten, der durch einen früheren Hybrid-Job generiert wurde, verwendet `from braket.jobs import load_job_checkpoint` das Algorithmus-Skript. Die Logik zum Laden in Ihr Algorithmus-Skript lautet wie folgt.
```
from braket.jobs import load_job_checkpoint
checkpoint_1 = load_job_checkpoint(
"previous_job_name",
checkpoint_file_suffix="checkpoint-1",
)
```
Nachdem Sie diesen Checkpoint geladen haben, können Sie Ihre Logik auf der Grundlage des geladenen Inhalts fortsetzen. `checkpoint-1`
**Anmerkung**
Das *checkpoint\$1file\$1suffix muss mit dem Suffix* übereinstimmen, das zuvor bei der Erstellung des Checkpoints angegeben wurde.
Ihr Orchestrierungsskript muss den `job-arn` aus dem vorherigen Hybrid-Job stammenden Job mit der mit \$1ADD kommentierten Zeile angeben.
```
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
)
```
# Führen Sie Ihren lokalen Code als Hybrid-Job aus
Amazon Braket Hybrid Jobs bietet eine vollständig verwaltete Orchestrierung hybrider quantenklassischer Algorithmen und kombiniert Amazon EC2 EC2-Rechenressourcen mit dem Zugriff auf die Amazon Braket Quantum Processing Unit (QPU). Quantenaufgaben, die in einem Hybrid-Job erstellt wurden, haben Vorrang vor einzelnen Quantenaufgaben, sodass Ihre Algorithmen nicht durch Schwankungen in der Warteschlange für Quantenaufgaben unterbrochen werden. Jede QPU unterhält eine separate Warteschlange für Hybrid-Jobs, wodurch sichergestellt wird, dass jeweils nur ein Hybrid-Job ausgeführt werden kann.
**Topics**
+ [Erstellen Sie einen Hybrid-Job aus lokalem Python-Code](#create-hybrid-job-from-local-python-code)
+ [Installieren Sie zusätzliche Python-Pakete und Quellcode](#install-python-packages-and-code)
+ [Speichern und laden Sie Daten in eine Hybrid-Job-Instanz](#save-load-data-into-instance)
+ [Bewährte Verfahren für hybride Jobdekorateure](#best-practices)
## Erstellen Sie einen Hybrid-Job aus lokalem Python-Code
Sie können Ihren lokalen Python-Code als Amazon Braket Hybrid Job ausführen. Sie können dies tun, indem Sie Ihren Code mit einem `@hybrid_job` Decorator annotieren, wie im folgenden Codebeispiel gezeigt. Für benutzerdefinierte Umgebungen können Sie sich dafür entscheiden, [einen benutzerdefinierten Container aus Amazon Elastic Container Registry (ECR) zu verwenden](braket-jobs-byoc.md).
**Anmerkung**
Standardmäßig wird nur Python 3.12 unterstützt.
Sie können den `@hybrid_job` Decorator verwenden, um eine Funktion mit Anmerkungen zu versehen. [Braket wandelt den Code im Decorator in ein Braket-Hybrid-Job-Algorithmus-Skript um.](braket-jobs-first.md) Der Hybrid-Job ruft dann die Funktion innerhalb des Decorators auf einer Amazon EC2 EC2-Instance auf. Sie können den Fortschritt des Jobs mit `job.state()` oder mit der Braket-Konsole überwachen. Das folgende Codebeispiel zeigt, wie eine Sequenz von fünf Zuständen auf dem State Vector Simulator (SV1) device ausgeführt wird.
```
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}
```
Sie erstellen den Hybrid-Job, indem Sie die Funktion wie normale Python-Funktionen aufrufen. Die Decorator-Funktion gibt jedoch eher das Hybrid-Job-Handle als das Ergebnis der Funktion zurück. Um die Ergebnisse abzurufen, nachdem sie abgeschlossen ist, verwenden Sie`job.result()`.
```
job = run_hybrid_job(num_tasks=1)
result = job.result()
```
Das Geräteargument im `@hybrid_job` Decorator gibt das Gerät an, auf das der Hybrid-Job vorrangigen Zugriff hat — in diesem Fall den SV1 Simulator. Um die QPU-Priorität zu erhalten, müssen Sie sicherstellen, dass der in der Funktion verwendete Geräte-ARN mit dem im Decorator angegebenen übereinstimmt. Der Einfachheit halber können Sie die Hilfsfunktion verwenden, `get_job_device_arn()` um den in deklarierten Geräte-ARN zu erfassen`@hybrid_job`.
**Anmerkung**
Jeder Hybrid-Job hat mindestens eine Minute Startzeit, da er eine containerisierte Umgebung auf Amazon EC2 erstellt. Für sehr kurze Arbeitslasten, wie z. B. einen einzelnen Schaltkreis oder eine Reihe von Schaltungen, kann es daher ausreichend sein, Quantenaufgaben zu verwenden.
**Hyperparameter**
Die `run_hybrid_job()` Funktion verwendet das Argument`num_tasks`, um die Anzahl der erstellten Quantenaufgaben zu kontrollieren. Der Hybrid-Job erfasst dies automatisch als [Hyperparameter](braket-jobs-hyperparameters.md).
**Anmerkung**
Hyperparameter werden in der Braket-Konsole als Zeichenketten angezeigt, die auf 2500 Zeichen begrenzt sind.
**Metriken und Protokollierung**
Innerhalb der `run_hybrid_job()` Funktion werden Metriken aus iterativen Algorithmen mit `log_metrics` aufgezeichnet. Metriken werden automatisch auf der Braket-Konsolenseite unter der Registerkarte Hybrid-Job dargestellt. [Mit dem Braket-Kosten-Tracker können Sie die Kosten für Quantenaufgaben während der Ausführung des Hybrid-Jobs nahezu in Echtzeit verfolgen.](braket-pricing.md) [Im obigen Beispiel wird der Metrikname „Wahrscheinlichkeit“ verwendet, der die erste Wahrscheinlichkeit aus dem Ergebnistyp aufzeichnet.](braket-result-types.md)
**Ergebnisse werden abgerufen**
Nach Abschluss des Hybrid-Jobs können Sie `job.result()` die Ergebnisse der Hybrid-Jobs abrufen. Alle Objekte in der Rückmeldung werden automatisch von Braket erfasst. Beachten Sie, dass die von der Funktion zurückgegebenen Objekte ein Tupel sein müssen, wobei jedes Element serialisierbar sein muss. Der folgende Code zeigt beispielsweise ein funktionierendes und ein fehlgeschlagenes Beispiel.
```
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
```
**Name des Berufs**
Standardmäßig wird der Name für diesen Hybrid-Job aus dem Funktionsnamen abgeleitet. Sie können auch einen benutzerdefinierten Namen mit einer Länge von bis zu 50 Zeichen angeben. Im folgenden Code lautet der Jobname beispielsweise "my-job-name“.
```
@hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name")
def function():
pass
```
**Lokaler Modus**
[Lokale Jobs](braket-jobs-local-mode.md) werden erstellt, indem das Argument `local=True` zum Decorator hinzugefügt wird. Dadurch wird der Hybrid-Job in einer containerisierten Umgebung in Ihrer lokalen Computerumgebung, z. B. Ihrem Laptop, ausgeführt. Lokale Jobs haben **keine** Priorität in der Warteschlange für Quantenaufgaben. In fortgeschrittenen Fällen, wie z. B. bei mehreren Knoten oder MPI, haben lokale Jobs möglicherweise Zugriff auf die erforderlichen Braket-Umgebungsvariablen. Der folgende Code erstellt einen lokalen Hybrid-Job mit dem Gerät als Simulator. SV1
```
@hybrid_job(device=Devices.Amazon.SV1, local=True)
def run_hybrid_job(num_tasks=1):
return ...
```
Alle anderen Hybrid-Job-Optionen werden unterstützt. Eine Liste der Optionen finden Sie im Modul [braket.jobs.quantum\$1job\$1creation](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.jobs.quantum_job_creation.html).
## Installieren Sie zusätzliche Python-Pakete und Quellcode
Sie können Ihre Laufzeitumgebung so anpassen, dass sie Ihre bevorzugten Python-Pakete verwendet. Sie können entweder eine `requirements.txt` Datei, eine Liste von Paketnamen oder [Ihren eigenen Container (BYOC](braket-jobs-byoc.md)) verwenden. Die `requirements.txt` Datei kann beispielsweise andere zu installierende Pakete enthalten.
```
qiskit
pennylane >= 0.31
mitiq == 0.29
```
Informationen zum Anpassen einer Laufzeitumgebung mithilfe einer `requirements.txt` Datei finden Sie im folgenden Codebeispiel.
```
@hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt")
def run_hybrid_job(num_tasks=1):
return ...
```
Alternativ können Sie die Paketnamen wie folgt als Python-Liste angeben.
```
@hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"])
def run_hybrid_job(num_tasks=1):
return ...
```
Zusätzlicher Quellcode kann entweder als Liste von Modulen oder als einzelnes Modul wie im folgenden Codebeispiel angegeben werden.
```
@hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"])
def run_hybrid_job(num_tasks=1):
return ...
```
## Speichern und laden Sie Daten in eine Hybrid-Job-Instanz
**Geben Sie die Eingabe-Trainingsdaten an**
Wenn Sie einen Hybrid-Job erstellen, können Sie Eingabe-Trainingsdatensätze bereitstellen, indem Sie einen Amazon Simple Storage Service (Amazon S3) -Bucket angeben. Sie können auch einen lokalen Pfad angeben, dann lädt Braket die Daten automatisch auf Amazon S3 hoch unter. `s3:///jobs///data/` Wenn Sie einen lokalen Pfad angeben, ist der Kanalname standardmäßig auf „input“ eingestellt. Der folgende Code zeigt eine Numpy-Datei aus dem lokalen Pfad. `data/file.npy`
```
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 ...
```
Für S3 müssen Sie die `get_input_data_dir()` Hilfsfunktion verwenden.
```
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")
```
Sie können mehrere Eingabedatenquellen angeben, indem Sie ein Wörterbuch mit Kanalwerten und S3- URIs oder lokalen Pfaden bereitstellen.
```
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")
```
**Anmerkung**
Wenn die Eingabedaten groß sind (> 1 GB), dauert es lange, bis der Job erstellt wird. Dies liegt an den lokalen Eingabedaten, wenn sie zum ersten Mal in einen S3-Bucket hochgeladen werden. Anschließend wird der S3-Pfad zur Jobanforderung hinzugefügt. Schließlich wird die Jobanfrage an den Braket-Service übermittelt.
**Ergebnisse werden auf S3 gespeichert**
Um Ergebnisse zu speichern, die nicht in der Return-Anweisung der dekorierten Funktion enthalten sind, müssen Sie allen Schreibvorgängen von Dateien das richtige Verzeichnis anhängen. Das folgende Beispiel zeigt das Speichern eines Numpy-Arrays und einer Matplotlib-Figur.
```
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 ...
```
Alle Ergebnisse werden in einer Datei mit dem Namen komprimiert. `model.tar.gz` Sie können die Ergebnisse mit der Python-Funktion `job.result()` herunterladen oder indem Sie auf der Hybrid-Job-Seite in der Braket-Managementkonsole zum Ergebnisordner navigieren.
**Speichern und von Checkpoints aus fortsetzen**
Bei Hybrid-Jobs mit langer Laufzeit wird empfohlen, den Zwischenstatus des Algorithmus regelmäßig zu speichern. Sie können die integrierte `save_job_checkpoint()` Hilfsfunktion verwenden oder Dateien im `AMZN_BRAKET_JOB_RESULTS_DIR` Pfad speichern. Letzteres ist mit der Hilfsfunktion verfügbar`get_job_results_dir()`.
Im Folgenden finden Sie ein minimales funktionierendes Beispiel für das Speichern und Laden von Checkpoints mit einem hybriden Job Decorator:
```
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()
```
Im ersten Hybrid-Job `save_job_checkpoint()` wird ein Wörterbuch aufgerufen, das die Daten enthält, die wir speichern möchten. Standardmäßig muss jeder Wert als Text serialisierbar sein. Um komplexere Python-Objekte wie Numpy-Arrays zu überprüfen, können Sie festlegen. `data_format = PersistedJobDataFormat.PICKLED_V4` Dieser Code erstellt und überschreibt eine Checkpoint-Datei mit dem Standardnamen `.json` in Ihren Hybrid-Job-Artefakten in einem Unterordner namens „Checkpoints“.
Um einen neuen Hybrid-Job zu erstellen, um vom Checkpoint aus fortzufahren, müssen wir übergeben, `copy_checkpoints_from_job=job_arn` wo `job_arn` sich der Hybrid-Job-ARN des vorherigen Jobs befindet. Dann laden wir `load_job_checkpoint(job_name)` normalerweise vom Checkpoint aus.
## Bewährte Verfahren für hybride Jobdekorateure
**Machen Sie sich Asynchronität zu eigen**
Hybrid-Jobs, die mit der Decorator-Annotation erstellt wurden, sind asynchron — sie werden ausgeführt, sobald die klassischen Ressourcen und die Quantenressourcen verfügbar sind. Sie überwachen den Fortschritt des Algorithmus mithilfe von Braket Management Console oder Amazon CloudWatch. Wenn Sie Ihren Algorithmus zur Ausführung einreichen, führt Braket Ihren Algorithmus in einer skalierbaren containerisierten Umgebung aus und die Ergebnisse werden abgerufen, wenn der Algorithmus abgeschlossen ist.
**Führen Sie iterative Variationsalgorythmen aus**
Hybrid-Jobs bieten Ihnen die Tools, um iterative quantenklassische Algorithmen auszuführen. Verwenden Sie für reine Quantenprobleme [Quantenaufgaben](braket-submit-tasks.md) oder eine [Reihe](braket-batching-tasks.md) von Quantenaufgaben. Der bevorzugte Zugriff auf bestimmte QPUs ist am vorteilhaftesten für Variationsalgorythmen mit langer Laufzeit, die mehrere iterative Aufrufe erfordern, QPUs wobei die klassische Verarbeitung dazwischen liegt.
**Debuggen Sie im lokalen Modus**
Bevor Sie einen Hybrid-Job auf einer QPU ausführen, wird empfohlen, ihn zuerst auf dem Simulator auszuführen, SV1 um sicherzustellen, dass er wie erwartet ausgeführt wird. Für Tests in kleinem Maßstab können Sie den lokalen Modus verwenden, um eine schnelle Iteration und ein schnelles Debuggen zu ermöglichen.
**Verbessern Sie die Reproduzierbarkeit mit [Bring Your](braket-jobs-byoc.md) Own Container (BYOC)**
Erstellen Sie ein reproduzierbares Experiment, indem Sie Ihre Software und ihre Abhängigkeiten in einer containerisierten Umgebung kapseln. Indem Sie Ihren gesamten Code, Ihre Abhängigkeiten und Einstellungen in einem Container verpacken, verhindern Sie potenzielle Konflikte und Versionsprobleme.
**Verteilte Simulatoren mit mehreren Instanzen**
Wenn Sie eine große Anzahl von Schaltungen ausführen möchten, sollten Sie erwägen, die integrierte MPI-Unterstützung zu verwenden, um lokale Simulatoren auf mehreren Instanzen innerhalb eines einzigen Hybrid-Jobs auszuführen. Weitere Informationen finden Sie unter [Integrierte](pennylane-embedded-simulators.md) Simulatoren.
**Verwenden Sie parametrische Schaltungen**
Parametrische Schaltungen, die Sie über einen Hybrid-Job einreichen, werden bei bestimmten QPUs Anwendungen automatisch [kompiliert](braket-jobs-parametric-compilation.md), um die Laufzeit Ihrer Algorithmen zu verbessern.
**Regelmäßiger Checkpoint**
Bei Hybrid-Jobs mit langer Laufzeit wird empfohlen, den Zwischenstatus des Algorithmus regelmäßig zu speichern.
**Weitere Beispiele, Anwendungsfälle und bewährte Methoden finden Sie in den [Amazon Braket-Beispielen](https://github.com/amazon-braket/amazon-braket-examples). GitHub**
# Verwendung der API mit Hybrid-Jobs
Über den können Sie direkt auf Amazon Braket Hybrid Jobs zugreifen und mit diesen interagieren. API Standardwerte und praktische Methoden sind jedoch nicht verfügbar, wenn Sie den API direkt verwenden.
**Anmerkung**
Wir empfehlen dringend, dass Sie mit Amazon Braket Hybrid Jobs über das [Amazon Braket Python](https://github.com/aws/amazon-braket-sdk-python) SDK interagieren. Es bietet praktische Standardeinstellungen und Schutzmaßnahmen, die dazu beitragen, dass Ihre Hybrid-Jobs erfolgreich ausgeführt werden.
Dieses Thema behandelt die Grundlagen der Verwendung von. API Wenn Sie sich für die Verwendung der API entscheiden, denken Sie daran, dass dieser Ansatz komplexer sein kann, und bereiten Sie sich auf mehrere Iterationen vor, damit Ihr Hybrid-Job ausgeführt werden kann.
Um die API verwenden zu können, sollte Ihr Konto eine Rolle in der `AmazonBraketFullAccess` verwalteten Richtlinie haben.
**Anmerkung**
Weitere Informationen darüber, wie Sie eine Rolle mit der `AmazonBraketFullAccess` verwalteten Richtlinie erhalten, finden Sie auf der Seite [Amazon Braket aktivieren](braket-enable-overview.md).
Darüber hinaus benötigen Sie eine **Ausführungsrolle**. Diese Rolle wird an den Dienst übergeben. Sie können die Rolle mit der **Amazon Braket-Konsole** erstellen. Verwenden Sie die Registerkarte **Ausführungsrollen** auf der Seite „**Berechtigungen und Einstellungen**“, um eine Standardrolle für Hybrid-Jobs zu erstellen.
Das `CreateJob` API erfordert, dass Sie alle erforderlichen Parameter für den Hybrid-Job angeben. Um Python zu verwenden, komprimieren Sie Ihre Algorithmus-Skriptdateien in ein Tar-Bundle, z. B. eine Datei input.tar.gz, und führen Sie das folgende Skript aus. Aktualisieren Sie die Teile des Codes in den spitzen Klammern (`<>`) so, dass sie mit Ihren Kontoinformationen und dem Einstiegspunkt übereinstimmen, die den Pfad, die Datei und die Methode angeben, mit der Ihr Hybrid-Job beginnt.
```
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
},
)
```
Sobald Sie Ihren Hybrid-Job erstellt haben, können Sie über die `GetJob` API oder die Konsole auf die Details des Hybrid-Jobs zugreifen. Verwenden Sie den folgenden Python-Befehl, um die Hybrid-Jobdetails aus der Python-Sitzung abzurufen, in der Sie den `createJob` Code wie im vorherigen Beispiel ausgeführt haben.
```
getJob = client.get_job(jobArn=job["jobArn"])
```
Um einen Hybridjob abzubrechen, rufen Sie den `CancelJob` API mit dem Amazon Resource Name Namen des Jobs ('JobArn') auf.
```
cancelJob = client.cancel_job(jobArn=job["jobArn"])
```
Sie können im Rahmen der `createJob` API Verwendung des `checkpointConfig` Parameters Checkpoints angeben.
```
checkpointConfig = {
"localPath" : "/opt/omega/checkpoints",
"s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints"
},
```
**Anmerkung**
Der LocalPath von `checkpointConfig` darf nicht mit einem der folgenden reservierten Pfade beginnen:`/opt/ml`, `/opt/braket``/tmp`, oder. `/usr/local/nvidia`
# Erstellen und debuggen Sie einen Hybrid-Job im lokalen Modus
Wenn Sie einen neuen Hybridalgorithmus erstellen, hilft Ihnen der lokale Modus beim Debuggen und Testen Ihres Algorithmus-Skripts. Der lokale Modus ist eine Funktion, mit der Sie Code ausführen können, den Sie in Amazon Braket Hybrid Jobs verwenden möchten, ohne dass Braket die Infrastruktur für die Ausführung des Hybrid-Jobs verwalten muss. Führen Sie Hybrid-Jobs stattdessen lokal auf Ihrer Amazon Braket Notebook-Instance oder auf einem bevorzugten Client wie einem Laptop oder Desktop-Computer aus.
Im lokalen Modus können Sie weiterhin Quantenaufgaben an tatsächliche Geräte senden, aber Sie profitieren nicht von den Leistungsvorteilen, wenn Sie sie im lokalen Modus mit einer echten Quantenverarbeitungseinheit (QPU) ausführen.
Um den lokalen Modus zu verwenden, ändern Sie ihn `AwsQuantumJob` an der `LocalQuantumJob` Stelle, an der er in Ihrem Programm vorkommt. Um beispielsweise das Beispiel aus [Create your first hybrid job (Erstellen Sie Ihren ersten Hybrid-Job](braket-jobs-first.md)) auszuführen, bearbeiten Sie das Hybrid-Job-Skript im Code wie folgt.
```
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",
)
```
**Anmerkung**
Docker, das bereits in den Amazon Braket-Notebooks vorinstalliert ist, muss in Ihrer lokalen Umgebung installiert sein, um diese Funktion nutzen zu können. [Anweisungen zur Installation von Docker finden Sie auf der Seite Get Docker.](https://docs.docker.com/get-started/get-docker/) Außerdem werden nicht alle Parameter im lokalen Modus unterstützt.
# Einen Hybrid-Job stornieren
Möglicherweise müssen Sie einen Hybrid-Job stornieren, der sich nicht im Terminalmodus befindet. Dies kann entweder in der Konsole oder mit Code erfolgen.
Um Ihren Hybrid-Job in der Konsole zu stornieren, wählen Sie auf der Seite **Hybrid-Jobs** den Hybrid-Job aus, den Sie stornieren möchten, und wählen Sie dann im Drop-down-Menü **Aktionen** die Option **Hybrid-Job stornieren** aus.
![\[Amazon Braket-Tabelle mit Hybrid-Jobs mit 4 Aufträgen, die deren Namen, Status, Geräteinformationen und Zeitstempel anzeigen. Das Drop-down-Menü „Aktionen“ enthält Optionen zum Anzeigen neuer Hybrid-Jobs, zum Stornieren oder Verwalten von Tags.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-hybrid-cancel-job.png)
Um die Stornierung zu bestätigen, geben Sie in das Eingabefeld *Abbrechen* ein, wenn Sie dazu aufgefordert werden, und wählen Sie dann **OK** aus.
![\[Dialogfenster zum Abbrechen eines bestimmten Auftrags mit Warnungen über den Abbruchvorgang und einem Texteingabefeld zur Bestätigung durch Eingabe von „Abbrechen“.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/braket-hybrid-cancel-job-confirm.png)
Um Ihren Hybrid-Job mithilfe von Code aus dem Braket Python SDK abzubrechen, identifizieren Sie den `job_arn` Hybrid-Job mit und rufen Sie dann den entsprechenden `cancel` Befehl auf, wie im folgenden Code gezeigt.
```
job = AwsQuantumJob(arn=job_arn)
job.cancel()
```
Der `cancel` Befehl beendet den klassischen Hybrid-Job-Container sofort und bemüht sich nach besten Kräften, alle zugehörigen Quantenaufgaben abzubrechen, die sich noch in einem nicht-terminalen Zustand befinden.
# Personalisieren Sie Ihren Hybrid-Job
Amazon Braket bietet mehrere Möglichkeiten, die Ausführung Ihrer Hybrid-Jobs anzupassen, sodass Sie die Umgebung an Ihre spezifischen Bedürfnisse anpassen können. In diesem Abschnitt werden Optionen für die Anpassung von Hybrid-Jobs untersucht, von der Definition der Algorithmus-Skriptumgebung bis hin zur Verwendung Ihres eigenen Containers. Sie erfahren, wie Sie Ihren Workflow mithilfe von Hyperparametern optimieren, Job-Instanzen konfigurieren und die parametrische Kompilierung nutzen können, um die Leistung zu verbessern. Diese Anpassungstechniken helfen Ihnen dabei, das Potenzial Ihrer hybriden Quantenberechnungen auf Amazon Braket zu maximieren.
**Topics**
+ [Definieren Sie die Umgebung für Ihr Algorithmus-Skript](braket-jobs-script-environment.md)
+ [Hyperparameter verwenden](braket-jobs-hyperparameters.md)
+ [Konfigurieren Sie Ihre Hybrid-Job-Instance](braket-jobs-configure-job-instance-for-script.md)
+ [Verwendung der parametrischen Kompilierung zur Beschleunigung von Hybrid-Jobs](braket-jobs-parametric-compilation.md)
# Definieren Sie die Umgebung für Ihr Algorithmus-Skript
Amazon Braket unterstützt Umgebungen, die durch Container für Ihr Algorithmus-Skript definiert sind:
+ Ein Basiscontainer (der Standard, wenn keiner angegeben `image_uri` ist)
+ Ein Container mit CUDA-Q
+ Ein Container mit Tensorflow und PennyLane
+ Ein Container mit PyTorch, und PennyLane CUDA-Q
Die folgende Tabelle enthält Einzelheiten zu den Containern und den darin enthaltenen Bibliotheken.
**Amazon Braket-Behälter**
| Typ | Base | CUDA-Q | TensorFlow | PyTorch |
| --- | --- | --- | --- | --- |
| **Bild-URI** | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest amazon-braket-base-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:aktuell amazon-braket-cudaq-jobs | 292282985366.dkr. ecr.us-east-1.amazonaws.com /:aktuell amazon-braket-tensorflow-jobs | 292282985366.dkr. ecr.us-west-2.amazonaws.com /:aktuell amazon-braket-pytorch-jobs |
| **Geerbte Bibliotheken** | | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) |
| **Zusätzliche Bibliotheken** | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/braket-jobs-script-environment.html) |
[Sie können die Open-Source-Container-Definitionen unter aws/ einsehen und darauf zugreifen. amazon-braket-containers](https://github.com/aws/amazon-braket-containers) Wählen Sie den Container, der am besten zu Ihrem Anwendungsfall passt. Sie können jede der verfügbaren AWS Regionen in Braket verwenden (us-east-1, us-west-1, us-west-2, eu-north-1, eu-west-2), aber die Container-Region muss mit der Region für Ihren Hybrid-Job übereinstimmen. Geben Sie das Container-Image an, wenn Sie einen Hybrid-Job erstellen, indem Sie Ihrem Aufruf im Hybrid-Job-Skript eines der folgenden drei Argumente hinzufügen. `create(…)` Sie können zur Laufzeit zusätzliche Abhängigkeiten in dem Container Ihrer Wahl installieren (auf Kosten des Starts oder der Laufzeit), da die Amazon Braket-Container über eine Internetverbindung verfügen. Das folgende Beispiel bezieht sich auf die Region us-west-2.
+ **Basisbild:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest“ amazon-braket-base-jobs
+ **CUDA-Q-Bild:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest“ amazon-braket-cudaq-jobs
+ **Tensorflow-Bild:** image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest“ amazon-braket-tensorflow-jobs
+ **PyTorch bild**: image\$1uri="292282985366.dkr. ecr.us-west-2.amazonaws.com /:latest“ amazon-braket-pytorch-jobs
Sie können auch mit der Funktion im Braket-SDK abgerufen werden. `image-uris` `retrieve_image()` Amazon Das folgende Beispiel zeigt, wie sie aus dem AWS-Region US-West-2 abgerufen werden können.
```
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")
```
# Verwendung Ihres eigenen Containers (BYOC)
Amazon Braket Hybrid Jobs bietet drei vorgefertigte Container für die Ausführung von Code in verschiedenen Umgebungen. Wenn einer dieser Container Ihren Anwendungsfall unterstützt, müssen Sie nur Ihr Algorithmus-Skript angeben, wenn Sie einen Hybrid-Job erstellen. Geringfügige fehlende Abhängigkeiten können mithilfe von Ihrem Algorithmus-Skript oder aus einer `requirements.txt` Datei hinzugefügt `pip` werden.
Falls keiner dieser Container Ihren Anwendungsfall unterstützt oder Sie diese erweitern möchten, unterstützt Braket Hybrid Jobs die Ausführung von Hybrid-Jobs mit Ihrem eigenen benutzerdefinierten Docker Container-Image oder Bring Your Own Container (BYOC). Stellen Sie sicher, dass es sich um die richtige Funktion für Ihren Anwendungsfall handelt.
**Topics**
+ [Wann ist es die richtige Entscheidung, meinen eigenen Container mitzubringen?](#bring-own-container-decision)
+ [Rezept für das Mitbringen eines eigenen Containers](bring-own-container-recipe.md)
+ [Braket-Hybrid-Jobs in Ihrem eigenen Container ausführen](running-hybrid-jobs-in-own-container.md)
## Wann ist es die richtige Entscheidung, meinen eigenen Container mitzubringen?
Bring Your Own Container (BYOC) zu Braket Hybrid Jobs bietet die Flexibilität, Ihre eigene Software zu verwenden, indem Sie sie in einer Paketumgebung installieren. Abhängig von Ihren spezifischen Anforderungen gibt es möglicherweise Möglichkeiten, dieselbe Flexibilität zu erreichen, ohne den gesamten URI-Zyklus BYOC Docker Build — Amazon ECR-Upload — benutzerdefiniertes Image durchlaufen zu müssen.
**Anmerkung**
BYOC ist möglicherweise nicht die richtige Wahl, wenn Sie eine kleine Anzahl zusätzlicher Python-Pakete (in der Regel weniger als 10) hinzufügen möchten, die öffentlich verfügbar sind. Zum Beispiel, wenn Sie verwenden. PyPi
In diesem Fall können Sie eines der vorgefertigten Braket-Images verwenden und dann bei der Einreichung des Jobs eine `requirements.txt` Datei in Ihr Quellverzeichnis aufnehmen. Die Datei wird automatisch gelesen und `pip` installiert die Pakete mit den angegebenen Versionen wie gewohnt. Wenn Sie eine große Anzahl von Paketen installieren, kann sich die Laufzeit Ihrer Jobs erheblich verlängern. Überprüfen Sie die Python- und gegebenenfalls die CUDA-Version des vorgefertigten Containers, den Sie verwenden möchten, um zu testen, ob Ihre Software funktioniert.
BYOC ist erforderlich, wenn Sie eine Nicht-Python-Sprache (wie C\$1\$1 oder Rust) für Ihr Job-Skript verwenden möchten oder wenn Sie eine Python-Version verwenden möchten, die nicht über die vorgefertigten Braket-Container verfügbar ist. Es ist auch eine gute Wahl, wenn:
+ Sie verwenden Software mit einem Lizenzschlüssel, und Sie müssen diesen Schlüssel auf einem Lizenzserver authentifizieren, um die Software ausführen zu können. Mit BYOC können Sie den Lizenzschlüssel in Ihr Docker Image einbetten und Code zur Authentifizierung hinzufügen.
+ Sie verwenden Software, die nicht öffentlich verfügbar ist. Die Software wird beispielsweise in einem privaten GitHub Repository GitLab oder in einem Repository gehostet, für dessen Zugriff Sie einen bestimmten SSH-Schlüssel benötigen.
+ Sie müssen eine große Softwaresuite installieren, die nicht in den von Braket bereitgestellten Containern verpackt ist. BYOC ermöglicht es Ihnen, lange Startzeiten für Ihre Hybrid-Job-Container aufgrund der Softwareinstallation zu vermeiden.
BYOC ermöglicht es Ihnen auch, Ihr benutzerdefiniertes SDK oder Ihren Algorithmus für Kunden verfügbar zu machen, indem Sie einen Docker Container mit Ihrer Software erstellen und diesen Ihren Benutzern zur Verfügung stellen. Sie können dies tun, indem Sie die entsprechenden Berechtigungen in Amazon ECR festlegen.
**Anmerkung**
Sie müssen alle geltenden Softwarelizenzen einhalten.
# Rezept für das Mitbringen eines eigenen Containers
In diesem Abschnitt finden Sie eine step-by-step Anleitung dazubring your own container (BYOC), was Sie für Braket Hybrid Jobs benötigen — die Skripts, Dateien und Schritte, um sie zu kombinieren, damit Sie mit Ihren benutzerdefinierten Docker Images loslegen können. Die Rezepte für zwei häufige Fälle:
1. Installieren Sie zusätzliche Software in einem Docker Image und verwenden Sie in Ihren Jobs nur Python-Algorithmus-Skripte.
1. Verwenden Sie Algorithmusskripte, die in einer anderen Sprache als Python geschrieben wurden, mit Hybrid Jobs oder einer anderen CPU-Architektur als x86.
Die Definition des *Container-Eintragsskripts* ist für Fall 2 komplexer.
Wenn Braket Ihren Hybrid-Job ausführt, startet es die angeforderte Anzahl und Art von Amazon EC2 EC2-Instances und führt dann das Docker Image aus, das durch die Image-URI angegeben wurde, die zur Auftragserstellung eingegeben wurde. Wenn Sie die BYOC-Funktion verwenden, geben Sie eine Bild-URI an, die in einem [privaten Amazon ECR-Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html) gehostet wird, auf das Sie Lesezugriff haben. Braket Hybrid Jobs verwendet dieses benutzerdefinierte Image, um den Job auszuführen.
Die spezifischen Komponenten, die Sie benötigen, um ein Docker Image zu erstellen, das mit Hybrid-Jobs verwendet werden kann. [Wenn Sie mit dem Schreiben und Erstellen nicht vertraut sind`Dockerfiles`, lesen Sie in der [Dockerfile-Dokumentation und in der Dokumentation](https://docs.docker.com/reference/dockerfile/) nach. Amazon ECR CLI](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html)
**Topics**
+ [Ein Basis-Image für Ihr Dockerfile](#base-image-dockerfile)
+ [(Optional) Ein modifiziertes Container-Einstiegspunktskript](#modified-container-entry-point)
+ [Installieren Sie die benötigte Software und das Container-Skript mit `Dockerfile`](#install-docketfile)
## Ein Basis-Image für Ihr Dockerfile
Wenn Sie Python verwenden und Software zusätzlich zu dem installieren möchten, was in den von Braket bereitgestellten Containern bereitgestellt wird, ist eine Option für ein Basis-Image eines der Braket-Container-Images, die in unserem [GitHub Repo](https://github.com/amazon-braket/amazon-braket-containers) und auf Amazon ECR gehostet werden. Sie müssen sich [bei Amazon ECR authentifizieren](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-authenticate-registry), um das Image abzurufen und darauf aufzubauen. Die erste Zeile Ihrer BYOC-Datei Docker könnte beispielsweise wie folgt lauten: `FROM [IMAGE_URI_HERE]`
Füllen Sie als Nächstes den Rest aus, Dockerfile um die Software zu installieren und einzurichten, die Sie dem Container hinzufügen möchten. Die vorgefertigten Braket-Images enthalten bereits das entsprechende Container-Einstiegspunkt-Skript, sodass Sie sich keine Gedanken darüber machen müssen, dieses einzubeziehen.
Wenn Sie eine Nicht-Python-Sprache wie C\$1\$1, Rust oder Julia verwenden möchten, oder wenn Sie ein Image für eine Nicht-x86-CPU-Architektur wie ARM erstellen möchten, müssen Sie möglicherweise auf einem öffentlichen Barebone-Image aufbauen. Viele solcher Bilder finden Sie in der [Amazon Elastic Container Registry Public Gallery](https://gallery.ecr.aws/). Stellen Sie sicher, dass Sie eine auswählen, die für die CPU-Architektur und gegebenenfalls für die GPU, die Sie verwenden möchten, geeignet ist.
## (Optional) Ein modifiziertes Container-Einstiegspunktskript
**Anmerkung**
Wenn Sie einem vorgefertigten Braket-Image nur zusätzliche Software hinzufügen, können Sie diesen Abschnitt überspringen.
Um Nicht-Python-Code als Teil Ihres Hybrid-Jobs auszuführen, ändern Sie das Python-Skript, das den Container-Einstiegspunkt definiert. Zum Beispiel das [`braket_container.py`Python-Skript auf dem Amazon Braket Github](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py). Dies ist das Skript, das die von Braket vorgefertigten Images verwenden, um Ihr Algorithmus-Skript zu starten und die entsprechenden Umgebungsvariablen festzulegen. Das Container-Einstiegspunktskript selbst **muss** in Python sein, kann aber Nicht-Python-Skripte starten. In dem vorgefertigten Beispiel können Sie sehen, dass Python-Algorithmus-Skripts entweder als [Python-Unterprozess](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L274) oder als [vollständig neuer](https://github.com/amazon-braket/amazon-braket-containers/blob/main/src/braket_container.py#L257) Prozess gestartet werden. Indem Sie diese Logik ändern, können Sie das Einstiegspunktskript aktivieren, um Skripten zu starten, die keine Python-Algorithmen sind. Sie könnten beispielsweise die [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)Funktion so ändern, dass sie Rust-Prozesse in Abhängigkeit von der Dateinamenerweiterung startet.
Sie können sich auch dafür entscheiden, eine komplett neue zu schreiben`braket_container.py`. Es sollte Eingabedaten, Quellarchive und andere notwendige Dateien aus Amazon S3 in den Container kopieren und die entsprechenden Umgebungsvariablen definieren.
## Installieren Sie die benötigte Software und das Container-Skript mit `Dockerfile`
**Anmerkung**
Wenn Sie ein vorgefertigtes Braket-Image als Docker Basis-Image verwenden, ist das Container-Skript bereits vorhanden.
Wenn Sie im vorherigen Schritt ein modifiziertes Container-Skript erstellt haben, müssen Sie es in den Container kopieren **und** die Umgebungsvariable `SAGEMAKER_PROGRAM` oder den Namen Ihres neuen Container-Einstiegspunktskripts definieren. `braket_container.py`
Im Folgenden finden Sie ein Beispiel für eine`Dockerfile`, mit der Sie Julia auf GPU-beschleunigten Jobs-Instanzen verwenden können:
```
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
```
In diesem Beispiel werden Skripte heruntergeladen und ausgeführt, die von bereitgestellt werden AWS , um die Einhaltung aller relevanten Open-Source-Lizenzen sicherzustellen. Zum Beispiel, indem jeder installierte Code, der von einem gesteuert wird, ordnungsgemäß zugewiesen wird. MIT license
Wenn Sie nicht-öffentlichen Code einbinden müssen, z. B. Code, der in einem privaten GitLab Speicher GitHub oder einem Repository gehostet wird, betten **Sie keine** SSH-Schlüssel in das Docker Image ein, um darauf zuzugreifen. Verwenden Sie stattdessen Docker Compose when you build, um den Zugriff auf SSH auf dem Host-Computer Docker zu ermöglichen, auf dem es basiert. Weitere Informationen finden Sie im Leitfaden [Sichere Verwendung von SSH-Schlüsseln in Docker für den Zugriff auf private Github-Repositorys](https://www.fastruby.io/blog/docker/docker-ssh-keys.html).
**Ihr Image erstellen und hochladen Docker**
Mit einem richtig definierten sind Sie nun bereit`Dockerfile`, die Schritte zum [Erstellen eines privaten Amazon ECR-Repositorys](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) zu befolgen, falls noch keines vorhanden ist. Sie können Ihr Container-Image auch erstellen, taggen und in das Repository hochladen.
Sie sind bereit, das Image zu erstellen, zu taggen und zu pushen. Eine vollständige Erläuterung der Optionen `docker build` und einige Beispiele finden Sie in der [Docker-Build-Dokumentation](https://docs.docker.com/reference/cli/docker/buildx/build/).
Für die oben definierte Beispieldatei könnten Sie Folgendes ausführen:
```
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
```
**Zuweisen geeigneter Amazon ECR-Berechtigungen**
Braket Hybrid Jobs DockerBilder müssen in privaten Amazon ECR-Repositorys gehostet werden. Standardmäßig gewährt ein privates Amazon ECR-Repo **keinen** Lesezugriff für die Braket Hybrid Jobs IAM role oder andere Benutzer, die Ihr Bild verwenden möchten, wie z. B. Mitarbeiter oder Schüler. Sie müssen [eine Repository-Richtlinie festlegen, um die](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) entsprechenden Berechtigungen zu gewähren. Im Allgemeinen sollten Sie nur den spezifischen Benutzern und IAM Rollen, die Sie für den Zugriff auf Ihre Bilder benötigen, die Erlaubnis erteilen, anstatt jedem, der über die Rechte verfügt, image URI zu erlauben, sie abzurufen.
# Braket-Hybrid-Jobs in Ihrem eigenen Container ausführen
Um einen Hybrid-Job mit Ihrem eigenen Container zu erstellen, rufen Sie `AwsQuantumJob.create()` mit dem `image_uri` angegebenen Argument auf. Sie können eine QPU, einen On-Demand-Simulator, verwenden oder Ihren Code lokal auf dem klassischen Prozessor ausführen, der mit Braket Hybrid Jobs verfügbar ist. Wir empfehlen, Ihren Code auf einem Simulator wie SV1, oder TN1 bevor Sie ihn auf einer echten QPU ausführen DM1, zu testen.
Um Ihren Code auf dem klassischen Prozessor auszuführen, spezifizieren Sie den `instanceType` und den, den `instanceCount` Sie verwenden, indem Sie den `InstanceConfig` aktualisieren. Beachten Sie, dass Sie bei Angabe von `instance_count` > 1 sicherstellen müssen, dass Ihr Code auf mehreren Hosts ausgeführt werden kann. Die Obergrenze für die Anzahl der Instanzen, die Sie wählen können, ist 5. Beispiel:
```
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",
# ...)
```
**Anmerkung**
Verwenden Sie den Geräte-ARN, um den Simulator zu verfolgen, den Sie als Metadaten für Hybrid-Jobs verwendet haben. Zulässige Werte müssen dem Format entsprechen`device = "local:/"`. Denken Sie daran `` und `` dürfen nur aus Buchstaben, Zahlen, `_``-`, und bestehen`.`. Die Zeichenfolge ist auf 256 Zeichen begrenzt.
Wenn Sie planen, BYOC zu verwenden, aber das Braket-SDK nicht zum Erstellen von Quantenaufgaben verwenden, sollten Sie den Wert der Umgebungsvariablen `AMZN_BRAKET_JOB_TOKEN` an den `jobToken` Parameter in der Anfrage übergeben. `CreateQuantumTask` Wenn Sie dies nicht tun, erhalten die Quantenaufgaben keine Priorität und werden als reguläre eigenständige Quantenaufgaben abgerechnet.
# Hyperparameter verwenden
Sie können Hyperparameter definieren, die Ihr Algorithmus benötigt, z. B. die Lernrate oder die Schrittgröße, wenn Sie einen Hybrid-Job erstellen. Hyperparameterwerte werden in der Regel zur Steuerung verschiedener Aspekte des Algorithmus verwendet und können häufig angepasst werden, um die Leistung des Algorithmus zu optimieren. Um Hyperparameter in einem Braket-Hybrid-Job zu verwenden, müssen Sie ihre Namen und Werte explizit als Wörterbuch angeben. Geben Sie die Hyperparameterwerte an, die bei der Suche nach dem optimalen Wertesatz getestet werden sollen. Der erste Schritt zur Verwendung von Hyperparametern besteht darin, die Hyperparameter als Wörterbuch einzurichten und zu definieren. Dies wird im folgenden Code beschrieben.
```
from braket.devices import Devices
device_arn = Devices.Amazon.SV1
hyperparameters = {"shots": 1_000}
```
Übergeben Sie dann die im oben angegebenen Codeausschnitt definierten Hyperparameter, damit sie in dem Algorithmus Ihrer Wahl verwendet werden sollen. Um das folgende Codebeispiel auszuführen, erstellen Sie ein Verzeichnis mit dem Namen „src“ im selben Pfad wie Ihre Hyperparameterdatei. [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)
```
*[Informationen zum Zugreifen auf Ihre Hyperparameter von Ihrem Hybrid-Job-Skript aus finden Sie in der Funktion in der Python-Datei notebook\$1runner.py. `load_jobs_hyperparams()`](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/7_Running_notebooks_as_hybrid_jobs/src/notebook_runner.py)* Führen Sie den folgenden Code aus, um *außerhalb* Ihres Hybrid-Job-Skripts auf Ihre Hyperparameter zuzugreifen.
```
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)
```
Weitere Informationen zum Erlernen der Verwendung von Hyperparametern finden Sie in den Tutorials [QAOA mit Amazon Braket Hybrid Jobs PennyLane und](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) [Quantum Machine Learning in Amazon](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) Braket Hybrid Jobs.
# Konfigurieren Sie Ihre Hybrid-Job-Instance
Abhängig von Ihrem Algorithmus haben Sie möglicherweise unterschiedliche Anforderungen. Standardmäßig führt Amazon Braket Ihr Algorithmus-Skript auf einer `ml.m5.large` Instance aus. Sie können diesen Instance-Typ jedoch anpassen, wenn Sie einen Hybrid-Job mit dem folgenden Import- und Konfigurationsargument erstellen.
```
from braket.jobs.config import InstanceConfig
job = AwsQuantumJob.create(
...
instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"), # Use NVIDIA T4 instance with 4 GPUs.
...
),
```
Wenn Sie eine eingebettete Simulation ausführen und in der Gerätekonfiguration ein lokales Gerät angegeben haben, können Sie zusätzlich mehr als eine Instanz in der anfordern, `InstanceConfig` indem Sie das angeben `instanceCount` und es auf mehr als eins setzen. Die Obergrenze liegt bei 5. Sie können beispielsweise 3 Instanzen wie folgt auswählen.
```
from braket.jobs.config import InstanceConfig
job = AwsQuantumJob.create(
...
instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge", instanceCount=3), # Use 3 NVIDIA T4 instances
...
),
```
Wenn Sie mehrere Instanzen verwenden, sollten Sie erwägen, Ihren Hybrid-Job mithilfe der Datenparallelfunktion zu verteilen. Im folgenden Beispiel-Notizbuch finden Sie weitere Informationen dazu, wie Sie sich dieses Beispiel für das [Parallelize-Training](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) für QML ansehen können.
In den folgenden drei Tabellen sind die verfügbaren Instance-Typen und Spezifikationen für Standard-, Hochleistungs- und GPU-beschleunigte Instances aufgeführt.
**Anmerkung**
Die standardmäßigen klassischen Compute-Instance-Kontingente für Hybrid-Jobs finden Sie auf der Seite [Amazon Braket-Kontingente](braket-quotas.md).
| Standard-Instances | vCPU | Arbeitsspeicher (GiB) |
| --- | --- | --- |
| ml.m5.large (Standard) | 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 |
| Hochleistungs-Instances | vCPU | Arbeitsspeicher (GiB) |
| --- | --- | --- |
| 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 |
| GPU-beschleunigte Instanzen | GPUs | vCPU | Arbeitsspeicher (GiB) | GPU-Speicher (GiB) |
| --- | --- | --- | --- | --- |
| 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 |
Jede Instanz verwendet eine Standardkonfiguration des Datenspeichers (SSD) von 30 GB. Sie können den Speicher jedoch auf die gleiche Weise anpassen, wie Sie den konfigurieren`instanceType`. Das folgende Beispiel zeigt, wie der Gesamtspeicher auf 50 GB erhöht werden kann.
```
from braket.jobs.config import InstanceConfig
job = AwsQuantumJob.create(
...
instance_config=InstanceConfig(
instanceType="ml.g4dn.xlarge",
volumeSizeInGb=50,
),
...
),
```
## Konfigurieren Sie den Standard-Bucket in `AwsSession`
Die Verwendung Ihrer eigenen `AwsSession` Instance bietet Ihnen mehr Flexibilität, z. B. die Möglichkeit, einen benutzerdefinierten Speicherort für Ihren standardmäßigen Amazon S3 S3-Bucket anzugeben. Standardmäßig `AwsSession` hat an einen vorkonfigurierten Amazon S3 S3-Bucket-Standort von`"amazon-braket-{id}-{region}"`. Sie haben jedoch die Möglichkeit, den standardmäßigen Amazon S3 S3-Bucket-Speicherort zu überschreiben, wenn Sie einen erstellen`AwsSession`. Benutzer können optional ein `AwsSession` Objekt an die `AwsQuantumJob.create()` Methode übergeben, indem sie den `aws_session` Parameter angeben, wie im folgenden Codebeispiel gezeigt.
```
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
)
```
# Verwendung der parametrischen Kompilierung zur Beschleunigung von Hybrid-Jobs
Amazon Braket unterstützt in bestimmten Fällen die parametrische Kompilierung. QPUs Auf diese Weise können Sie den mit dem rechenintensiven Kompilierungsschritt verbundenen Aufwand reduzieren, indem Sie eine Schaltung nur einmal kompilieren und nicht für jede Iteration in Ihrem hybriden Algorithmus. Dies kann die Laufzeiten von Hybrid-Jobs erheblich verbessern, da Sie vermeiden, dass Sie Ihre Schaltung bei jedem Schritt neu kompilieren müssen. Reichen Sie einfach parametrisierte Schaltungen bei einem unserer QPUs als Braket Hybrid unterstützten Job ein. Bei Hybrid-Jobs mit langer Laufzeit verwendet Braket bei der Zusammenstellung Ihrer Schaltung automatisch die aktualisierten Kalibrierungsdaten des Hardwareanbieters, um Ergebnisse von höchster Qualität zu gewährleisten.
Um eine parametrische Schaltung zu erstellen, müssen Sie zunächst Parameter als Eingaben in Ihrem Algorithmus-Skript angeben. In diesem Beispiel verwenden wir einen kleinen parametrischen Schaltkreis und ignorieren jegliche klassische Verarbeitung zwischen den einzelnen Iterationen. Bei typischen Workloads würden Sie viele Schaltungen stapelweise einreichen und eine klassische Verarbeitung durchführen, wie z. B. die Aktualisierung der Parameter in jeder Iteration.
```
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.")
```
Sie können das Algorithmus-Skript zur Ausführung als Hybrid-Job mit dem folgenden Job-Skript einreichen. Wenn der Hybrid-Job auf einer QPU ausgeführt wird, die parametrische Kompilierung unterstützt, wird die Schaltung nur beim ersten Lauf kompiliert. In nachfolgenden Läufen wird der kompilierte Schaltkreis wiederverwendet, wodurch die Laufzeitleistung des Hybrid-Jobs ohne zusätzliche Codezeilen erhöht wird.
```
from braket.aws import AwsQuantumJob
job = AwsQuantumJob.create(
device=device_arn,
source_module="algorithm_script.py",
)
```
**Anmerkung**
Die parametrische Kompilierung wird auf allen supraleitenden Gate-basierten Formularen unterstützt, Rigetti Computing mit Ausnahme QPUs von Pulspegelprogrammen.
# Verwendung PennyLane mit Amazon Braket
Hybride Algorithmen sind Algorithmen, die sowohl klassische als auch Quantenbefehle enthalten. Die klassischen Befehle werden auf klassischer Hardware (einer EC2-Instanz oder Ihrem Laptop) ausgeführt, und die Quantenbefehle werden entweder auf einem Simulator oder auf einem Quantencomputer ausgeführt. Wir empfehlen, hybride Algorithmen mithilfe der Hybrid-Jobs-Funktion auszuführen. Weitere Informationen finden Sie unter [Wann sollten Sie Amazon Braket Jobs verwenden](braket-jobs.md#braket-jobs-use)?
Mit Amazon Braket können Sie hybride Quantenalgorithmen mithilfe des **Amazon PennyLane Braket-Plug-ins oder mit dem Amazon Braket** **Python SDK** und Beispiel-Notebook-Repositorys einrichten und ausführen. Amazon Braket-Beispiel-Notebooks, die auf dem SDK basieren, ermöglichen es Ihnen, bestimmte Hybrid-Algorithmen ohne das PennyLane Plugin einzurichten und auszuführen. Wir empfehlen dies jedoch, PennyLane da es eine umfassendere Benutzererfahrung bietet.
**Über hybride Quantenalgorithmen**
Hybride Quantenalgorithmen sind heute für die Industrie wichtig, da moderne Quantencomputer im Allgemeinen Rauschen und damit Fehler erzeugen. Jedes Quantengatter, das zu einer Berechnung hinzugefügt wird, erhöht die Wahrscheinlichkeit, dass Rauschen hinzukommt. Daher können Algorithmen mit langer Laufzeit durch Rauschen überfordert werden, was zu fehlerhaften Berechnungen führt.
Reine Quantenalgorithmen wie der von Shor [(Beispiel Quantum Phase Estimation)](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Quantum_Phase_Estimation) oder der von Grover [(Grovers Beispiel) erfordern Tausende](https://github.com/aws/amazon-braket-examples/tree/main/examples/advanced_circuits_algorithms/Grover) oder Millionen von Operationen. Aus diesem Grund können sie für bestehende Quantengeräte, die allgemein als Noisy Intermediate-Scale Quantum (NISQ) -Geräte (*Noisy Intermediate-Scale* Quantum) bezeichnet werden, unpraktisch sein.
In hybriden Quantenalgorithmen arbeiten Quantenverarbeitungseinheiten (QPUs) als Co-Prozessoren für klassische Algorithmen CPUs, insbesondere um bestimmte Berechnungen in einem klassischen Algorithmus zu beschleunigen. Die Ausführung von Schaltungen wird deutlich kürzer, was mit den Möglichkeiten heutiger Geräte möglich ist.
**Topics**
+ [Amazon Braket mit PennyLane](#pennylane-option)
+ [Hybride Algorithmen in Amazon Braket-Beispielnotizbüchern](#braket-hybrid-workflow)
+ [Hybride Algorithmen mit eingebetteten Simulatoren PennyLane](#hybrid-alorithms-pennylane)
+ [Adjoint Gradient aktiviert PennyLane mit Amazon Braket-Simulatoren](#adjoint-gradient-pennylane)
+ [Hybrid-Jobs verwenden und einen QAOA-Algorithmus ausführen PennyLane](braket-jobs-run-qaoa-algorithm.md)
+ [Führen Sie hybride Workloads mit eingebetteten Simulatoren aus PennyLane](pennylane-embedded-simulators.md)
## Amazon Braket mit PennyLane
Amazon Braket bietet Unterstützung für [PennyLane](https://pennylane.ai), ein Open-Source-Software-Framework, das auf dem Konzept der *quantendifferenzierbaren* Programmierung basiert. Sie können dieses Framework verwenden, um Quantenschaltkreise auf die gleiche Weise zu trainieren, wie Sie ein neuronales Netzwerk trainieren würden, um Lösungen für Rechenprobleme in den Bereichen Quantenchemie, Quantenmaschinenlernen und Optimierung zu finden.
Die PennyLane Bibliothek bietet Schnittstellen zu vertrauten Tools für maschinelles Lernen, einschließlich PyTorch und TensorFlow, um das Training von Quantenschaltkreisen schnell und intuitiv zu gestalten.
+ **Die PennyLane Bibliothek** —— PennyLane ist in Amazon Braket-Notebooks vorinstalliert. Um von aus auf Amazon Braket-Geräte zuzugreifen PennyLane, öffnen Sie ein Notizbuch und importieren Sie die PennyLane Bibliothek mit dem folgenden Befehl.
```
import pennylane as qml
```
Tutorial-Notizbücher helfen Ihnen dabei, schnell loszulegen. Alternativ können Sie PennyLane On Amazon Braket von einer IDE Ihrer Wahl aus verwenden.
+ **Das Amazon PennyLane Braket-Plugin** — Um Ihre eigene IDE zu verwenden, können Sie das Amazon PennyLane Braket-Plugin manuell installieren. Das Plugin stellt eine Verbindung PennyLane mit dem [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python) her, sodass Sie Schaltungen PennyLane auf Amazon Braket-Geräten ausführen können. Verwenden Sie den folgenden Befehl, um PennyLane das Plugin zu installieren.
```
pip install amazon-braket-pennylane-plugin
```
Das folgende Beispiel zeigt, wie Sie den Zugriff auf Amazon Braket-Geräte einrichten in 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)
```
Tutorial-Beispiele und weitere Informationen PennyLane dazu finden Sie im [Amazon Braket-Beispiel-Repository](https://github.com/aws/amazon-braket-examples/tree/main/examples/pennylane).
Das Amazon PennyLane Braket-Plugin ermöglicht es Ihnen, PennyLane mit einer einzigen Amazon Codezeile zwischen Braket QPU und eingebetteten Simulatorgeräten zu wechseln. Es bietet zwei Amazon Braket-Quantengeräte, mit denen Sie arbeiten können: PennyLane
+ `braket.aws.qubit`für den Betrieb mit den Quantengeräten des Amazon Braket-Dienstes, einschließlich Simulatoren QPUs
+ `braket.local.qubit`für die Ausführung mit dem lokalen Simulator des Amazon Braket-SDK
Das Amazon PennyLane Braket-Plugin ist Open Source. Sie können es aus dem [PennyLane GitHub Plugin-Repository](https://github.com/aws/amazon-braket-pennylane-plugin-python) installieren.
Weitere Informationen PennyLane dazu finden Sie in der Dokumentation auf der [PennyLane Website](https://pennylane.ai).
## Hybride Algorithmen in Amazon Braket-Beispielnotizbüchern
Amazon Braket bietet eine Vielzahl von Beispiel-Notebooks, die nicht auf das PennyLane Plugin angewiesen sind, um Hybrid-Algorithmen auszuführen. Sie können mit jedem dieser [Amazon Braket-Hybrid-Beispielnotizbücher](https://github.com/aws/amazon-braket-examples/tree/main/examples/hybrid_quantum_algorithms) beginnen, in denen *Variationsmethoden* wie der Quantum Approximate Optimization Algorithm (QAOA) oder Variational Quantum Eigensolver (VQE) veranschaulicht werden.
Die Amazon Braket-Beispielnotizbücher basieren auf dem [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python). Das SDK bietet ein Framework für die Interaktion mit Quantencomputer-Hardwaregeräten über Amazon Braket. Es handelt sich um eine Open-Source-Bibliothek, die Sie beim Quantenanteil Ihres hybriden Workflows unterstützen soll.
Mit unseren [Beispiel-Notizbüchern](https://github.com/aws/amazon-braket-examples) können Sie Amazon Braket weiter erkunden.
## Hybride Algorithmen mit eingebetteten Simulatoren PennyLane
Amazon Braket Hybrid Jobs wird jetzt mit leistungsstarken CPU- und GPU-basierten Embedded-Simulatoren von geliefert. [PennyLane](https://github.com/PennyLaneAI/pennylane-lightning) [Diese Familie eingebetteter Simulatoren kann direkt in Ihren Hybrid-Job-Container eingebettet werden und umfasst den schnellen `lightning.qubit` State-Vector-Simulator, den mit der CuQuantum-Bibliothek von NVIDIA beschleunigten `lightning.gpu` Simulator und andere.](https://developer.nvidia.com/cuquantum-sdk) [Diese eingebetteten Simulatoren eignen sich ideal für variationelle Algorithmen wie maschinelles Quantenlernen, die von fortschrittlichen Methoden wie der Methode der adjungierten Differenzierung profitieren können.](https://docs.pennylane.ai/en/stable/introduction/interfaces.html#simulation-based-differentiation) Sie können diese eingebetteten Simulatoren auf einer oder mehreren CPU- oder GPU-Instanzen ausführen.
Mit Hybrid-Jobs können Sie jetzt Ihren variationellen Algorithmuscode mit einer Kombination aus einem klassischen Co-Prozessor und einer QPU, einem Amazon Braket-On-Demand-Simulator wieSV1, oder direkt mit dem eingebetteten Simulator von ausführen. PennyLane
Der eingebettete Simulator ist bereits mit dem Hybrid Jobs-Container verfügbar. Sie müssen Ihre Python-Hauptfunktion mit dem `@hybrid_job` Decorator dekorieren. Um den PennyLane `lightning.gpu` Simulator zu verwenden, müssen Sie außerdem eine GPU-Instanz angeben, `InstanceConfig` wie im folgenden Codeausschnitt gezeigt:
```
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)
...
```
Sehen Sie sich das [Beispiel-Notizbuch](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) an, um mit der Verwendung eines PennyLane eingebetteten Simulators mit Hybrid-Jobs zu beginnen.
## Adjoint Gradient aktiviert PennyLane mit Amazon Braket-Simulatoren
Mit dem PennyLane Plug-in für Amazon Braket können Sie Gradienten mithilfe der Methode der adjungierten Differenzierung berechnen, wenn Sie auf dem lokalen Zustandsvektorsimulator oder. SV1
**Hinweis:** **Um die Methode der adjungierten Differenzierung verwenden zu können, müssen Sie `diff_method='device'` in Ihrer `qnode` und nicht angeben.** `diff_method='adjoint'` Sehen Sie sich das folgende Beispiel an.
```
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)
```
**Anmerkung**
Derzeit PennyLane berechnet ich Gruppierungsindizes für QAOA-Hamiltonianer und verwendet sie, um den Hamiltonian in mehrere Erwartungswerte aufzuteilen. Wenn Sie bei der Ausführung SV1 von QAOA die Fähigkeit zur adjungierten Differenzierung verwenden möchten, müssen Sie den Kosten-Hamilton-Wert rekonstruierenPennyLane, indem Sie die Gruppierungsindizes wie folgt entfernen: `cost_h, mixer_h = qml.qaoa.max_clique(g, constrained=False) cost_h = qml.Hamiltonian(cost_h.coeffs, cost_h.ops)`
# Hybrid-Jobs verwenden und einen QAOA-Algorithmus ausführen PennyLane
In diesem Abschnitt werden Sie das Gelernte anwenden, um ein echtes Hybridprogramm PennyLane mit parametrischer Kompilierung zu schreiben. Sie verwenden das Algorithmus-Skript, um ein Problem mit dem Quantum Approximate Optimization Algorithm (QAOA) zu lösen. Das Programm erstellt eine Kostenfunktion, die einem klassischen Max-Cut-Optimierungsproblem entspricht, spezifiziert einen parametrisierten Quantenschaltkreis und verwendet eine Gradientenabstiegsmethode, um die Parameter so zu optimieren, dass die Kostenfunktion minimiert wird. In diesem Beispiel generieren wir der Einfachheit halber das Problemdiagramm im Algorithmus-Skript. Für typischere Anwendungsfälle empfiehlt es sich jedoch, die Problemspezifikation über einen speziellen Kanal in der Eingabedatenkonfiguration bereitzustellen. Das Flag `parametrize_differentiable` ist standardmäßig auf eingestellt, `True` sodass Sie automatisch die Vorteile der verbesserten Laufzeitleistung durch die parametrische Kompilierung auf supported nutzen können. 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})
```
**Anmerkung**
Die parametrische Kompilierung wird auf allen supraleitenden Gate-basierten Formularen unterstützt, Rigetti Computing mit Ausnahme QPUs von Pulspegelprogrammen.
# Führen Sie hybride Workloads mit eingebetteten Simulatoren aus PennyLane
Schauen wir uns an, wie Sie eingebettete Simulatoren von PennyLane Amazon Braket Hybrid Jobs aus verwenden können, um Hybrid-Workloads auszuführen. Der GPU-basierte eingebettete Simulator von Pennylane verwendet die [Nvidia](https://developer.nvidia.com/cuquantum-sdk) CuQuantum-Bibliothek`lightning.gpu`, um Schaltungssimulationen zu beschleunigen. Der eingebettete GPU-Simulator ist in allen [Braket-Jobcontainern](https://github.com/amazon-braket/amazon-braket-containers) vorkonfiguriert, die Benutzer sofort verwenden können. Auf dieser Seite zeigen wir Ihnen, wie Sie `lightning.gpu` damit Ihre Hybrid-Workloads beschleunigen können.
## `lightning.gpu`Für QAOA-Workloads verwenden
[Sehen Sie sich die Beispiele des Quantum Approximate Optimization Algorithm (QAOA) aus diesem Notizbuch an.](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/hybrid_jobs/2_Using_PennyLane_with_Braket_Hybrid_Jobs) Um einen eingebetteten Simulator auszuwählen, geben Sie als `device` Argument eine Zeichenfolge der folgenden Form an:. `"local:/"` Zum Beispiel würden Sie `"local:pennylane/lightning.gpu"` für festlegen`lightning.gpu`. Die Gerätezeichenfolge, die Sie dem Hybrid-Job beim Start geben, wird als Umgebungsvariable an den Job übergeben`"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)
```
Vergleichen Sie auf dieser Seite die beiden eingebetteten PennyLane Zustandsvektorsimulatoren `lightning.qubit` (der CPU-basiert) und `lightning.gpu` (der GPU-basiert ist). Stellen Sie den Simulatoren benutzerdefinierte Gate-Zerlegungen zur Verfügung, um verschiedene Gradienten zu berechnen.
Jetzt sind Sie bereit, das Skript zum Starten des Hybrid-Jobs vorzubereiten. Führen Sie den QAOA-Algorithmus mit zwei Instanztypen aus: `ml.m5.2xlarge` und. `ml.g4dn.xlarge` Der `ml.m5.2xlarge` Instanztyp ist vergleichbar mit einem Standard-Entwickler-Laptop. Dabei `ml.g4dn.xlarge` handelt es sich um eine beschleunigte Recheninstanz mit einer einzelnen NVIDIA T4-GPU mit 16 GB Arbeitsspeicher.
Um die GPU auszuführen, müssen wir zunächst ein kompatibles Image und die richtige Instanz angeben (die standardmäßig eine `ml.m5.2xlarge` Instanz ist).
```
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")
```
Diese müssen wir dann zusammen mit den aktualisierten Geräteparametern sowohl in den System- als auch in den Hybrid-Job-Argumenten in den Hybrid-Job-Decorator eingeben.
```
@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))
...
```
**Anmerkung**
Wenn Sie das mithilfe einer GPU-basierten Instanz `instance_config` als angeben, aber den `device` eingebetteten CPU-basierten Simulator (`lightning.qubit`) wählen, wird die GPU nicht verwendet. Stellen Sie sicher, dass Sie den eingebetteten GPU-basierten Simulator verwenden, wenn Sie die GPU als Ziel verwenden möchten\$1
Die durchschnittliche Iterationszeit für die `m5.2xlarge` Instanz beträgt etwa 73 Sekunden, während sie für die `ml.g4dn.xlarge` Instanz etwa 0,6 Sekunden beträgt. Für diesen 21-Qubit-Workflow bietet uns die GPU-Instanz eine 100-fache Beschleunigung. Wenn Sie sich die [Preisseite für Amazon Braket Hybrid Jobs ansehen](https://aws.amazon.com/braket/pricing/), können Sie sehen, dass die Kosten pro Minute für eine `m5.2xlarge` Instance 0,00768 USD betragen, während sie für die `ml.g4dn.xlarge` Instance 0,01227 USD betragen. In diesem Fall ist die Ausführung auf der GPU-Instanz schneller und günstiger.
## Maschinelles Quantenlernen und Datenparallelität
Wenn es sich bei Ihrem Workload-Typ um quantenmechanisches Lernen (QML) handelt, das anhand von Datensätzen trainiert, können Sie Ihren Workload mithilfe von Datenparallelität weiter beschleunigen. In QML enthält das Modell einen oder mehrere Quantenschaltkreise. Das Modell kann auch klassische neuronale Netze enthalten oder auch nicht. Beim Training des Modells mit dem Datensatz werden die Parameter im Modell aktualisiert, um die Verlustfunktion zu minimieren. Eine Verlustfunktion wird normalerweise für einen einzelnen Datenpunkt und der Gesamtverlust für den durchschnittlichen Verlust über den gesamten Datensatz definiert. In QML werden die Verluste normalerweise seriell berechnet, bevor bei Gradientenberechnungen der Durchschnitt zum Gesamtverlust berechnet wird. Dieses Verfahren ist zeitaufwändig, insbesondere wenn es Hunderte von Datenpunkten gibt.
Da der Verlust von einem Datenpunkt nicht von anderen Datenpunkten abhängt, können die Verluste parallel ausgewertet werden\$1 Verluste und Gradienten, die mit verschiedenen Datenpunkten verbunden sind, können gleichzeitig ausgewertet werden. Dies wird als Datenparallelität bezeichnet. Mit SageMaker der verteilten Datenparallelbibliothek erleichtert Ihnen Amazon Braket Hybrid Jobs die Nutzung von Datenparallelität, um Ihr Training zu beschleunigen.
Stellen Sie sich den folgenden QML-Workload für Datenparallelität vor, der den [Sonar-Datensatz](https://archive.ics.uci.edu/dataset/151/connectionist+bench+sonar+mines+vs+rocks) aus dem bekannten UCI-Repository als Beispiel für die binäre Klassifizierung verwendet. Der Sonar-Datensatz enthält 208 Datenpunkte mit jeweils 60 Merkmalen, die anhand von Sonarsignalen erfasst wurden, die von Materialien abprallen. Jeder Datenpunkt ist entweder mit „M“ für Minen oder mit „R“ für Gesteine gekennzeichnet. Unser QML-Modell besteht aus einer Eingangsschicht, einem Quantenschaltkreis als versteckte Schicht und einer Ausgangsschicht. Die Eingabe- und Ausgabeschichten sind klassische neuronale Netze, die in PyTorch implementiert sind. Der Quantenschaltkreis ist mithilfe PennyLane des qml.qnn-Moduls in die PyTorch neuronalen Netze integriert. Weitere Informationen zur Arbeitslast finden Sie in unseren [Beispiel-Notizbüchern](https://github.com/aws/amazon-braket-examples). Wie im obigen QAOA-Beispiel können Sie die Leistung der GPU nutzen, indem Sie eingebettete GPU-basierte Simulatoren wie PennyLane diese verwenden, um die Leistung gegenüber eingebetteten CPU-basierten Simulatoren `lightning.gpu` zu verbessern.
Um einen Hybrid-Job zu erstellen, können Sie das Algorithmus-Skript, das Gerät `AwsQuantumJob.create` und andere Konfigurationen über seine Schlüsselwortargumente aufrufen und angeben.
```
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,
...
)
```
Um Datenparallelität zu verwenden, müssen Sie einige Codezeilen im Algorithmus-Skript für die SageMaker verteilte Bibliothek ändern, um das Training korrekt zu parallelisieren. Zunächst importieren Sie das `smdistributed` Paket, das den Großteil der Arbeit für die Verteilung Ihrer Workloads auf mehrere und mehrere Instanzen übernimmt. GPUs Dieses Paket ist im Braket und in den Containern vorkonfiguriert. PyTorch TensorFlow Das `dist` Modul teilt unserem Algorithmus-Skript mit, wie viele GPUs für das Training (`world_size`) insgesamt vorhanden sind `rank` und wie viele `local_rank` GPU-Kerne haben. `rank`ist der absolute Index einer GPU für alle Instanzen, während `local_rank` es der Index einer GPU innerhalb einer Instanz ist. Wenn es beispielsweise vier Instanzen gibt, von denen jeweils acht für das Training GPUs zugewiesen sind, `rank` liegen die Werte zwischen 0 und 31 und die `local_rank` Bereiche zwischen 0 und 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)
```
Als Nächstes definieren Sie a `DistributedSampler` entsprechend dem `world_size` und `rank` und übergeben es dann an den Datenlader. Dieser Sampler vermeidet den GPUs Zugriff auf dasselbe Segment eines Datensatzes.
```
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,
)
```
Als Nächstes verwenden Sie die `DistributedDataParallel` Klasse, um Datenparallelität zu aktivieren.
```
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"])
```
Die oben genannten Änderungen sind erforderlich, um Datenparallelität zu verwenden. In QML möchten Sie häufig Ergebnisse speichern und den Trainingsfortschritt ausdrucken. Wenn jede GPU den Befehl zum Speichern und Drucken ausführt, wird das Protokoll mit den wiederholten Informationen überflutet und die Ergebnisse überschreiben sich gegenseitig. Um dies zu vermeiden, können Sie nur von der GPU aus speichern und drucken, die 0 hat`rank`.
```
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 unterstützt `ml.g4dn.12xlarge` Instance-Typen für die SageMaker Distributed Data Parallel Library. Sie konfigurieren den Instance-Typ über das `InstanceConfig` Argument in Hybrid Jobs. Damit die SageMaker Distributed Data Parallel Library weiß, dass Datenparallelität aktiviert ist, müssen Sie zwei zusätzliche Hyperparameter hinzufügen: `"sagemaker_distributed_dataparallel_enabled"` Einstellung auf `"true"` und `"sagemaker_instance_type"` Einstellung auf den Instanztyp, den Sie verwenden. Diese beiden Hyperparameter werden pro Paket verwendet. `smdistributed` Ihr Algorithmus-Skript muss sie nicht explizit verwenden. Im Amazon Braket SDK bietet es ein praktisches Schlüsselwortargument`distribution`. `distribution="data_parallel"`Bei der Erstellung hybrider Jobs fügt das Amazon Braket SDK die beiden Hyperparameter automatisch für Sie ein. Wenn Sie die Amazon Braket-API verwenden, müssen Sie diese beiden Hyperparameter einbeziehen.
Wenn die Instanz und die Datenparallelität konfiguriert sind, können Sie jetzt Ihren Hybrid-Job einreichen. Es gibt 4 GPUs in einer `ml.g4dn.12xlarge` Instanz. Wenn Sie diese Einstellung `instanceCount=1` vornehmen, wird die Arbeitslast auf die 8 Instanzen GPUs in der Instanz verteilt. Wenn Sie `instanceCount` mehr als eine festlegen, wird die Arbeitslast auf alle GPUs verfügbaren Instanzen verteilt. Wenn Sie mehrere Instanzen verwenden, fällt für jede Instanz eine Gebühr an, die davon abhängt, wie lange Sie sie verwenden. Wenn Sie beispielsweise vier Instances verwenden, beträgt die abrechnungsfähige Zeit das Vierfache der Laufzeit pro Instance, da Ihre Workloads von vier Instances gleichzeitig ausgeführt werden.
```
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",
...
)
```
**Anmerkung**
In der obigen Hybrid-Job-Erstellung `train_dp.py` ist das modifizierte Algorithmus-Skript für die Nutzung von Datenparallelität enthalten. Beachten Sie, dass Datenparallelität nur dann korrekt funktioniert, wenn Sie Ihr Algorithmus-Skript gemäß dem obigen Abschnitt ändern. Wenn die Option Datenparallelität ohne ein korrekt modifiziertes Algorithmus-Skript aktiviert ist, kann der Hybrid-Job Fehler auslösen, oder jede GPU kann wiederholt denselben Datenabschnitt verarbeiten, was ineffizient ist.
Bei richtiger Anwendung kann die Verwendung mehrerer Instanzen zu einer erheblichen Zeit- und Kostenreduzierung führen. Weitere Informationen finden Sie im [Beispiel-Notizbuch](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb).
# CUDA-Q mit Amazon Braket verwenden
NVIDIA's CUDA-Qist eine Softwarebibliothek, die für die Programmierung hybrider Quantenalgorithmen entwickelt wurde CPUs GPUs, die, und Quantenverarbeitungseinheiten (QPUs) kombinieren. Sie bietet ein einheitliches Programmiermodell, das es Entwicklern ermöglicht, sowohl klassische als auch Quantenbefehle in einem einzigen Programm auszudrücken und so Arbeitsabläufe zu rationalisieren. CUDA-Qbeschleunigt die Simulation und Laufzeit von Quantenprogrammen mit seinen integrierten CPU- und GPU-Simulatoren. CUDA-Qist mit nativen Braket-Notebook-Instances (NBIs) und Amazon Braket Hybrid Jobs verfügbar.
**Topics**
+ [CUDA-Q im NBIs](#braket-cuda-q-nbis)
+ [CUDA-Q bei Hybridaufträgen](#braket-cuda-q-hybrid-jobs)
## CUDA-Q im NBIs
CUDA-Qist standardmäßig in der Braket-NBI-Umgebung installiert. Sie können ein CUDA-Q Beispiel-Notizbuch öffnen, indem Sie auf der Jupyter Launcher-Seite die Kachel und Braket auswählen. CUDA-Q Dadurch wird das Beispiel-Notizbuch `0_Getting_started_with_CUDA-Q.ipynb` im Hauptfenster geöffnet. Weitere CUDA-Q Beispiele finden Sie im linken Bereich des `nvidia_cuda_q/` Verzeichnisses.
Sie können auch die Version von CUDA-Q oder einem anderen Paket eines Drittanbieters überprüfen, das in Ihrem NBI installiert ist. Sie können beispielsweise den folgenden Befehl in einer Notebook-Codezelle ausführenCUDA-Q, um die Versionen der Pakete Qiskit und Braket zu überprüfen PennyLane, die in der Umgebung installiert sind.
```
%pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket
```
## CUDA-Q bei Hybridaufträgen
Die Verwendung CUDA-Q auf [Amazon Braket Hybrid Jobs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html) bietet eine flexible On-Demand-Computerumgebung. Recheninstanzen werden nur für die Dauer Ihrer Arbeitslast ausgeführt, sodass sichergestellt ist, dass Sie nur für das bezahlen, was Sie tatsächlich nutzen. Amazon Braket Hybrid Jobs bietet auch ein skalierbares Erlebnis. Benutzer können mit kleineren Instances für das Prototyping und Testen beginnen und dann auf größere Instances skalieren, die größere Workloads für vollständige Experimente bewältigen können.
Amazon Braket Hybrid Jobs-Unterstützung GPUs , die für die Maximierung CUDA-Q des Potenzials unerlässlich ist. GPUs beschleunigt die Simulationen von Quantenprogrammen im Vergleich zu CPU-basierten Simulatoren erheblich, insbesondere bei der Arbeit mit Schaltungen mit hoher Qubitzahl. Die Parallelisierung wird bei der Verwendung CUDA-Q auf Amazon Braket Hybrid Jobs unkompliziert. Hybrid Jobs vereinfacht die Verteilung von Schaltkreisabtastungen und beobachtbaren Auswertungen auf mehrere Rechenknoten. Diese nahtlose Parallelisierung der CUDA-Q Workloads ermöglicht es den Benutzern, sich mehr auf die Entwicklung ihrer Workloads zu konzentrieren, anstatt die Infrastruktur für groß angelegte Experimente einzurichten.
Sehen Sie sich zunächst das [CUDA-QStarter-Beispiel](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/0_Getting_started_with_CUDA-Q.ipynb) auf dem Github für Amazon Braket-Beispiele an, um einen von Braket bereitgestellten CUDA-Q Hybrid-Job-Container zu verwenden.
Der folgende Codeausschnitt ist ein `hello-world` Beispiel für die Ausführung eines CUDA-Q Programms mit 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
```
Das obige Beispiel simuliert eine Bell-Schaltung auf einem CPU-Simulator. Dieses Beispiel wird lokal auf Ihrem Laptop oder Braket Jupyter-Notebook ausgeführt. Aufgrund der `local=True` Einstellung wird bei der Ausführung dieses Skripts ein Container in Ihrer lokalen Umgebung gestartet, um das CUDA-Q Programm zum Testen und Debuggen auszuführen. Nachdem Sie den Test abgeschlossen haben, können Sie die `local=True` Markierung entfernen und Ihren Job AWS weiterführen. Weitere Informationen finden Sie unter [Arbeiten mit Amazon Braket Hybrid Jobs](braket-jobs.md).
Wenn Ihre Workloads eine hohe Qubit-Anzahl, eine große Anzahl von Schaltungen oder eine große Anzahl von Iterationen aufweisen, können Sie leistungsstärkere CPU-Rechenressourcen verwenden, indem Sie die Einstellung angeben. `instance_config` Der folgende Codeausschnitt zeigt, wie Sie die Einstellung im Decorator konfigurieren. `instance_config` `hybrid_job` Weitere Informationen zu den unterstützten Instanztypen finden [Sie unter Konfiguration Ihrer Hybrid-Job-Instanz](braket-jobs-configure-job-instance-for-script.md). Eine Liste der Instance-Typen finden Sie unter [Amazon EC2 EC2-Instance-Typen](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():
...
```
Für anspruchsvollere Workloads können Sie Ihre Workloads auf einem CUDA-Q GPU-Simulator ausführen. Verwenden Sie den Backend-Namen, um einen GPU-Simulator zu aktivieren. `nvidia` Das `nvidia` Backend arbeitet als CUDA-Q GPU-Simulator. Wählen Sie als Nächstes einen Amazon EC2 EC2-Instance-Typ aus, der eine NVIDIA GPU unterstützt. Der folgende Codeausschnitt zeigt den GPU-konfigurierten Decorator. `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 und NBIs unterstützt parallel GPU-Simulationen mitCUDA-Q. Sie können die Auswertung mehrerer Observables oder mehrerer Schaltungen parallelisieren, um die Leistung Ihres Workloads zu steigern. Um mehrere Observables zu parallelisieren, nehmen Sie die folgenden Änderungen an Ihrem Algorithmus-Skript vor.
Stellen Sie die `mgpu` Option des Backends ein. `nvidia` Dies ist erforderlich, um die Observablen zu parallelisieren. Bei der Parallelisierung wird MPI für die Kommunikation zwischen beiden verwendet. GPUs Daher muss MPI vor der Ausführung initialisiert und danach finalisiert werden.
Geben Sie als Nächstes den Ausführungsmodus durch Einstellung an. `execution=cudaq.parallel.mpi` Der folgende Codeausschnitt zeigt diese Änderungen.
```
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()
```
Geben Sie im `hybrid_job` Decorator einen Instanztyp an, der mehrere Instanzen hostet, GPUs wie im folgenden Codeausschnitt gezeigt.
```
@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):
...
```
Das [Notizbuch für parallel Simulationen](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/5_Multiple_GPU_simulations.ipynb) im Github Amazon Braket-Beispiele enthält end-to-end Beispiele, die zeigen, wie Quantenprogrammsimulationen auf GPU-Backends ausgeführt und parallel Simulationen von Observablen und Schaltkreisstapeln durchgeführt werden können.
### Ihre Workloads auf Quantencomputern ausführen
Nach Abschluss der Simulatortests können Sie zur Ausführung von Experimenten am übergehen QPUs. Stellen Sie das Ziel einfach auf eine Amazon Braket-QPU um, z. B. auf die IQM GeräteIonQ, oderRigetti. Der folgende Codeausschnitt veranschaulicht, wie Sie das Ziel für das Gerät festlegen. IQM Garnet Eine Liste der verfügbaren QPUs Produkte finden Sie in der [Amazon Braket-Konsole](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)
```
Weitere Informationen zu Hybrid-Jobs finden Sie unter [Arbeiten mit Amazon Braket Hybrid Jobs](braket-jobs.md) im Entwicklerhandbuch. Weitere Informationen über CUDA-Q finden Sie in der [NVIDIA CUDA-QDokumentation](https://nvidia.github.io/cuda-quantum/latest/index.html).