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. # 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.