Utilisation de CUDA-Q avec Amazon Braket - Amazon Braket
CUDA-Q en NBIsCUDA-Q dans les emplois hybrides

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation de CUDA-Q avec Amazon Braket

NVIDIA's CUDA-Qest une bibliothèque logicielle conçue pour programmer des algorithmes quantiques hybrides combinant CPUs, GPUs, et des unités de traitement quantiques (QPUs). Il fournit un modèle de programmation unifié, permettant aux développeurs d'exprimer des instructions classiques et quantiques dans un seul programme, rationalisant ainsi les flux de travail. CUDA-Qaccélère la simulation et l'exécution de programmes quantiques grâce à ses simulateurs CPU et GPU intégrés. CUDA-Qest disponible avec les instances natives de bloc-notes Braket (NBIs) et Amazon Braket Hybrid Jobs.

CUDA-Q en NBIs

CUDA-Qest installé par défaut dans l'environnement Braket NBI. Vous pouvez ouvrir un CUDA-Q exemple de bloc-notes en accédant à la page du lanceur Jupyter et en sélectionnant la CUDA-Q vignette et Braket. Cela ouvre le bloc-notes d'exemple 0_hello_cudaq_jobs.ipynb dans la fenêtre principale. Pour plus d'CUDA-Qexemples, consultez le panneau de gauche du nvidia_cuda_q/ répertoire.

Vous pouvez également vérifier la version de CUDA-Q ou de tout autre package tiers installé dans votre NBI. Par exemple, vous pouvez exécuter la commande suivante dans une cellule de code de bloc-notes pour vérifier les versions des CUDA-Q packages Qiskit et Braket installées dans l'environnement. PennyLane

%pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket

CUDA-Q dans les emplois hybrides

L'utilisation CUDA-Q d'Amazon Braket Hybrid Jobs offre un environnement informatique flexible et à la demande. Les instances de calcul ne s'exécutent que pendant la durée de votre charge de travail, ce qui garantit que vous ne payez que pour ce que vous utilisez. Amazon Braket Hybrid Jobs propose également une expérience évolutive. Les utilisateurs peuvent commencer par des instances plus petites pour le prototypage et les tests, puis passer à des instances plus grandes capables de gérer des charges de travail plus importantes pour des expériences complètes.

Le support Amazon Braket Hybrid Jobs GPUs est essentiel pour optimiser le potentielCUDA-Q. GPUs accélère considérablement les simulations de programmes quantiques par rapport aux simulateurs basés sur un processeur, en particulier lorsque vous travaillez avec des circuits à nombre de bits quantiques élevé. La parallélisation devient simple lorsque vous utilisez Amazon Braket CUDA-Q Hybrid Jobs. Hybrid Jobs simplifie la distribution de l'échantillonnage des circuits et des évaluations observables sur plusieurs nœuds de calcul. Cette parallélisation fluide des CUDA-Q charges de travail permet aux utilisateurs de se concentrer davantage sur le développement de leurs charges de travail plutôt que sur la mise en place d'une infrastructure pour des expériences à grande échelle.

Pour commencer, consultez l'exemple de CUDA-Q démarrage sur le Github d'Amazon Braket pour utiliser un conteneur de tâches CUDA-Q hybrides fourni par Braket.

L'extrait de code suivant est un hello-world exemple d'exécution d'un CUDA-Q programme avec Amazon Braket Hybrid Jobs.

image_uri = retrieve_image(Framework.CUDAQ, AwsSession().region)

@hybrid_job(device='local:nvidia/qpp-cpu', image_uri=image_uri)
def hello_quantum():
    import cudaq

    # define the backend
    device=get_job_device_arn()
    cudaq.set_target(device.split('/')[-1])

    # define the Bell circuit
    kernel = cudaq.make_kernel()
    qubits = kernel.qalloc(2)
    kernel.h(qubits[0])
    kernel.cx(qubits[0], qubits[1])

    # sample the Bell circuit
    result = cudaq.sample(kernel, shots_count=1000)
    measurement_probabilities = dict(result.items())
    
    return measurement_probabilities

