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 au sein d'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.

CUDA-Q dans 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 de lancement de Jupyter et en sélectionnant la vignette et CUDA-Q Braket. L'exemple de bloc-notes s'ouvre 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 CUDA-Q ou 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 sur 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 vous permet de ne payer 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 de votre entreprise. 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 sur Amazon Braket. Exemples Github pour utiliser un conteneur de tâches CUDA-Q hybride 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 de Bell sur un simulateur de processeur. Cet exemple s'exécute localement sur votre ordinateur portable ou 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 les tests terminés, vous pouvez supprimer l'local=Trueindicateur et exécuter votre tâche AWS. Pour en savoir plus, consultez la section Utilisation d'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 informatiques de processeur 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, voir 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 CUDA-Q GPU. Pour activer un simulateur GPU, utilisez le nom nvidia du backend. Le nvidia backend fonctionne comme un simulateur CUDA-Q GPU. Sélectionnez ensuite 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 au script de votre 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 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 le paramétrantexecution=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 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 figurant dans les exemples d'Amazon Braket sur Github 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 vous suffit de déplacer la cible vers un QPU Amazon Braket, tel que les appareils IQMIonQ, ou. Rigetti L'extrait de code suivant montre comment définir la cible pour le IQM Garnet périphérique. Pour obtenir la liste des QPU disponibles, 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 tâches hybrides, consultez la section Utilisation d'Amazon Braket Hybrid Jobs dans le guide du développeur. Pour en savoir plus sur CUDA-Q, consultez Documentation NVIDIA CUDA-Q.