Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
Jalankan beban kerja hybrid dengan simulator PennyLane tertanam
Mari kita lihat bagaimana Anda dapat menggunakan simulator tertanam dari PennyLane di Amazon Braket Hybrid Jobs untuk menjalankan beban kerja hybrid. Simulator tertanam GPU berbasis Pennylane,lightning.gpu, menggunakan cuQuantum perpustakaan Nvidialightning.gpu untuk mempercepat beban kerja hybrid Anda.
Menggunakan lightning.gpu untuk beban QAOA kerja
Pertimbangkan contoh Quantum Perkiraan Optimasi Algoritma (QAOA) dari buku catatandevice 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 keadaan tertanam lightning.qubit (yang CPU berbasis) dan lightning.gpu (yang GPU berbasis). Anda harus menyediakan simulator dengan beberapa dekomposisi gerbang khusus untuk menghitung berbagai gradien.
Sekarang Anda siap menyiapkan skrip peluncuran pekerjaan hibrida. Anda akan menjalankan QAOA algoritma menggunakan dua jenis instance: m5.2xlarge danp3.2xlarge. Jenis m5.2xlarge instans sebanding dengan laptop pengembang standar. p3.2xlargeIni adalah instance komputasi yang dipercepat yang memiliki NVIDIA Volta tunggal GPU 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 GPU berbasis, tetapi memilih device untuk menjadi simulator CPU berbasis tertanam (lightning.qubit), tidak GPU akan digunakan. Pastikan untuk menggunakan simulator GPU berbasis tertanam jika Anda ingin menargetkanGPU!
Pertama, Anda dapat membuat dua pekerjaan hibrida dan menyelesaikan Max-Cut dengan QAOA 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, GPU instance memberi kita percepatan 2x. Jika Anda melihat halaman hargam5.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 CPU instance atau $0,06375 menggunakan instance — keduanya cukup murah! GPU
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 CPU instance 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, GPU contohnya adalah urutan besarnya 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 CPU instance atau sekitar $0,775625 menggunakan instance. GPU CPUPenggunaannya tidak hanya lebih mahal, tetapi juga membutuhkan lebih banyak waktu untuk dijalankan. Mempercepat alur kerja ini dengan GPU instance yang tersedia di 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 quantum machine learning (QML) yang melatih pada kumpulan data, Anda dapat mempercepat beban kerja Anda lebih lanjut menggunakan paralelisme data. DalamQML, 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. DalamQML, kerugian biasanya dihitung secara serial sebelum dirata-ratakan ke total kerugian 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 QML beban kerja berikut untuk paralelisme data yang menggunakan dataset data Sonarlightning.gpu untuk meningkatkan kinerja dibandingkan simulator CPU berbasis 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 pekerjaan berat untuk mendistribusikan beban kerja Anda di beberapa dan beberapa GPUs instance. Paket ini sudah dikonfigurasi sebelumnya di Braket PyTorch dan TensorFlow kontainer. distModul ini memberi tahu skrip algoritme kami berapa jumlah total GPUs untuk pelatihan (world_size) serta inti rank dan local_rank GPU inti. rankadalah indeks absolut dari a GPU di semua instance, sedangkan local_rank indeks GPU dalam sebuah instance. Misalnya, jika ada empat contoh masing-masing dengan delapan GPUs 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 GPUs 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. DiQML, Anda sering ingin menyimpan hasil dan mencetak kemajuan pelatihan. Jika masing-masing 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 BraketSDK, ini menyediakan argumen kata kunci yang nyaman. distribution distribution="data_parallel"Dengan penciptaan lapangan kerja hybrid, Amazon Braket SDK secara otomatis menyisipkan dua hyperparameters untuk Anda. Jika Anda menggunakan Amazon BraketAPI, Anda harus menyertakan dua hyperparameters ini.
Dengan paralelisme instance dan data yang dikonfigurasi, Anda sekarang dapat mengirimkan pekerjaan hybrid Anda. Ada 8 GPUs dalam satu ml.p3.16xlarge contoh. Saat Anda mengaturinstanceCount=1, beban kerja didistribusikan di 8 GPUs dalam instance. Bila Anda menyetel instanceCount lebih dari satu, beban kerja didistribusikan ke seluruh GPUs tersedia di semua contoh. Saat menggunakan beberapa instance, setiap instans dikenakan biaya berdasarkan berapa lama Anda menggunakannya. 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 algoritma yang dimodifikasi dengan benar, pekerjaan hibrida dapat menimbulkan kesalahan, atau masing-masing 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!
