Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Uso de CUDA-Q con Amazon Braket (Avanzado) CUDA-Q con Amazon Braket NVIDIA's CUDA-Qes una biblioteca de software diseñada para programar algoritmos cuánticos híbridos que combinan CPUs GPUs, y unidades de procesamiento cuántico (QPUs). Proporciona un modelo de programación unificado que permite a los desarrolladores expresar instrucciones clásicas y cuánticas en un solo programa, lo que agiliza los flujos de trabajo. CUDA-Qacelera la simulación cuántica y el tiempo de ejecución de los programas con sus simuladores de CPU y GPU integrados. CUDA-Qestá disponible con instancias de notebook Braket nativas (NBIs) y Amazon Braket Hybrid Jobs. **Topics** + [ ## CUDA-Q en NBIs ](#braket-cuda-q-nbis) + [ ## CUDA-Q en trabajos híbridos ](#braket-cuda-q-hybrid-jobs) ## CUDA-Q en NBIs CUDA-Q está instalado de forma predeterminada en el entorno de NBI de Braket. Para abrir un cuaderno de CUDA-Q ejemplo, vaya a la página del lanzador de Jupyter y seleccione el mosaico de CUDA-Q y Braket. Esto abre el cuaderno de ejemplo `0_Getting_started_with_CUDA-Q.ipynb` en la ventana principal. Para ver más ejemplos de CUDA-Q, consulte el panel izquierdo en el directorio de `nvidia_cuda_q/`. También puede comprobar la versión de CUDA-Q o cualquier otro paquete de terceros instalado en su NBI. Por ejemplo, puede ejecutar el siguiente comando en una celda de código de un bloc de notas para comprobar las versiones de CUDA-Q los paquetes Qiskit y Braket que están instaladas en el entorno. PennyLane ``` %pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket ``` ## CUDA-Q en trabajos híbridos El uso de CUDA-Q en [trabajos híbridos de Amazon Braket](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html) ofrece un entorno de computación flexible y bajo demanda. Las instancias computacionales solo se ejecutan durante el tiempo que dura su carga de trabajo, lo que garantiza que solo pague por lo que utiliza. Los trabajos híbridos de Amazon Braket también proporcionan una experiencia escalable. Los usuarios pueden comenzar con instancias más pequeñas para crear prototipos y realizar pruebas, y luego escalar verticalmente a instancias más grandes capaces de manejar mayores cargas de trabajo para realizar experimentos completos. Amazon Braket Hybrid Jobs apoya, GPUs que es esencial para maximizar su potencial. CUDA-Q GPUs acelera considerablemente las simulaciones de programas cuánticos en comparación con los simuladores basados en CPU, especialmente cuando se trabaja con circuitos con un alto número de cúbits. La paralelización se simplifica cuando se utiliza CUDA-Q en los trabajos híbridos de Amazon Braket. Los trabajos híbridos simplifican la distribución del muestreo de circuitos y las evaluaciones observables entre varios nodos computacionales. Esta paralelización fluida de las cargas de trabajo de CUDA-Q permite a los usuarios centrarse más en desarrollar sus cargas de trabajo en lugar de configurar la infraestructura para experimentos a gran escala. Para empezar, consulte el [ejemplo para empezar con CUDA-Q](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/0_Getting_started_with_CUDA-Q.ipynb) en el GitHub de ejemplos de Amazon Braket para utilizar un contenedor de trabajos híbridos de CUDA-Q proporcionado por Braket. El siguiente fragmento de código es un ejemplo de `hello-world` para ejecutar un programa de CUDA-Q con los trabajos híbridos de Amazon Braket. ``` 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 ``` El ejemplo anterior simula un circuito Bell en un simulador de CPU. Este ejemplo se ejecuta localmente en su portátil o en el cuaderno de Jupyter de Braket. Debido a esta configuración de `local=True`, cuando ejecute este script, se iniciará un contenedor en su entorno local para ejecutar el programa CUDA-Q con fines de prueba y depuración. Cuando termine de realizar las pruebas, puede quitar el indicador `local=True` y continuar con su trabajo en AWS. Para obtener más información, consulte [Trabajar con trabajos híbridos de Amazon Braket](braket-jobs.md). Si sus cargas de trabajo tienen un recuento elevado de qubits, un gran número de circuitos o un gran número de iteraciones, puede utilizar recursos de computación de CPU más potentes especificando la configuración `instance_config`. El siguiente fragmento de código muestra cómo configurar el ajuste `instance_config` en el decorador de `hybrid_job`. Para obtener más información sobre los tipos de instancias compatibles, consulte [Configuración de su instancia de trabajo híbrido](braket-jobs-configure-job-instance-for-script.md). Para obtener la lista de los tipos de instancia, consulte [Tipos de instancias de 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(): ... ``` Para cargas de trabajo más exigentes, puede ejecutar sus cargas de trabajo en un simulador de GPU de CUDA-Q. Para habilitar un simulador de GPU, use el nombre de backend `nvidia`. El backend `nvidia` funciona como un simulador GPU de CUDA-Q. A continuación, seleccione un tipo de instancia de Amazon EC2 que sea compatible con una GPU de NVIDIA. El siguiente fragmento de código muestra el decorador de `hybrid_job` configurado para la GPU. ``` @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 y admite simulaciones de GPU NBIs paralelas con. CUDA-Q Puede paralelizar la evaluación de varias observables o varios circuitos para mejorar el rendimiento de su carga de trabajo. Para paralelizar varios observables, realice los siguientes cambios en el script de algoritmo. Configura la opción `mgpu` del backend `nvidia`. Esto es necesario para paralelizar los observables. La paralelización utiliza el MPI para la comunicación entre ellas GPUs, por lo que el MPI debe inicializarse antes de la ejecución y finalizarse después de la ejecución. A continuación, especifique el modo de ejecución mediante la configuración de `execution=cudaq.parallel.mpi`. El siguiente fragmento de código muestra estos cambios. ``` 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() ``` En el `hybrid_job` decorador, especifique un tipo de instancia que aloje múltiples GPUs , como se muestra en el siguiente fragmento de código. ``` @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): ... ``` El [cuaderno de simulaciones paralelas](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/5_Multiple_GPU_simulations.ipynb) de Amazon Braket, Github, proporciona end-to-end ejemplos que demuestran cómo ejecutar simulaciones de programas cuánticos en backends de GPU y realizar simulaciones paralelas de observables y lotes de circuitos. ### Ejecución de sus cargas de trabajo en computadoras cuánticas Tras completar las pruebas con el simulador, puede pasar a la ejecución de experimentos en él QPUs. Simplemente cambie el destino a una QPU de Amazon Braket, como los dispositivos IQM, IonQ o Rigetti. El siguiente fragmento de código ilustra cómo establecer el objetivo en el dispositivo IQM Garnet. Para ver una lista de las disponibles QPUs, consulta la [consola 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) ``` Para obtener más información sobre trabajos híbridos, consulte [Trabajar con trabajos híbridos de Amazon Braket](braket-jobs.md) en la guía para desarrolladores. Para obtener más información sobre CUDA-Q, consulte la [documentación de NVIDIA CUDA-Q](https://nvidia.github.io/cuda-quantum/latest/index.html).