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.

O uso 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 sua carga de trabalho, garantindo que você pague somente pelo que usa. 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 cargas de trabalho 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 CUDA-Q Braket Hybrid Jobs. 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 cargas de CUDA-Q trabalho permite que os usuários se concentrem mais no desenvolvimento de suas cargas de trabalho em vez de configurar a infraestrutura para experimentos em grande escala.

Para começar, veja o exemplo CUDA-Q inicial no Github de exemplos do Amazon Braket para criar um contêiner de trabalho CUDA-Q que ofereça suporte por meio de traga seu próprio contêiner (BYOC). Certifique-se de ter as permissões apropriadas do IAM para criar e publicar seu CUDA-Q contêiner em um repositório Amazon ECR.

O trecho de código a seguir é um hello-world exemplo de execução de um CUDA-Q programa com o Amazon Braket Hybrid Jobs.

image_uri = "<ecr-image-uri>"

@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 local=True configuração, quando você executa 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 local=True sinalizador e executar seu trabalho AWS. Para saber mais, consulte Introdução ao Amazon Braket Hybrid Jobs.

Se suas cargas de trabalho 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 definir a instance_config configuração no hybrid_job decorador. Para obter mais informações sobre os tipos de instância compatíveis, consulte Configurar a instância de trabalho híbrida para executar seu script. Para obter uma lista dos tipos de instância, consulte Tipos de EC2 instância da Amazon.

@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 trabalho mais exigentes, você pode executar suas cargas de trabalho em um simulador de CUDA-Q GPU. Para habilitar um simulador de GPU, use o nome do back-end. nvidia O nvidia back-end funciona como um simulador de CUDA-Q GPU. Em seguida, selecione um tipo de EC2 instância da Amazon que ofereça suporte a uma NVIDIA GPU. O trecho de código a seguir mostra o decorador configurado pela hybrid_job GPU.

@hybrid_job(
    device="local:nvidia/nvidia",
    image_uri=image_uri,
    instance_config=InstanceConfig(instanceType="ml.p3.2xlarge"),
)
def my_job_script():
    ...

O Amazon Braket Hybrid Jobs oferece 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 carga de trabalho. Para paralelizar vários observáveis, faça as seguintes alterações em seu script de algoritmo.

Defina a mgpu opção do nvidia back-end. 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çãoexecution=cudaq.parallel.mpi. O trecho de código a seguir 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.p3.8xlarge", 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 cargas de trabalho 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 um Amazon Braket QPU, como IQM os dispositivos,, ou. IonQ 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 Amazon Braket Console.

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 o Amazon Braket Hybrid Jobs, consulte Trabalhando com o Amazon Braket Hybrid Jobs no guia do desenvolvedor. Para saber mais sobre o CUDA-Q, consulte a documentação CUDA-Q.