Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Jalankan beban kerja hibrida dengan simulator PennyLane tertanam

Mari kita lihat bagaimana Anda dapat menggunakan simulator tertanam dari PennyLane Amazon Braket Hybrid Jobs untuk menjalankan beban kerja hibrida. Simulator GPU-based tertanam 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 kepada Anda cara menggunakan lightning.gpu untuk mempercepat beban kerja hybrid Anda.

Menggunakan lightning.gpu untuk beban kerja QAOA

Pertimbangkan contoh Quantum Approximative Optimization Algorithm (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 Hybrid Job saat Anda meluncurkan diteruskan ke pekerjaan 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 keadaan tertanam lightning.qubit (yaitu CPU-based) dan lightning.gpu (yang merupakan GPU-based). Menyediakan 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 danml.g4dn.xlarge. Jenis ml.m5.2xlarge instance sebanding dengan laptop pengembang standar. Ini ml.g4dn.xlarge adalah contoh komputasi 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 ml.m5.2xlarge instance).

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 maupun 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 contoh adalah sekitar 73 detik, sedangkan untuk ml.g4dn.xlarge contoh 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 contoh adalah $0,00768, sedangkan untuk ml.g4dn.xlarge contoh adalah $0,01227. 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) yang melatih kumpulan data, Anda dapat mempercepat beban kerja menggunakan paralelisme data. Dalam QML, model berisi satu atau lebih sirkuit kuantum. Model mungkin atau mungkin tidak juga mengandung jaring saraf klasik. Saat melatih model dengan dataset, parameter dalam model diperbarui untuk meminimalkan fungsi kerugian. Fungsi kerugian biasanya didefinisikan untuk satu titik data, dan kerugian total untuk kerugian rata-rata atas seluruh dataset. 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 bergantung 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 set 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 bahan. Setiap titik data diberi label sebagai “M” untuk tambang atau “R” untuk batuan. Model QML kami terdiri dari lapisan input, sirkuit kuantum sebagai lapisan tersembunyi, dan lapisan keluaran. Lapisan input dan output adalah jaringan saraf klasik yang diimplementasikan di PyTorch. Sirkuit kuantum terintegrasi dengan jaringan PyTorch saraf menggunakan modul qml.q PennyLane nn. Lihat contoh buku catatan kami untuk detail lebih lanjut tentang beban kerja. Seperti contoh QAOA di atas, Anda dapat memanfaatkan kekuatan GPU dengan menggunakan GPU-based simulator tertanam seperti PennyLane lightning.gpu untuk meningkatkan kinerja dibandingkan simulator tertanam CPU-based.

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 algoritma untuk perpustakaan terdistribusi untuk mem SageMaker paralelkan pelatihan dengan benar. Pertama, Anda mengimpor smdistributed paket yang melakukan sebagian besar tugas berat untuk mendistribusikan beban kerja Anda di beberapa GPU dan beberapa instance. Paket ini sudah dikonfigurasi sebelumnya di Braket PyTorch dan TensorFlow wadah. distModul ini memberi tahu skrip algoritma kami berapa jumlah total GPU untuk pelatihan (world_size) serta inti GPU rank danlocal_rank. rankadalah indeks absolut GPU di semua instance, sementara local_rank itu adalah 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 a DistributedSampler sesuai dengan world_size rank dan kemudian meneruskannya ke pemuat data. Sampler ini menghindari GPU yang mengakses irisan 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 QML, 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 menggantikan. 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 instance untuk pustaka paralel data ter SageMaker distribusi. Anda mengonfigurasi jenis instance melalui InstanceConfig argumen di Hybrid Jobs. Agar pust SageMaker aka paralel data terdistribusi mengetahui bahwa paralelisme data diaktifkan, Anda perlu menambahkan dua hyperparameter tambahan, "sagemaker_distributed_dataparallel_enabled" pengaturan ke "true" dan "sagemaker_instance_type" pengaturan ke jenis instance yang Anda gunakan. Kedua hyperparameter ini digunakan oleh smdistributed paket. Skrip algoritma Anda tidak perlu menggunakannya secara eksplisit. Di Amazon Braket SDK, ini menyediakan argum distribution en kata kunci yang nyaman. distribution="data_parallel"Dengan pembuatan pekerjaan hibrida, Amazon Braket SDK secara otomatis menyisipkan dua hyperparameter untuk Anda. Jika Anda menggunakan Amazon Braket API, Anda harus menyertakan dua hyperparameter ini.

Dengan instance dan paralelisme data yang dikonfigurasi, Anda sekarang dapat mengirimkan pekerjaan hybrid Anda. Ada 4 GPU dalam satu ml.g4dn.12xlarge contoh. Saat Anda mengaturinstanceCount=1, beban kerja didistribusikan ke 8 GPU dalam instance. Bila Anda menetapkan instanceCount lebih dari satu, beban kerja didistribusikan di seluruh GPU yang tersedia di semua instance. Saat menggunakan beberapa instans, setiap instans dikenakan biaya berdasarkan berapa lama Anda menggunakannya. Misalnya, saat Anda menggunakan empat instans, waktu yang dapat ditagih adalah empat kali waktu berjalan per instans karena ada empat instans 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 contoh dapat menyebabkan pengurangan waktu dan biaya secara besar-besaran. Lihat contoh notebook untuk lebih jelasnya.