Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Buat Job Hybrid Bagian ini menunjukkan kepada Anda cara membuat Job Hybrid menggunakan skrip Python. Atau, untuk membuat pekerjaan hybrid dari kode Python lokal, seperti lingkungan pengembangan terintegrasi (IDE) pilihan Anda atau notebook Braket, lihat. [Jalankan kode lokal Anda sebagai pekerjaan hibrida](braket-hybrid-job-decorator.md) **Topics** + [Buat dan jalankan](#braket-jobs-first-create) + [Pantau hasil Anda](#braket-jobs-first-monitor-results) + [Simpan hasil Anda](#braket-jobs-save-results) + [Menggunakan pos pemeriksaan](#braket-jobs-checkpoints) + [Jalankan kode lokal Anda sebagai pekerjaan hibrida](braket-hybrid-job-decorator.md) + [Menggunakan API dengan Hybrid Jobs](braket-jobs-api.md) + [Membuat dan men-debug pekerjaan hybrid dengan mode lokal](braket-jobs-local-mode.md) ## Buat dan jalankan Setelah Anda memiliki peran dengan izin untuk menjalankan pekerjaan hibrida, Anda siap untuk melanjutkan. Bagian kunci dari pekerjaan hybrid Braket pertama Anda adalah *skrip algoritma*. Ini mendefinisikan algoritma yang ingin Anda jalankan dan berisi logika klasik dan tugas kuantum yang merupakan bagian dari algoritma Anda. Selain skrip algoritme Anda, Anda dapat menyediakan file ketergantungan lainnya. Skrip algoritma bersama dengan dependensinya disebut modul *sumber*. *Titik masuk* mendefinisikan file atau fungsi pertama yang dijalankan di modul sumber Anda saat pekerjaan hybrid dimulai. ![\[Diagram yang menunjukkan alur kerja pembuatan pekerjaan kuantum menggunakan konsol atau notebook, menjalankan skrip algoritme pada perangkat kuantum, dan menganalisis hasil.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/braket-jobs-first-workflow.jpg) Pertama, pertimbangkan contoh dasar berikut dari skrip algoritme yang menciptakan lima status lonceng dan mencetak hasil pengukuran yang sesuai. ``` 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!") ``` Simpan file ini dengan nama *algorithm\$1script.py* di direktori kerja Anda saat ini di notebook Braket atau lingkungan lokal Anda. File algorithm\$1script.py memiliki `start_here()` titik masuk yang direncanakan. Selanjutnya, buat file Python atau notebook Python di direktori yang sama dengan file algorithm\$1script.py. Skrip ini memulai pekerjaan hybrid dan menangani pemrosesan asinkron apa pun, seperti mencetak status atau hasil utama yang kami minati. Minimal, skrip ini perlu menentukan skrip pekerjaan hybrid dan perangkat utama Anda. **catatan** Untuk informasi selengkapnya tentang cara membuat buku catatan Braket atau mengunggah file, seperti file *algorithm\$1script.py*, di direktori yang sama dengan notebook, lihat [Menjalankan sirkuit pertama Anda menggunakan Amazon Braket Python](braket-get-started-run-circuit.md) SDK Untuk kasus pertama dasar ini, Anda menargetkan simulator. Jenis perangkat kuantum apa pun yang Anda targetkan, simulator atau unit pemrosesan kuantum aktual (QPU), perangkat yang Anda tentukan `device` dalam skrip berikut digunakan untuk menjadwalkan pekerjaan hibrida dan tersedia untuk skrip algoritme sebagai variabel lingkungan. `AMZN_BRAKET_DEVICE_ARN` **catatan** Anda hanya dapat menggunakan perangkat yang tersedia di Wilayah AWS pekerjaan hybrid Anda. Amazon Braket SDK auto memilih ini. Wilayah AWS Misalnya, pekerjaan hybrid di us-east-1 dapat IonQ menggunakanSV1,,, TN1 dan perangkatDM1, tetapi bukan perangkat. Rigetti Jika Anda memilih komputer kuantum alih-alih simulator, Braket menjadwalkan pekerjaan hibrida Anda untuk menjalankan semua tugas kuantum mereka dengan akses prioritas. ``` 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 ) ``` Parameter `wait_until_complete=True` menetapkan mode verbose sehingga pekerjaan Anda mencetak output dari pekerjaan yang sebenarnya saat sedang berjalan. Anda akan melihat output yang mirip dengan contoh berikut. ``` 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 ``` **catatan** Anda juga dapat menggunakan modul yang dibuat khusus dengan [AwsQuantumJobmetode.create](https://amazon-braket-sdk-python.readthedocs.io/en/latest/_apidoc/braket.aws.aws_quantum_job.html#braket.aws.aws_quantum_job.AwsQuantumJob.create) dengan meneruskan lokasinya (baik jalur ke direktori atau file lokal, atau URI S3 dari file tar.gz). [Untuk contoh kerja, lihat [Parallelize\$1TRAINING\$1FOR\$1QML.ipynb](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/hybrid_jobs/5_Parallelize_training_for_QML/Parallelize_training_for_QML.ipynb) file di folder pekerjaan hybrid di contoh Amazon Braket repo Github.](https://github.com/amazon-braket/amazon-braket-examples/tree/main) ## Pantau hasil Anda Atau, Anda dapat mengakses output log dari Amazon CloudWatch. Untuk melakukan ini, buka tab **Grup log** di menu kiri halaman detail pekerjaan, pilih grup log`aws/braket/jobs`, lalu pilih aliran log yang berisi nama pekerjaan. Dalam contoh di atas, ini adalah`braket-job-default-1631915042705/algo-1-1631915190`. ![\[CloudWatch grup log yang menampilkan daftar peristiwa log dengan jalur file dan stempel waktu untuk pengujian Python SDK Amazon Braket.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/braket-jobs-first-cw-log.png) Anda juga dapat melihat status pekerjaan hybrid di konsol dengan memilih halaman **Pekerjaan Hybrid** dan kemudian memilih **Pengaturan**. ![\[Detail pekerjaan hybrid Amazon Braket yang menampilkan ringkasan, waktu kejadian, kode sumber dan konfigurasi instans, serta kondisi penghentian.\]](http://docs.aws.amazon.com/id_id/braket/latest/developerguide/images/braket-jobs-first-console-status.png) Pekerjaan hybrid Anda menghasilkan beberapa artefak di Amazon S3 saat berjalan. Nama bucket S3 default adalah `amazon-braket--` dan isinya ada di `jobs//` direktori. Anda dapat mengonfigurasi lokasi S3 tempat artefak ini disimpan dengan menentukan yang berbeda `code_location` saat pekerjaan hybrid dibuat dengan Braket Python SDK. **catatan** Bucket S3 ini harus terletak Wilayah AWS sama dengan skrip pekerjaan Anda. `jobs//`Direktori berisi subfolder dengan output dari skrip titik masuk dalam `model.tar.gz` file. Ada juga direktori bernama `script` yang berisi artefak skrip algoritma Anda dalam sebuah `source.tar.gz` file. Hasil dari tugas kuantum Anda yang sebenarnya ada di direktori bernama`jobs//tasks`. ## Simpan hasil Anda Anda dapat menyimpan hasil yang dihasilkan oleh skrip algoritme sehingga tersedia dari objek pekerjaan hibrida dalam skrip pekerjaan hibrida serta dari folder keluaran di Amazon S3 (dalam file tar-zip bernama model.tar.gz). Output harus disimpan dalam file menggunakan format JavaScript Object Notation (JSON). Jika data tidak dapat dengan mudah diserialisasikan ke teks, seperti dalam kasus array numpy, Anda dapat meneruskan opsi untuk membuat serial menggunakan format data acar. Lihat 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) untuk detail selengkapnya. Untuk menyimpan hasil pekerjaan hybrid, tambahkan baris berikut yang dikomentari dengan \$1ADD ke file algorithm\$1script.py. ``` import os from braket.aws import AwsDevice from braket.circuits import Circuit from braket.jobs import save_job_result # ADD def start_here(): print("Test job started!") device = AwsDevice(os.environ['AMZN_BRAKET_DEVICE_ARN']) results = [] # ADD bell = Circuit().h(0).cnot(0, 1) for count in range(5): task = device.run(bell, shots=100) print(task.result().measurement_counts) results.append(task.result().measurement_counts) # ADD save_job_result({"measurement_counts": results}) # ADD print("Test job completed!") ``` Anda kemudian dapat menampilkan hasil pekerjaan dari skrip pekerjaan Anda dengan menambahkan baris yang **`print(job.result())`**dikomentari dengan \$1ADD. ``` import time from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( source_module="algorithm_script.py", entry_point="algorithm_script:start_here", device="arn:aws:braket:::device/quantum-simulator/amazon/sv1", ) print(job.arn) while job.state() not in AwsQuantumJob.TERMINAL_STATES: print(job.state()) time.sleep(10) print(job.state()) print(job.result()) # ADD ``` Dalam contoh ini, kami telah menghapus `wait_until_complete=True` untuk menekan output verbose. Anda dapat menambahkannya kembali untuk debugging. Ketika Anda menjalankan pekerjaan hibrida ini, ia mengeluarkan pengenal dan`job-arn`, diikuti oleh status pekerjaan hibrida setiap 10 detik hingga pekerjaan hibrida`COMPLETED`, setelah itu menunjukkan kepada Anda hasil sirkuit bel. Lihat contoh berikut ini. ``` 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}]} ``` ## Menggunakan pos pemeriksaan Anda dapat menyimpan iterasi perantara dari pekerjaan hybrid Anda menggunakan pos pemeriksaan. Dalam contoh skrip algoritma dari bagian sebelumnya, Anda akan menambahkan baris berikut yang dikomentari dengan \$1ADD untuk membuat file pos pemeriksaan. ``` 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!") ``` Saat Anda menjalankan pekerjaan hybrid, itu membuat file *-checkpoint-1.json* di artefak pekerjaan hybrid Anda di direktori pos pemeriksaan dengan jalur default. `/opt/jobs/checkpoints` Skrip pekerjaan hybrid tetap tidak berubah kecuali Anda ingin mengubah jalur default ini. Jika Anda ingin memuat pekerjaan hybrid dari pos pemeriksaan yang dihasilkan oleh pekerjaan hybrid sebelumnya, skrip algoritme menggunakan`from braket.jobs import load_job_checkpoint`. Logika untuk memuat dalam skrip algoritme Anda adalah sebagai berikut. ``` from braket.jobs import load_job_checkpoint checkpoint_1 = load_job_checkpoint( "previous_job_name", checkpoint_file_suffix="checkpoint-1", ) ``` Setelah memuat pos pemeriksaan ini, Anda dapat melanjutkan logika berdasarkan konten yang dimuat`checkpoint-1`. **catatan** *Checkpoint\$1file\$1suffix* harus cocok dengan akhiran yang ditentukan sebelumnya saat membuat pos pemeriksaan. Skrip orkestrasi Anda perlu menentukan `job-arn` dari pekerjaan hybrid sebelumnya dengan baris yang dikomentari dengan \$1ADD. ``` from braket.aws import AwsQuantumJob job = AwsQuantumJob.create( source_module="source_dir", entry_point="source_dir.algorithm_script:start_here", device="arn:aws:braket:::device/quantum-simulator/amazon/sv1", copy_checkpoints_from_job="", #ADD ) ``` # Jalankan kode lokal Anda sebagai pekerjaan hibrida Amazon Braket Hybrid Jobs menyediakan orkestrasi algoritma klasik kuantum hibrida yang dikelola sepenuhnya, menggabungkan sumber daya komputasi Amazon EC2 dengan akses Unit Pemrosesan Kuantum Amazon Braket (QPU). Tugas kuantum yang dibuat dalam pekerjaan hibrida memiliki antrian prioritas di atas tugas kuantum individu sehingga algoritme Anda tidak akan terganggu oleh fluktuasi dalam antrian tugas kuantum. Setiap QPU mempertahankan antrian pekerjaan hibrida yang terpisah, memastikan bahwa hanya satu pekerjaan hibrida yang dapat berjalan pada waktu tertentu. **Topics** + [Buat pekerjaan hybrid dari kode Python lokal](#create-hybrid-job-from-local-python-code) + [Instal paket Python tambahan dan kode sumber](#install-python-packages-and-code) + [Menyimpan dan memuat data ke dalam instance pekerjaan hibrida](#save-load-data-into-instance) + [Praktik terbaik untuk dekorator pekerjaan hibrida](#best-practices) ## Buat pekerjaan hybrid dari kode Python lokal Anda dapat menjalankan kode Python lokal Anda sebagai Amazon Braket Hybrid Job. Anda dapat melakukan ini dengan membuat anotasi kode Anda dengan `@hybrid_job` dekorator, seperti yang ditunjukkan pada contoh kode berikut. Untuk lingkungan khusus, Anda dapat memilih untuk [menggunakan wadah khusus](braket-jobs-byoc.md) dari Amazon Elastic Container Registry (ECR). **catatan** Hanya Python 3.12 yang didukung secara default. Anda dapat menggunakan `@hybrid_job` dekorator untuk membubuhi keterangan suatu fungsi. [Braket mengubah kode di dalam dekorator menjadi skrip algoritma pekerjaan hibrida Braket.](braket-jobs-first.md) Pekerjaan hybrid kemudian memanggil fungsi di dalam dekorator pada instans Amazon EC2. Anda dapat memantau kemajuan pekerjaan dengan `job.state()` atau dengan konsol Braket. Contoh kode berikut menunjukkan bagaimana menjalankan urutan lima status padaState Vector Simulator (SV1) device. ``` from braket.aws import AwsDevice from braket.circuits import Circuit, FreeParameter, Observable from braket.devices import Devices from braket.jobs.hybrid_job import hybrid_job from braket.jobs.metrics import log_metric device_arn = Devices.Amazon.SV1 @hybrid_job(device=device_arn) # Choose priority device def run_hybrid_job(num_tasks=1): device = AwsDevice(device_arn) # Declare AwsDevice within the hybrid job # Create a parametric circuit circ = Circuit() circ.rx(0, FreeParameter("theta")) circ.cnot(0, 1) circ.expectation(observable=Observable.X(), target=0) theta = 0.0 # Initial parameter for i in range(num_tasks): task = device.run(circ, shots=100, inputs={"theta": theta}) # Input parameters exp_val = task.result().values[0] theta += exp_val # Modify the parameter (possibly gradient descent) log_metric(metric_name="exp_val", value=exp_val, iteration_number=i) return {"final_theta": theta, "final_exp_val": exp_val} ``` Anda membuat pekerjaan hybrid dengan menjalankan fungsi seperti yang Anda lakukan pada fungsi Python normal. Namun, fungsi dekorator mengembalikan pegangan pekerjaan hibrida daripada hasil fungsi. Untuk mengambil hasil setelah selesai, gunakan`job.result()`. ``` job = run_hybrid_job(num_tasks=1) result = job.result() ``` Argumen perangkat di `@hybrid_job` dekorator menentukan perangkat yang memiliki akses prioritas pekerjaan hybrid - dalam hal ini, simulator. SV1 Untuk mendapatkan prioritas QPU, Anda harus memastikan bahwa perangkat ARN yang digunakan dalam fungsi cocok dengan yang ditentukan dalam dekorator. Untuk kenyamanan, Anda dapat menggunakan fungsi pembantu `get_job_device_arn()` untuk menangkap perangkat yang dideklarasikan ARN. `@hybrid_job` **catatan** Setiap pekerjaan hybrid memiliki setidaknya satu menit waktu startup karena menciptakan lingkungan kontainer di Amazon EC2. Jadi untuk beban kerja yang sangat singkat, seperti rangkaian tunggal atau sekumpulan sirkuit, mungkin cukup bagi Anda untuk menggunakan tugas kuantum. **Hiperparameter** `run_hybrid_job()`Fungsi mengambil argumen `num_tasks` untuk mengontrol jumlah tugas kuantum yang dibuat. Pekerjaan hybrid secara otomatis menangkap ini sebagai [hyperparameter](braket-jobs-hyperparameters.md). **catatan** Hyperparameters ditampilkan di konsol Braket sebagai string, yang dibatasi hingga 2500 karakter. **Metrik dan pencatatan** Dalam `run_hybrid_job()` fungsi tersebut, metrik dari algoritma iteratif direkam dengan. `log_metrics` Metrik secara otomatis diplot di halaman konsol Braket di bawah tab pekerjaan hybrid. Anda dapat menggunakan metrik untuk melacak biaya tugas kuantum secara mendekati waktu nyata selama pekerjaan hibrida dijalankan dengan pelacak biaya [Braket](braket-pricing.md). Contoh di atas menggunakan nama metrik “probabilitas” yang mencatat probabilitas pertama dari [jenis hasil](braket-result-types.md). **Mengambil hasil** Setelah pekerjaan hybrid selesai, Anda gunakan `job.result()` untuk mengambil hasil pekerjaan hibrida. Setiap objek dalam pernyataan pengembalian secara otomatis ditangkap oleh Braket. Perhatikan bahwa objek yang dikembalikan oleh fungsi harus berupa tupel dengan setiap elemen menjadi serializable. Misalnya, kode berikut menunjukkan contoh yang berfungsi, dan gagal. ``` 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 ``` **Nama Job** Secara default, nama untuk pekerjaan hybrid ini disimpulkan dari nama fungsi. Anda juga dapat menentukan nama kustom hingga 50 karakter. Misalnya, dalam kode berikut nama pekerjaan adalah "my-job-name”. ``` @hybrid_job(device=Devices.Amazon.SV1, job_name="my-job-name") def function(): pass ``` **Modus lokal** [Pekerjaan lokal](braket-jobs-local-mode.md) dibuat dengan menambahkan argumen `local=True` ke dekorator. Ini menjalankan pekerjaan hybrid di lingkungan kontainer di lingkungan komputasi lokal Anda, seperti laptop Anda. Pekerjaan lokal **tidak** memiliki antrian prioritas untuk tugas-tugas kuantum. Untuk kasus lanjutan seperti multi-node atau MPI, pekerjaan lokal mungkin memiliki akses ke variabel lingkungan Braket yang diperlukan. Kode berikut membuat pekerjaan hybrid lokal dengan perangkat sebagai SV1 simulator. ``` @hybrid_job(device=Devices.Amazon.SV1, local=True) def run_hybrid_job(num_tasks=1): return ... ``` Semua opsi pekerjaan hybrid lainnya didukung. Untuk daftar opsi, lihat modul [braket.jobs.quantum\$1job\$1creation](https://amazon-braket-sdk-python.readthedocs.io/en/stable/_apidoc/braket.jobs.quantum_job_creation.html). ## Instal paket Python tambahan dan kode sumber Anda dapat menyesuaikan lingkungan runtime Anda untuk menggunakan paket Python pilihan Anda. Anda dapat menggunakan `requirements.txt` file, daftar nama paket, atau [membawa wadah Anda sendiri (BYOC](braket-jobs-byoc.md)). Misalnya, `requirements.txt` file tersebut mungkin menyertakan paket lain untuk diinstal. ``` qiskit pennylane >= 0.31 mitiq == 0.29 ``` Untuk menyesuaikan lingkungan runtime menggunakan `requirements.txt` file, lihat contoh kode berikut. ``` @hybrid_job(device=Devices.Amazon.SV1, dependencies="requirements.txt") def run_hybrid_job(num_tasks=1): return ... ``` Atau, Anda dapat memberikan nama paket sebagai daftar Python sebagai berikut. ``` @hybrid_job(device=Devices.Amazon.SV1, dependencies=["qiskit", "pennylane>=0.31", "mitiq==0.29"]) def run_hybrid_job(num_tasks=1): return ... ``` Kode sumber tambahan dapat ditentukan baik sebagai daftar modul, atau modul tunggal seperti pada contoh kode berikut. ``` @hybrid_job(device=Devices.Amazon.SV1, include_modules=["my_module1", "my_module2"]) def run_hybrid_job(num_tasks=1): return ... ``` ## Menyimpan dan memuat data ke dalam instance pekerjaan hibrida **Menentukan data pelatihan input** Saat membuat pekerjaan hybrid, Anda dapat memberikan kumpulan data pelatihan input dengan menentukan bucket Amazon Simple Storage Service (Amazon S3). Anda juga dapat menentukan jalur lokal, lalu Braket secara otomatis mengunggah data ke Amazon S3 di. `s3:///jobs///data/` Jika Anda menentukan jalur lokal, nama saluran default ke “input”. Kode berikut menunjukkan file numpy dari jalur `data/file.npy` lokal. ``` 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 ... ``` Untuk S3, Anda harus menggunakan fungsi `get_input_data_dir()` pembantu. ``` 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") ``` Anda dapat menentukan beberapa sumber data input dengan menyediakan kamus nilai saluran dan jalur S3 URIs atau lokal. ``` 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") ``` **catatan** Ketika data input besar (> 1GB), ada waktu tunggu yang lama sebelum pekerjaan dibuat. Ini karena data input lokal saat pertama kali diunggah ke bucket S3, kemudian jalur S3 ditambahkan ke permintaan pekerjaan. Akhirnya, permintaan pekerjaan diajukan ke layanan Braket. **Menyimpan hasil ke S3** Untuk menyimpan hasil yang tidak termasuk dalam pernyataan pengembalian fungsi yang didekorasi, Anda harus menambahkan direktori yang benar ke semua operasi penulisan file. Contoh berikut, menunjukkan menyimpan array numpy dan angka matplotlib. ``` import matplotlib.pyplot as plt import numpy as np @hybrid_job(device=Devices.Amazon.SV1) def run_hybrid_job(num_tasks=1): result = np.random.rand(5) # Save a numpy array np.save("result.npy", result) # Save a matplotlib figure plt.plot(result) plt.savefig("fig.png") return ... ``` Semua hasil dikompresi menjadi file bernama`model.tar.gz`. Anda dapat mengunduh hasilnya dengan fungsi Python`job.result()`, atau dengan menavigasi ke folder hasil dari halaman pekerjaan hybrid di konsol manajemen Braket. **Menyimpan dan melanjutkan dari pos pemeriksaan** Untuk pekerjaan hybrid yang berjalan lama, disarankan untuk secara berkala menyimpan keadaan perantara algoritma. Anda dapat menggunakan fungsi `save_job_checkpoint()` pembantu bawaan, atau menyimpan file ke `AMZN_BRAKET_JOB_RESULTS_DIR` jalur. Nanti tersedia dengan fungsi `get_job_results_dir()` pembantu. Berikut ini adalah contoh kerja minimal untuk menyimpan dan memuat pos pemeriksaan dengan dekorator pekerjaan hybrid: ``` 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() ``` Dalam pekerjaan hybrid pertama, `save_job_checkpoint()` disebut dengan kamus yang berisi data yang ingin kita simpan. Secara default, setiap nilai harus dapat diserialkan sebagai teks. Untuk memeriksa objek Python yang lebih kompleks, seperti array numpy, Anda dapat mengatur. `data_format = PersistedJobDataFormat.PICKLED_V4` Kode ini membuat dan menimpa file pos pemeriksaan dengan nama default di artefak pekerjaan hibrida Anda `.json` di bawah subfolder yang disebut “pos pemeriksaan”. Untuk membuat pekerjaan hybrid baru untuk melanjutkan dari pos pemeriksaan, kita harus lulus `copy_checkpoints_from_job=job_arn` di `job_arn` mana ARN pekerjaan hybrid dari pekerjaan sebelumnya. Kemudian kita gunakan `load_job_checkpoint(job_name)` untuk memuat dari pos pemeriksaan. ## Praktik terbaik untuk dekorator pekerjaan hibrida **Merangkul asinkron** Pekerjaan hibrida yang dibuat dengan anotasi dekorator tidak sinkron - mereka berjalan setelah sumber daya klasik dan kuantum tersedia. Anda memantau kemajuan algoritma menggunakan Braket Management Console atau Amazon CloudWatch. Saat Anda mengirimkan algoritme untuk dijalankan, Braket menjalankan algoritme Anda di lingkungan kontainer yang dapat diskalakan dan hasilnya diambil saat algoritme selesai. **Jalankan algoritma variasional berulang** Pekerjaan hybrid memberi Anda alat untuk menjalankan algoritme klasik kuantum berulang. Untuk masalah kuantum murni, gunakan [tugas kuantum](braket-submit-tasks.md) atau [sekumpulan tugas kuantum](braket-batching-tasks.md). Akses prioritas ke tertentu paling QPUs bermanfaat untuk algoritme variasional yang berjalan lama yang membutuhkan beberapa panggilan berulang ke QPUs dengan pemrosesan klasik di antaranya. **Debug menggunakan mode lokal** Sebelum Anda menjalankan pekerjaan hybrid pada QPU, disarankan untuk menjalankan simulator terlebih dahulu SV1 untuk mengonfirmasi bahwa itu berjalan seperti yang diharapkan. Untuk pengujian skala kecil, Anda dapat menjalankan dengan mode lokal untuk iterasi cepat dan debugging. **Tingkatkan reproduktifitas dengan [Bring your own container](braket-jobs-byoc.md) (BYOC)** Buat eksperimen yang dapat direproduksi dengan mengenkapsulasi perangkat lunak Anda dan dependensinya dalam lingkungan kontainerisasi. Dengan mengemas semua kode, dependensi, dan pengaturan Anda dalam wadah, Anda mencegah potensi konflik dan masalah pembuatan versi. **Simulator terdistribusi multi-instance** Untuk menjalankan sejumlah besar sirkuit, pertimbangkan untuk menggunakan dukungan MPI bawaan untuk menjalankan simulator lokal pada beberapa instance dalam satu pekerjaan hybrid. Untuk informasi selengkapnya, lihat [simulator tertanam](pennylane-embedded-simulators.md). **Gunakan sirkuit parametrik** Sirkuit parametrik yang Anda kirimkan dari pekerjaan hybrid secara otomatis dikompilasi secara tertentu QPUs menggunakan [kompilasi parametrik](braket-jobs-parametric-compilation.md) untuk meningkatkan runtime algoritme Anda. **Pos pemeriksaan secara berkala** Untuk pekerjaan hybrid yang berjalan lama, disarankan untuk secara berkala menyimpan keadaan perantara algoritma. **Untuk contoh lebih lanjut, kasus penggunaan, dan praktik terbaik, lihat contoh [Amazon GitHub Braket](https://github.com/amazon-braket/amazon-braket-examples).** # Menggunakan API dengan Hybrid Jobs Anda dapat mengakses dan berinteraksi dengan Amazon Braket Hybrid Jobs secara langsung menggunakan. API Namun, metode default dan kenyamanan tidak tersedia saat menggunakan secara langsung. API **catatan** Kami sangat menyarankan agar Anda berinteraksi dengan Amazon Braket Hybrid Jobs menggunakan Amazon [Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python). Ini menawarkan default dan perlindungan yang nyaman yang membantu pekerjaan hibrida Anda berjalan dengan sukses. Topik ini mencakup dasar-dasar penggunaanAPI. Jika Anda memilih untuk menggunakan API, perlu diingat bahwa pendekatan ini bisa lebih kompleks dan bersiaplah untuk beberapa iterasi agar pekerjaan hybrid Anda berjalan. Untuk menggunakan API, akun Anda harus memiliki peran dengan kebijakan `AmazonBraketFullAccess` terkelola. **catatan** Untuk informasi selengkapnya tentang cara mendapatkan peran dengan kebijakan `AmazonBraketFullAccess` terkelola, lihat halaman [Aktifkan Amazon Braket](braket-enable-overview.md). Selain itu, Anda memerlukan **peran eksekusi**. Peran ini akan diteruskan ke layanan. Anda dapat membuat peran menggunakan konsol **Amazon Braket**. Gunakan tab **Peran eksekusi** pada halaman **Izin dan pengaturan** untuk membuat peran default untuk pekerjaan hibrida. Ini `CreateJob` API mengharuskan Anda menentukan semua parameter yang diperlukan untuk pekerjaan hybrid. Untuk menggunakan Python, kompres file skrip algoritme Anda ke bundel tar, seperti file input.tar.gz, dan jalankan skrip berikut. Perbarui bagian kode dalam kurung miring (`<>`) agar sesuai dengan informasi akun Anda dan titik masuk yang menentukan jalur, file, dan metode tempat pekerjaan hibrida Anda dimulai. ``` 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 }, ) ``` Setelah Anda membuat pekerjaan hybrid, Anda dapat mengakses detail pekerjaan hybrid melalui `GetJob` API atau konsol. Untuk mendapatkan rincian pekerjaan hybrid dari sesi Python di mana Anda menjalankan `createJob` kode seperti pada contoh sebelumnya, gunakan perintah Python berikut. ``` getJob = client.get_job(jobArn=job["jobArn"]) ``` Untuk membatalkan pekerjaan hibrida, hubungi `CancelJob` API dengan Amazon Resource Name pekerjaan ('JobArn'). ``` cancelJob = client.cancel_job(jobArn=job["jobArn"]) ``` Anda dapat menentukan pos pemeriksaan sebagai bagian dari `createJob` API penggunaan `checkpointConfig` parameter. ``` checkpointConfig = { "localPath" : "/opt/omega/checkpoints", "s3Uri": f"s3://{bucket}/{s3_prefix}/checkpoints" }, ``` **catatan** LocalPath `checkpointConfig` tidak dapat memulai dengan salah satu jalur cadangan berikut:`/opt/ml`,, `/opt/braket``/tmp`, atau. `/usr/local/nvidia` # Membuat dan men-debug pekerjaan hybrid dengan mode lokal Saat Anda membangun algoritma hybrid baru, mode lokal membantu Anda men-debug dan menguji skrip algoritme Anda. Mode lokal adalah fitur yang memungkinkan Anda menjalankan kode yang Anda rencanakan untuk digunakan di Amazon Braket Hybrid Jobs, tetapi tanpa perlu Braket untuk mengelola infrastruktur untuk menjalankan pekerjaan hybrid. Sebagai gantinya, jalankan pekerjaan hybrid secara lokal di instans Notebook Amazon Braket Anda atau pada klien pilihan, seperti laptop atau komputer desktop. Dalam mode lokal, Anda masih dapat mengirim tugas kuantum ke perangkat yang sebenarnya, tetapi Anda tidak mendapatkan manfaat kinerja saat menjalankan unit pemrosesan Quantum (QPU) yang sebenarnya saat dalam mode lokal. Untuk menggunakan mode lokal, ubah `AwsQuantumJob` ke `LocalQuantumJob` mana pun itu terjadi di dalam program Anda. Misalnya, untuk menjalankan contoh dari [Buat pekerjaan hybrid pertama Anda](braket-jobs-first.md), edit skrip pekerjaan hybrid dalam kode sebagai berikut. ``` 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", ) ``` **catatan** Docker, yang sudah diinstal sebelumnya di notebook Amazon Braket, perlu diinstal di lingkungan lokal Anda untuk menggunakan fitur ini. Petunjuk untuk menginstal Docker dapat ditemukan di halaman [Get Docker](https://docs.docker.com/get-started/get-docker/). Selain itu, tidak semua parameter didukung dalam mode lokal.