As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usando CUDA-Q com o Amazon Braket
NVIDIA's CUDA-Q é uma biblioteca de software projetada para programar algoritmos quânticos híbridos que combinam CPUs, GPUs e unidades de processamento quântico (QPUs). Ele fornece um modelo de programação unificado, permitindo que os desenvolvedores expressem instruções clássicas e quânticas em um único programa, simplificando os fluxos de trabalho. CUDA-Qacelera a simulação e o runtime de programas quânticos com seus simuladores integrados de CPU e GPU. CUDA-Q está disponível com instâncias nativas do caderno do Braket (NBIs) e Amazon Braket Hybrid Jobs.
**Topics**
+ [CUDA-Q em NBIs](#braket-cuda-q-nbis)
+ [CUDA-Q em empregos híbridos](#braket-cuda-q-hybrid-jobs)
## CUDA-Q em NBIs
CUDA-Q é instalado por padrão no ambiente Braket NBI. Você pode abrir um caderno de exemplo CUDA-Q acessando a página inicial do Jupyter e selecionando o bloco CUDA-Q e Braket. Isso abre o caderno `0_Getting_started_with_CUDA-Q.ipynb` de exemplo na janela principal. Para obter mais exemplos CUDA-Q, consulte o painel esquerdo no `nvidia_cuda_q/` diretório.
Você também pode verificar a versão CUDA-Q ou qualquer outro pacote de terceiros instalado em seu NBI. Por exemplo, você pode executar o comando a seguir em uma célula de código do notebook para verificar as versões dos CUDA-Q pacotes Qiskit e Braket que estão instalados no ambiente. PennyLane
```
%pip freeze | grep -i -e cudaq -e qiskit -e pennylane -e braket
```
## CUDA-Q em empregos híbridos
Usar CUDA-Q no [Amazon Braket Hybrid Jobs](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs.html) oferece um ambiente de computação flexível e sob demanda. As instâncias computacionais são executadas somente durante a duração da workload, garantindo que você pague somente pelo que usar. O Amazon Braket Hybrid Jobs também oferece uma experiência escalável. Os usuários podem começar com instâncias menores para prototipagem e teste e, em seguida, escalar para instâncias maiores, capazes de lidar com workloads maiores para experimentos completos.
Os trabalhos híbridos do Amazon Braket oferecem suporte a GPUs, que são essenciais para maximizar o potencial do CUDA-Q. As GPUs aceleram significativamente as simulações de programas quânticos em comparação aos CPU-based simuladores, especialmente quando se trabalha com circuitos de alta contagem de qubits. A paralelização se torna simples quando usada no Amazon Braket Hybrid Jobs CUDA-Q. O Hybrid Jobs simplifica a distribuição da amostragem do circuito e das avaliações observáveis em vários nós computacionais. Essa paralelização perfeita das workloads CUDA-Q permite que os usuários se concentrem mais no desenvolvimento de suas workloads em vez de configurar a infraestrutura para experimentos em grande escala.
Para começar, veja o [exemplo inicial CUDA-Q](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/0_Getting_started_with_CUDA-Q.ipynb) no Github de exemplos do Amazon Braket para CUDA-Q usar um contêiner de trabalhos híbrido fornecido pela Braket.
O trecho de código a seguir é um exemplo `hello-world` de execução de um programa CUDA-Q com o 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
```
O exemplo acima simula um circuito Bell em um simulador de CPU. Este exemplo é executado localmente em seu laptop ou notebook Braket Jupyter. Por causa da configuração `local=True` , ao executar esse script, um contêiner será iniciado em seu ambiente local para executar o programa CUDA-Q para teste e depuração. Depois de concluir o teste, você pode remover o sinalizador `local=True` e continuar executando seu trabalho AWS. Para saber mais, consulte [Trabalhando com o Amazon Braket Hybrid Jobs](braket-jobs.md).
Se suas workloads tiverem uma alta contagem de qubits, um grande número de circuitos ou um grande número de iterações, você poderá usar recursos de computação de CPU mais poderosos especificando a configuração `instance_config`. O trecho de código a seguir mostra como configurar a configuração `instance_config` no decorador `hybrid_job`. Para obter mais informações sobre os tipos de instância compatíveis, consulte [Configurar sua instância de trabalho híbrida](braket-jobs-configure-job-instance-for-script.md). Para obter uma lista dos tipos de instância , consulte [Tipos de instância do 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 workloads mais exigentes, você pode executar suas workloads em um simulador de GPU CUDA-Q. Para habilitar um simulador de GPU, use o nome do back-end `nvidia`. O back-end `nvidia` funciona como um simulador de GPU CUDA-Q. Em seguida, selecione um tipo de instância do Amazon EC2 que ofereça suporte a uma GPU NVIDIA. O trecho de código a seguir mostra o GPU-configured `hybrid_job` decorador.
```
@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 e NBIs oferecem suporte a simulações paralelas de GPU com CUDA-Q. Você pode paralelizar a avaliação de vários observáveis ou vários circuitos para aumentar o desempenho de sua workload. Para paralelizar vários observáveis, faça as seguintes alterações em seu script de algoritmo.
Defina a opção `mgpu` do back-end `nvidia`. Isso é necessário para paralelizar os observáveis. A paralelização usa MPI para comunicação entre GPUs, portanto, o MPI precisa ser inicializado antes da execução e finalizado depois dela.
Em seguida, especifique o modo de execução por meio da configuração `execution=cudaq.parallel.mpi`. O seguinte trecho de código mostra essas alterações.
```
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()
```
No decorador `hybrid_job`, especifique um tipo de instância que hospede várias GPUs, conforme mostrado no trecho de código a seguir.
```
@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):
...
```
O [caderno de simulações paralelas](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/nvidia_cuda_q/5_Multiple_GPU_simulations.ipynb) nos exemplos do Amazon Braket no Github fornece exemplos completos que demonstram como executar simulações de programas quânticos em back-ends de GPU e realizar simulações paralelas de observáveis e lotes de circuitos.
### Executando suas workloads em computadores quânticos
Depois de concluir o teste do simulador, você pode fazer a transição para a execução de experimentos em QPUs. Basta mudar o alvo para uma QPU Amazon Braket, como o IQM, os dispositivos IonQ, ou Rigetti. O trecho de código a seguir ilustra como definir o destino para o dispositivo IQM Garnet. Para obter uma lista das QPUs disponíveis, consulte o [console do 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 obter mais informações sobre trabalhos híbridos, consulte [Trabalhando com o Amazon Braket Hybrid Jobs](braket-jobs.md) no guia do desenvolvedor. Para saber mais sobre o CUDA-Q, consulte a [documentação NVIDIA CUDA-Q](https://nvidia.github.io/cuda-quantum/latest/index.html).