Percepat beban kerja hybrid Anda dengan simulator tertanam dari PennyLane

Mari kita lihat bagaimana Anda dapat menggunakan simulator tertanam dari PennyLane di Amazon Braket Hybrid Jobs untuk menjalankan beban kerja hybrid. Simulator tertanam berbasis GPU Pennylane,lightning.gpu, menggunakan perpustakaan Nvidia CuQuantum untuk mempercepat simulasi sirkuit. Simulator GPU tertanam sudah dikonfigurasi sebelumnya di semua wadah pekerjaan Braket yang dapat digunakan pengguna di luar kotak. Di halaman ini, kami menunjukkan cara menggunakan lightning.gpu untuk mempercepat beban kerja hybrid Anda.

Menggunakan lightning.gpu untuk beban kerja Algoritma Pengoptimalan Perkiraan Kuantum

Pertimbangkan contoh Quantum Perkiraan Optimasi Algoritma (QAOA) dari buku catatan ini. Untuk memilih simulator tertanam, Anda menentukan device argumen untuk menjadi string dari formulir:"local:<provider>/<simulator_name>". Misalnya, Anda akan mengatur "local:pennylane/lightning.gpu" untuklightning.gpu. String perangkat yang Anda berikan ke Job Hybrid saat diluncurkan diteruskan ke job sebagai variabel lingkungan"AMZN_BRAKET_DEVICE_ARN".

device_string = os.environ["AMZN_BRAKET_DEVICE_ARN"]
prefix, device_name = device_string.split("/")
device = qml.device(simulator_name, wires=n_wires)

Di halaman ini, mari kita bandingkan dua simulator vektor PennyLane status tertanam lightning.qubit (yang berbasis CPU) dan lightning.gpu (yang berbasis GPU). Anda harus menyediakan simulator dengan beberapa dekomposisi gerbang khusus untuk menghitung berbagai gradien.

Sekarang Anda siap menyiapkan skrip peluncuran pekerjaan hibrida. Anda akan menjalankan algoritma QAOA menggunakan dua jenis instance: m5.2xlarge dan. p3.2xlarge Jenis m5.2xlarge instans sebanding dengan laptop pengembang standar. p3.2xlargeIni adalah instance komputasi yang dipercepat yang memiliki GPU NVIDIA Volta tunggal dengan memori 16GB.

hyperparametersUntuk semua pekerjaan hybrid Anda akan sama. Yang perlu Anda lakukan untuk mencoba berbagai contoh dan simulator adalah mengubah dua baris sebagai berikut.

# Specify device that the hybrid job will primarily be targeting
device = "local:pennylane/lightning.qubit"
# Run on a CPU based instance with about as much power as a laptop
instance_config = InstanceConfig(instanceType='ml.m5.2xlarge')

atau:

# Specify device that the hybrid job will primarily be targeting
device = "local:pennylane/lightning.gpu"
# Run on an inexpensive GPU based instance
instance_config = InstanceConfig(instanceType='ml.p3.2xlarge')

catatan

Jika Anda menentukan instance_config sebagai menggunakan instance berbasis GPU, tetapi memilih device untuk menjadi simulator berbasis CPU tertanam (lightning.qubit), GPU tidak akan digunakan. Pastikan untuk menggunakan simulator berbasis GPU tertanam jika Anda ingin menargetkan GPU!

Pertama, Anda dapat membuat dua pekerjaan hibrida dan menyelesaikan Max-Cut dengan QAOA pada grafik dengan 18 simpul. Ini berarti sirkuit 18-qubit — relatif kecil dan layak untuk dijalankan dengan cepat di laptop Anda atau instans. m5.2xlarge

num_nodes = 18
num_edges = 24
seed = 1967

graph = nx.gnm_random_graph(num_nodes, num_edges, seed=seed)

# And similarly for the p3 job
m5_job = AwsQuantumJob.create(
    device=device,
    source_module="qaoa_source",
    job_name="qaoa-m5-" + str(int(time.time())),
    image_uri=image_uri,
    # Relative to the source_module
    entry_point="qaoa_source.qaoa_algorithm_script",
    copy_checkpoints_from_job=None,
    instance_config=instance_config,
    # general parameters
    hyperparameters=hyperparameters,
    input_data={"input-graph": input_file_path},
    wait_until_complete=True,
)

