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 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 QAOA

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, bandingkan dua simulator vektor PennyLane status tertanam lightning.qubit (yang berbasis CPU) dan lightning.gpu (yang berbasis GPU). Sediakan simulator dengan dekomposisi gerbang khusus untuk menghitung berbagai gradien.

Sekarang Anda siap untuk menyiapkan skrip peluncuran pekerjaan hybrid. Jalankan algoritma QAOA menggunakan dua jenis instance: ml.m5.2xlarge dan. ml.g4dn.xlarge Jenis ml.m5.2xlarge instans sebanding dengan laptop pengembang standar. ml.g4dn.xlargeIni adalah instance komputasi yang dipercepat yang memiliki GPU NVIDIA T4 tunggal dengan memori 16GB.

Untuk menjalankan GPU, pertama-tama kita perlu menentukan gambar yang kompatibel dan instance yang benar (yang default ke instance). ml.m5.2xlarge

from braket.aws import AwsSession
from braket.jobs.image_uris import Framework, retrieve_image

image_uri = retrieve_image(Framework.PL_PYTORCH, AwsSession().region)
instance_config = InstanceConfig(instanceType="ml.g4dn.xlarge")

Kita kemudian perlu memasukkan ini ke dekorator pekerjaan hybrid, bersama dengan parameter perangkat yang diperbarui baik di sistem dan argumen pekerjaan hybrid.

@hybrid_job(
        device="local:pennylane/lightning.gpu",
        input_data=input_file_path,
        image_uri=image_uri,
        instance_config=instance_config)
def run_qaoa_hybrid_job_gpu(p=1, steps=10):
    params = np.random.rand(2, p)

    braket_task_tracker = Tracker()

    graph = nx.read_adjlist(input_file_path, nodetype=int)
    wires = list(graph.nodes)
    cost_h, _mixer_h = qaoa.maxcut(graph)

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

Waktu iterasi rata-rata untuk m5.2xlarge instance adalah sekitar 73 detik, sedangkan untuk ml.g4dn.xlarge instance sekitar 0,6 detik. Untuk alur kerja 21-qubit ini, instance GPU memberi kita percepatan 100x. 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 adalah $0,01227. ml.g4dn.xlarge Dalam hal ini lebih cepat dan lebih murah untuk dijalankan pada instance GPU.

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 menggunakan 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.g4dn.xlarge')

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 inti GPU. rankadalah indeks absolut 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. 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.g4dn.12xlarge 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 4 GPUs dalam satu ml.g4dn.12xlarge 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 instans, 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.g4dn.12xlarge',
                                 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",
    ...
)

Jika digunakan dengan benar, menggunakan beberapa instance dapat menyebabkan urutan pengurangan besaran baik dalam waktu maupun biaya. Lihat contoh buku catatan untuk lebih jelasnya.