Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
Menjalankan kode lokal Anda sebagai pekerjaan hibrida
Amazon Braket Hybrid Jobs menyediakan orkestrasi algoritma klasik kuantum hibrida yang dikelola sepenuhnya, menggabungkan EC2 sumber daya komputasi Amazon 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. Masing-masing QPU mempertahankan antrian pekerjaan hibrida yang terpisah, memastikan bahwa hanya satu pekerjaan hibrida yang dapat berjalan pada waktu tertentu.
Di bagian ini:
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 dari Amazon Elastic Container Registry (ECR).
catatan
Hanya Python 3.10 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. Pekerjaan hybrid kemudian memanggil fungsi di dalam dekorator pada instance AmazonEC2. Anda dapat memantau kemajuan pekerjaan dengan job.state()
atau dengan konsol Braket. Contoh kode berikut menunjukkan bagaimana menjalankan urutan lima negara pada State 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, gunakanjob.result()
.
job = run_hybrid_job(num_tasks=1) result = job.result()
Argumen perangkat di @hybrid_job
dekorator menentukan perangkat yang memiliki akses prioritas pekerjaan hibrida - dalam hal ini, SV1 simulator. Untuk mendapatkan QPU prioritas, Anda harus memastikan bahwa perangkat yang ARN digunakan dalam fungsi cocok dengan yang ditentukan dalam dekorator. Untuk kenyamanan, Anda dapat menggunakan fungsi pembantu get_job_device_arn()
untuk menangkap perangkat yang ARN dideklarasikan@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.
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. Contoh di atas menggunakan nama metrik “probabilitas” yang mencatat probabilitas pertama dari jenis hasil.
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.
@hybrid_job(device=Devices.Amazon.SV1) def passing(): np_array = np.random.rand(5) return np_array # serializable @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 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 atauMPI, 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_job_creation
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 container Anda sendiri (BYOC). 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 ...
Misalnya, requirements.txt
file tersebut mungkin menyertakan paket lain untuk diinstal.
qiskit pennylane >= 0.31 mitiq == 0.29
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://<default_bucket_name>/jobs/<job_name>/<timestamp>/data/<channel_name>
Jika Anda menentukan jalur lokal, nama saluran default ke “input”. Kode berikut menunjukkan file numpy dari jalur data/file.npy
lokal.
@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.
s3_path = "s3://amazon-braket-us-west-1-961591465522/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.
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.
@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 bernamamodel.tar.gz
. Anda dapat mengunduh hasilnya dengan fungsi Pythonjob.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 <jobname>.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 pekerjaan hibrida ARN 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 algoritme 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 algoritme variasional berulang
Pekerjaan hybrid memberi Anda alat untuk menjalankan algoritme klasik kuantum berulang. Untuk masalah kuantum murni, gunakan tugas kuantum atau sekumpulan tugas kuantum. 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 aQPU, 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 Bawa wadah Anda sendiri () 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 MPI dukungan bawaan untuk menjalankan simulator lokal pada beberapa instance dalam satu pekerjaan hybrid. Untuk informasi selengkapnya, lihat simulator tertanam.
Gunakan sirkuit parametrik
Sirkuit parametrik yang Anda kirimkan dari pekerjaan hybrid secara otomatis dikompilasi secara tertentu QPUs menggunakan kompilasi parametrik 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