Waktu iterasi rata-rata untuk m5.2xlarge instance adalah sekitar 25 detik, sedangkan untuk p3.2xlarge contoh itu sekitar 12 detik. Untuk alur kerja 18-qubit ini, instance GPU memberi kita percepatan 2x. Jika Anda melihat halaman harga Amazon Braket Hybrid Jobs, Anda dapat melihat bahwa biaya per menit untuk sebuah m5.2xlarge instans adalah $0,00768, sedangkan untuk contoh itu $0,06375p3.2xlarge. Untuk menjalankan 5 iterasi total, seperti yang Anda lakukan di sini, akan dikenakan biaya $0,016 menggunakan instance CPU atau $0,06375 menggunakan instance GPU — keduanya cukup murah!

Sekarang mari kita membuat masalah lebih sulit, dan mencoba memecahkan masalah Max-Cut pada grafik 24-vertex, yang akan diterjemahkan menjadi 24 qubit. Jalankan pekerjaan hybrid lagi pada dua contoh yang sama dan bandingkan biayanya.

catatan

Anda akan melihat bahwa waktu untuk menjalankan pekerjaan hybrid ini pada instance CPU mungkin sekitar lima jam!

num_nodes = 24
num_edges = 36
seed = 1967

graph = nx.gnm_random_graph(num_nodes, num_edges, seed=seed)

# And similarly for the p3 job
m5_big_job = AwsQuantumJob.create(
    device=device,
    source_module="qaoa_source",
    job_name="qaoa-m5-big-" + str(int(time.time())),
    image_uri=image_uri,
    # Relative to the source_module
    entry_point="qaoa_source.qaoa_algorithm_script",
    copy_checkpoints_from_job=None,
    instance_config=instance_config,
    # general parameters
    hyperparameters=hyperparameters,
    input_data={"input-graph": input_file_path},
    wait_until_complete=True,
)

Waktu iterasi rata-rata untuk m5.2xlarge instance kira-kira satu jam, sedangkan untuk p3.2xlarge instance kira-kira dua menit. Untuk masalah yang lebih besar ini, instance GPU lebih cepat! Yang harus Anda lakukan untuk mendapatkan keuntungan dari percepatan ini adalah mengubah dua baris kode, menukar jenis instance dan simulator lokal yang digunakan. Untuk menjalankan 5 iterasi total, seperti yang dilakukan di sini, akan menelan biaya sekitar $2.27072 menggunakan instance CPU atau sekitar $0,775625 menggunakan instance GPU. Penggunaan CPU tidak hanya lebih mahal, tetapi juga membutuhkan lebih banyak waktu untuk dijalankan. Mempercepat alur kerja ini dengan instance GPU yang tersedia AWS, menggunakan PennyLane simulator tertanam yang didukung oleh NVIDIA CuQuantum, memungkinkan Anda menjalankan alur kerja dengan jumlah qubit menengah (antara 20 dan 30) dengan biaya total yang lebih sedikit dan dalam waktu yang lebih singkat. Ini berarti Anda dapat bereksperimen dengan komputasi kuantum bahkan untuk masalah yang terlalu besar untuk berjalan cepat di laptop Anda atau instance berukuran serupa.

Pembelajaran mesin kuantum dan paralelisme data

Jika jenis beban kerja Anda adalah pembelajaran mesin kuantum (QML/Quantum Machine Learning) yang melatih pada kumpulan data, Anda dapat lebih mempercepat beban kerja Anda menggunakan paralelisme data. Dalam QML, model berisi satu atau lebih sirkuit kuantum. Model mungkin atau mungkin juga tidak mengandung jaring saraf klasik. Saat melatih model dengan kumpulan data, parameter dalam model diperbarui untuk meminimalkan fungsi kerugian. Fungsi kerugian biasanya didefinisikan untuk satu titik data, dan total kerugian untuk kerugian rata-rata atas seluruh kumpulan data. Dalam QML, kerugian biasanya dihitung secara serial sebelum rata-rata kerugian total untuk perhitungan gradien. Prosedur ini memakan waktu, terutama ketika ada ratusan titik data.

Karena kerugian dari satu titik data tidak tergantung pada titik data lain, kerugian dapat dievaluasi secara paralel! Kerugian dan gradien yang terkait dengan titik data yang berbeda dapat dievaluasi secara bersamaan. Ini dikenal sebagai paralelisme data. Dengan SageMaker perpustakaan paralel data terdistribusi, Amazon Braket Hybrid Jobs memudahkan Anda memanfaatkan paralelisme data untuk mempercepat pelatihan Anda.

