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 CUDA-Q avec Amazon Braket
NVIDIA's CUDA-Qest une bibliothèque logicielle conçue pour programmer des algorithmes quantiques hybrides combinant des processeurs, des GPU et des unités de traitement quantique (QPU). 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 (NBI) et Amazon Braket Hybrid Jobs.
**Topics**
+ [CUDA-Q en NBis](#braket-cuda-q-nbis)
+ [CUDA-Q dans Hybrid Jobs](#braket-cuda-q-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_Getting_started_with_CUDA-Q.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 Hybrid Jobs
L'utilisation CUDA-Q d'[Amazon Braket Hybrid Jobs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html) 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.
Amazon Braket Hybrid Jobs prend en charge les GPU essentiels pour optimiser CUDA-Q le potentiel. Les GPU accélèrent considérablement les simulations de programmes quantiques par rapport aux CPU-based simulateurs, en particulier lorsque vous travaillez avec des circuits à nombre de qubits élevé. La parallélisation devient simple lors de l'utilisation CUDA-Q sur Amazon Braket 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](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/0_Getting_started_with_CUDA-Q.ipynb) 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](braket-jobs.md).
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](braket-jobs-configure-job-instance-for-script.md). Pour obtenir la liste des types d'instances, consultez la section Types d'[instances Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
```
@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 GPU-configured `hybrid_job` décorateur.
```
@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 NBI prennent en charge les simulations GPU 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'`mgpu`option du `nvidia` backend. Cela est nécessaire pour paralléliser les observables. La parallélisation utilise le MPI pour la communication entre les GPU. 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églant`execution=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 hébergeant plusieurs GPU, 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](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/5_Multiple_GPU_simulations.ipynb) du Github consacré aux exemples d'Amazon Braket fournit des exemples de bout en bout qui montrent comment exécuter des simulations de programmes quantiques sur des serveurs 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 des QPU. 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 QPU disponibles, consultez la console [Amazon Braket](https://console.aws.amazon.com/braket/home).
```
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](braket-jobs.md) dans le guide du développeur. Pour en savoir plus sur CUDA-Q, consultez [Documentation NVIDIA CUDA-Q](https://nvidia.github.io/cuda-quantum/latest/index.html).