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.

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 status 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://my-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.