Pertimbangkan beban kerja QML berikut untuk paralelisme data yang menggunakan dataset data Sonar dari repositori UCI yang terkenal sebagai contoh untuk klasifikasi biner. Dataset Sonar memiliki 208 titik data masing-masing dengan 60 fitur yang dikumpulkan dari sinyal sonar yang memantul dari material. Setiap titik data diberi label sebagai “M” untuk tambang atau “R” untuk batu. Model QML kami terdiri dari lapisan input, sirkuit kuantum sebagai lapisan tersembunyi, dan lapisan keluaran. Lapisan input dan output adalah jaring saraf klasik yang diimplementasikan di PyTorch. Sirkuit kuantum terintegrasi dengan jaring PyTorch saraf menggunakan modul PennyLane qml.qnn. Lihat contoh notebook kami untuk detail lebih lanjut tentang beban kerja. Seperti contoh QAOA di atas, Anda dapat memanfaatkan kekuatan GPU dengan menggunakan simulator berbasis GPU tertanam seperti ini lightning.gpu untuk meningkatkan kinerja dibandingkan simulator berbasis PennyLane CPU tertanam.

Untuk membuat pekerjaan hybrid, Anda dapat memanggil AwsQuantumJob.create dan menentukan skrip algoritma, perangkat, dan konfigurasi lainnya melalui argumen kata kuncinya.

instance_config = InstanceConfig(instanceType='ml.p3.2xlarge')

hyperparameters={"nwires": "10",
                 "ndata": "32",
                 ...
}

job = AwsQuantumJob.create(
    device="local:pennylane/lightning.gpu",
    source_module="qml_source",
    entry_point="qml_source.train_single",
    hyperparameters=hyperparameters,
    instance_config=instance_config,
    ...
)

Untuk menggunakan paralelisme data, Anda perlu memodifikasi beberapa baris kode dalam skrip algoritme agar pustaka SageMaker terdistribusi dapat memparalelkan pelatihan dengan benar. Pertama, Anda mengimpor smdistributed paket yang melakukan sebagian besar peningkatan berat untuk mendistribusikan beban kerja Anda di beberapa GPU dan beberapa instance. Paket ini sudah dikonfigurasi sebelumnya di Braket PyTorch dan TensorFlow kontainer. distModul ini memberi tahu skrip algoritme kami berapa jumlah total GPU untuk pelatihan (world_size) serta inti rank dan local_rank inti GPU. rankadalah indeks absolut GPU di semua instance, sedangkan local_rank indeks GPU dalam sebuah instance. Misalnya, jika ada empat instance masing-masing dengan delapan GPU yang dialokasikan untuk pelatihan, rank rentang dari 0 hingga 31 dan local_rank rentang dari 0 hingga 7.

import smdistributed.dataparallel.torch.distributed as dist

dp_info = {
    "world_size": dist.get_world_size(),
    "rank": dist.get_rank(),
    "local_rank": dist.get_local_rank(),
}
batch_size //= dp_info["world_size"] // 8
batch_size = max(batch_size, 1)

Selanjutnya, Anda mendefinisikan DistributedSampler sesuai dengan world_size rank dan kemudian meneruskannya ke pemuat data. Sampler ini menghindari GPU mengakses potongan dataset yang sama.

train_sampler = torch.utils.data.distributed.DistributedSampler(
    train_dataset,
    num_replicas=dp_info["world_size"],
    rank=dp_info["rank"]
)
train_loader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=batch_size,
    shuffle=False,
    num_workers=0,
    pin_memory=True,
    sampler=train_sampler,
)

Selanjutnya, Anda menggunakan DistributedDataParallel kelas untuk mengaktifkan paralelisme data.

from smdistributed.dataparallel.torch.parallel.distributed import DistributedDataParallel as DDP

model = DressedQNN(qc_dev).to(device)
model = DDP(model)
torch.cuda.set_device(dp_info["local_rank"])
model.cuda(dp_info["local_rank"])

