Usando o CUDA-Q com o Amazon Braket - Amazon Braket
CUDA-Q em NBIsCUDA-Q no Hybrid Jobs

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 o 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 tempo de execução de programas quânticos com seus simuladores integrados de CPU e GPU. CUDA-Qestá disponível com instâncias nativas do notebook Braket (NBIs) e Amazon Braket 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_hello_cudaq_jobs.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 no Hybrid Jobs

Usar CUDA-Q no Amazon Braket Hybrid Jobs 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.

O Amazon Braket Hybrid Jobs GPUs oferece suporte essencial para CUDA-Q maximizar o potencial da Amazon Braket. GPUs aceleram significativamente as simulações de programas quânticos em comparação com simuladores baseados em CPU, especialmente ao trabalhar 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 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.

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. Para obter uma lista dos tipos de instância , consulte Tipos de instância do Amazon EC2.

@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 seguinte trecho de código mostra o decorador configurado em GPU hybrid_job configurado.

@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 suporte 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 eles 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 hybrid_job decorador, 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 no Amazon Braket Examples end-to-end Github fornece exemplos 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 no 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 dos disponíveis QPUs, consulte o console Amazon Braket.

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 no guia do desenvolvedor. Para saber mais sobre o CUDA-Q, consulte a documentação NVIDIA CUDA-Q.