L'exemple ci-dessus simule un circuit Bell sur un simulateur de processeur. Cet exemple s'exécute localement sur votre ordinateur portable ou sur votre bloc-notes Braket Jupyter. En raison de ce local=True paramètre, lorsque vous exécutez ce script, un conteneur démarre dans votre environnement local pour exécuter le CUDA-Q programme à des fins de test et de débogage. Une fois le test terminé, vous pouvez supprimer le local=True drapeau et exécuter votre tâche AWS. Pour en savoir plus, consultez l'article Travailler avec Amazon Braket Hybrid Jobs.

Si vos charges de travail comportent un nombre de qubits élevé, un grand nombre de circuits ou un grand nombre d'itérations, vous pouvez utiliser des ressources de calcul CPU plus puissantes en spécifiant le paramètre. instance_config L'extrait de code suivant montre comment configurer le instance_config paramètre dans le hybrid_job décorateur. Pour plus d'informations sur les types d'instances pris en charge, consultez Configurer votre instance de tâche hybride. Pour obtenir la liste des types d'instances, consultez la section Types d'instances Amazon EC2.

@hybrid_job(
    device="local:nvidia/qpp-cpu",
    image_uri=image_uri,
    instance_config=InstanceConfig(instanceType="ml.c5.2xlarge"),
)
def my_job_script():
    ...

Pour les charges de travail plus exigeantes, vous pouvez exécuter vos charges de travail sur un simulateur de CUDA-Q GPU. Pour activer un simulateur de GPU, utilisez le nom nvidia du backend. Le nvidia backend fonctionne comme un simulateur de CUDA-Q GPU. Ensuite, sélectionnez un type d'instance Amazon EC2 qui prend en charge un NVIDIA GPU. L'extrait de code suivant montre le décorateur configuré par GPUhybrid_job.

@hybrid_job(
    device="local:nvidia/nvidia",
    image_uri=image_uri,
    instance_config=InstanceConfig(instanceType="ml.g4dn.xlarge"),
)
def my_job_script():
    ...

Amazon Braket Hybrid Jobs et prend en charge les simulations de GPU NBIs parallèles avec. CUDA-Q Vous pouvez paralléliser l'évaluation de plusieurs observables ou de plusieurs circuits pour améliorer les performances de votre charge de travail. Pour paralléliser plusieurs observables, apportez les modifications suivantes à votre script d'algorithme.

Définissez l'mgpuoption du nvidia backend. Cela est nécessaire pour paralléliser les observables. La parallélisation utilise le MPI pour la communication entre les deux GPUs. Le MPI doit donc être initialisé avant l'exécution et finalisé après celle-ci.

Ensuite, spécifiez le mode d'exécution en réglantexecution=cudaq.parallel.mpi. L'extrait de code suivant montre ces modifications.

cudaq.set_target("nvidia", option="mqpu")
cudaq.mpi.initialize()
result = cudaq.observe(
    kernel, hamiltonian, shots_count=n_shots, execution=cudaq.parallel.mpi
)
cudaq.mpi.finalize()

Dans le hybrid_job décorateur, spécifiez un type d'instance qui héberge plusieurs instances GPUs , comme indiqué dans l'extrait de code suivant.

@hybrid_job(
    device="local:nvidia/nvidia-mqpu",
    instance_config=InstanceConfig(instanceType="ml.g4dn.12xlarge", instanceCount=1),
    image_uri=image_uri,
)
def parallel_observables_gpu_job(sagemaker_mpi_enabled=True):
    ...

Le carnet de simulations parallèles du Github consacré aux exemples d'Amazon Braket fournit des end-to-end exemples qui montrent comment exécuter des simulations de programmes quantiques sur des backends GPU et effectuer des simulations parallèles d'observables et de lots de circuits.

Exécution de vos charges de travail sur des ordinateurs quantiques

Après avoir terminé les tests du simulateur, vous pouvez passer à l'exécution d'expériences sur QPUs. Il suffit de passer de la cible à un QPU Amazon Braket, tel que les appareils IQMIonQ, ou. Rigetti L'extrait de code suivant montre comment définir la cible sur le périphérique. IQM Garnet Pour obtenir la liste des produits disponibles QPUs, consultez la console Amazon Braket.

device_arn = "arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet"
cudaq.set_target("braket", machine=device_arn)

Pour plus d'informations sur les jobs hybrides, consultez la section Working with Amazon Braket Hybrid Jobs dans le guide du développeur. Pour en savoir plus sur CUDA-Q, consultez Documentation NVIDIA CUDA-Q.