Di atas adalah perubahan yang Anda butuhkan untuk menggunakan paralelisme data. Di QHTML, Anda sering ingin menyimpan hasil dan mencetak kemajuan pelatihan. Jika setiap GPU menjalankan perintah penyimpanan dan pencetakan, log akan dibanjiri dengan informasi berulang dan hasilnya akan saling menimpa. Untuk menghindari hal ini, Anda hanya dapat menyimpan dan mencetak dari GPU yang memiliki rank 0.

if dp_info["rank"]==0:
    print('elapsed time: ', elapsed)
    torch.save(model.state_dict(), f"{output_dir}/test_local.pt")
    save_job_result({"last loss": loss_before})

Amazon Braket Hybrid Jobs mendukung jenis ml.p3.16xlarge instans untuk library paralel SageMaker data terdistribusi. Anda mengonfigurasi tipe instance melalui InstanceConfig argumen di Hybrid Jobs. Agar pustaka paralel data SageMaker terdistribusi mengetahui bahwa paralelisme data diaktifkan, Anda perlu menambahkan dua hiperparameter tambahan, "sagemaker_distributed_dataparallel_enabled" pengaturan ke "true" dan "sagemaker_instance_type" pengaturan ke jenis instance yang Anda gunakan. Kedua hyperparameters ini digunakan oleh smdistributed paket. Skrip algoritme Anda tidak perlu menggunakannya secara eksplisit. Di Amazon Braket SDK, ini menyediakan argumen kata kunci yang nyaman. distribution distribution="data_parallel"Dengan penciptaan lapangan kerja hybrid, Amazon Braket SDK secara otomatis menyisipkan dua hyperparameter untuk Anda. Jika Anda menggunakan Amazon Braket API, Anda harus menyertakan dua hyperparameters ini.

Dengan paralelisme instance dan data yang dikonfigurasi, Anda sekarang dapat mengirimkan pekerjaan hybrid Anda. Ada 8 GPU dalam satu ml.p3.16xlarge contoh. Saat Anda mengaturinstanceCount=1, beban kerja didistribusikan di 8 GPU dalam instance. Bila Anda menyetel instanceCount lebih dari satu, beban kerja didistribusikan ke seluruh GPU yang tersedia di semua instance. Saat menggunakan beberapa instans, setiap instans dikenakan biaya berdasarkan berapa banyak waktu yang Anda gunakan. Misalnya, saat Anda menggunakan empat instance, waktu yang dapat ditagih adalah empat kali waktu proses per instance karena ada empat instance yang menjalankan beban kerja Anda secara bersamaan.

instance_config = InstanceConfig(instanceType='ml.p3.16xlarge',
                                 instanceCount=1,
)

hyperparameters={"nwires": "10",
                 "ndata": "32",
                 ...,
}

job = AwsQuantumJob.create(
    device="local:pennylane/lightning.gpu",
    source_module="qml_source",
    entry_point="qml_source.train_dp",
    hyperparameters=hyperparameters,
    instance_config=instance_config,
    distribution="data_parallel",
    ...
)

catatan

Dalam penciptaan pekerjaan hibrida di atas, train_dp.py adalah skrip algoritma yang dimodifikasi untuk menggunakan paralelisme data. Perlu diingat bahwa paralelisme data hanya berfungsi dengan benar ketika Anda memodifikasi skrip algoritme Anda sesuai dengan bagian di atas. Jika opsi paralelisme data diaktifkan tanpa skrip algoritme yang dimodifikasi dengan benar, pekerjaan hibrida dapat menimbulkan kesalahan, atau setiap GPU dapat berulang kali memproses irisan data yang sama, yang tidak efisien.

Mari kita bandingkan waktu berjalan dan biaya dalam contoh di mana ketika melatih model dengan sirkuit kuantum 26-qubit untuk masalah klasifikasi biner yang disebutkan di atas. ml.p3.16xlargeContoh yang digunakan dalam contoh ini berharga $0,4692 per menit. Tanpa paralelisme data, simulator membutuhkan waktu sekitar 45 menit untuk melatih model selama 1 zaman (yaitu, lebih dari 208 titik data) dan harganya sekitar $20. Dengan paralelisme data di 1 instance dan 4 instance, masing-masing hanya membutuhkan waktu 6 menit dan 1,5 menit, yang berarti sekitar $2,8 untuk keduanya. Dengan menggunakan paralelisme data di 4 instance, Anda tidak hanya meningkatkan waktu berjalan sebesar 30x, tetapi juga mengurangi biaya dengan urutan besarnya!