Use PennyLane com o Amazon Braket

Algoritmos híbridos são algoritmos que contêm instruções clássicas e quânticas. As instruções clássicas são executadas em hardware clássico (uma instância EC2 ou seu laptop), e as instruções quânticas são executadas em um simulador ou em um computador quântico. Recomendamos que você execute algoritmos híbridos usando o recurso Hybrid Jobs. Para obter mais informações, consulte Quando usar o Amazon Braket Jobs.

AmazonO Braket permite que você configure e execute algoritmos quânticos híbridos com a ajuda do PennyLane plug-in Braket ou com o Amazon SDK Braket Amazon Python e exemplos de repositórios de notebooks. Amazon Os notebooks de exemplo do Braket, baseados no SDK, permitem que você configure e execute determinados algoritmos híbridos sem o plug-in. PennyLane No entanto, recomendamos PennyLane porque proporciona uma experiência mais rica.

Sobre algoritmos quânticos híbridos

Os algoritmos quânticos híbridos são importantes para a indústria atual porque os dispositivos de computação quântica contemporâneos geralmente produzem ruído e, portanto, erros. Cada porta quântica adicionada a uma computação aumenta a chance de adicionar ruído; portanto, algoritmos de longa execução podem ser sobrecarregados pelo ruído, o que resulta em cálculos defeituosos.

Algoritmos quânticos puros, como o de Shor (exemplo de estimativa de fase quântica) ou o de Grover (exemplo de Grover), exigem milhares ou milhões de operações. Por esse motivo, eles podem ser impraticáveis para dispositivos quânticos existentes, geralmente chamados de dispositivos quânticos ruidosos de escala intermediária (NISQ).

Em algoritmos quânticos híbridos, as unidades de processamento quântico (QPUs) funcionam como coprocessadores para CPUs clássicas, especificamente para acelerar certos cálculos em um algoritmo clássico. As execuções de circuitos se tornam muito mais curtas, ao alcance dos recursos dos dispositivos atuais.

Amazon Braket com PennyLane

AmazonO Braket fornece suporte para PennyLaneuma estrutura de software de código aberto construída em torno do conceito de programação quântica diferenciável. Você pode usar essa estrutura para treinar circuitos quânticos da mesma forma que treinaria uma rede neural para encontrar soluções para problemas computacionais em química quântica, aprendizado de máquina quântica e otimização.

A PennyLane biblioteca fornece interfaces para ferramentas conhecidas de aprendizado de máquina, incluindo PyTorch e TensorFlow, para tornar o treinamento de circuitos quânticos rápido e intuitivo.

• A PennyLane Biblioteca -— PennyLane está pré-instalada nos notebooks Amazon Braket. Para acessar os dispositivos Amazon Braket a partir de PennyLane, abra um notebook e importe a PennyLane biblioteca com o comando a seguir.

import pennylane as qml

Os cadernos tutoriais ajudam você a começar rapidamente. Como alternativa, você pode usar PennyLane no Amazon Braket a partir de um IDE de sua escolha.

• O PennyLane plug-in Amazon Braket — Para usar seu próprio IDE, você pode instalar o plug-in Amazon PennyLane Braket manualmente. O plug-in se PennyLane conecta ao SDK Amazon Braket Python, para que você possa executar circuitos em dispositivos Braket. PennyLane Amazon Para instalar o PennyLane plug-in, use o comando a seguir.

pip install amazon-braket-pennylane-plugin

O exemplo a seguir demonstra como configurar o acesso aos dispositivos Amazon Braket em: PennyLane

# to use SV1
import pennylane as qml
sv1 = qml.device("braket.aws.qubit", device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", wires=2)

# to run a circuit:
@qml.qnode(sv1)
def circuit(x):
    qml.RZ(x, wires=0)
    qml.CNOT(wires=[0,1])
    qml.RY(x, wires=1)
    return qml.expval(qml.PauliZ(1))

result = circuit(0.543)


#To use the local sim:
local = qml.device("braket.local.qubit", wires=2)

Para exemplos de tutoriais e mais informações sobre isso PennyLane, consulte o repositório de exemplos do Amazon Braket.

O PennyLane plug-in Amazon Braket permite que você alterne entre o Amazon Braket QPU e dispositivos simuladores incorporados PennyLane com uma única linha de código. Ele oferece dois dispositivos quânticos Amazon Braket para trabalhar com: PennyLane

• braket.aws.qubitpara funcionar com os dispositivos quânticos do serviço Amazon Braket, incluindo QPUs e simuladores

• braket.local.qubitpara execução com o simulador Amazon local do Braket SDK

O PennyLane plugin Amazon Braket é de código aberto. Você pode instalá-lo a partir do GitHub repositório de PennyLane plug-ins.

Para obter mais informações sobre PennyLane, consulte a documentação no PennyLane site.

Algoritmos híbridos em notebooks de exemplo do Amazon Braket

AmazonO Braket fornece uma variedade de exemplos de notebooks que não dependem do PennyLane plug-in para executar algoritmos híbridos. Você pode começar com qualquer um desses notebooks híbridos Amazon Braket que ilustram métodos variacionais, como o Quantum Approximate Optimization Algorithm (QAOA) ou o Variational Quantum Eigensolver (VQE).

Os notebooks de exemplo do Amazon Braket dependem do SDK Amazon Braket Python. O SDK fornece uma estrutura para interagir com dispositivos de hardware de computação quântica por meio do Amazon Braket. É uma biblioteca de código aberto projetada para ajudá-lo com a parte quântica do seu fluxo de trabalho híbrido.

Você pode explorar ainda mais o Amazon Braket com nossos exemplos de cadernos.

Algoritmos híbridos com PennyLane simuladores incorporados

AmazonO Braket Hybrid Jobs agora vem com simuladores incorporados de alto desempenho baseados em CPU e GPU da. PennyLane Essa família de simuladores incorporados pode ser incorporada diretamente em seu contêiner de tarefas híbrido e inclui o rápido simulador vetorial de estado, o lightning.qubitlightning.gpu simulador acelerado usando a biblioteca CuQuantum da NVIDIA e outros. Esses simuladores incorporados são ideais para algoritmos variacionais, como aprendizado de máquina quântico, que podem se beneficiar de métodos avançados, como o método de diferenciação adjunta. Você pode executar esses simuladores incorporados em uma ou várias instâncias de CPU ou GPU.

Com o Hybrid Jobs, agora você pode executar seu código de algoritmo variacional usando uma combinação de um coprocessador clássico e uma QPU, um simulador sob demanda Amazon Braket, comoSV1, ou usando diretamente o simulador incorporado do. PennyLane

O simulador incorporado já está disponível com o contêiner Hybrid Jobs. Você só precisa decorar sua função principal do Python com @hybrid_job o decorador. Para usar o PennyLane lightning.gpu simulador, você também precisa especificar uma instância de GPU no, InstanceConfig conforme mostrado no seguinte trecho de código:

import pennylane as qml
from braket.jobs import hybird_job
from braket.jobs.config import InstanceConfig


@hybrid_job(device="local:pennylane/lightning.gpu", instance_config=InstanceConfig(instanceType="ml.p3.8xlarge"))
def function(wires):
    dev = qml.device("lightning.gpu", wires=wires)
    ...

Consulte o exemplo de caderno para começar a usar um simulador PennyLane incorporado com o Hybrid Jobs.

Gradiente adjunto PennyLane com simuladores Amazon Braket

Com o PennyLane plug-in do Amazon Braket, você pode calcular gradientes usando o método de diferenciação adjunta ao executar no simulador vetorial estadual local ou no SV1.

Nota: Para usar o método de diferenciação adjunta, você deve especificar diff_method='device' em seuqnode, e não. diff_method='adjoint' Veja o exemplo a seguir.

device_arn = "arn:aws:braket:::device/quantum-simulator/amazon/sv1"
dev = qml.device("braket.aws.qubit", wires=wires, shots=0, device_arn=device_arn)
                
@qml.qnode(dev, diff_method="device")
def cost_function(params):
    circuit(params)
    return qml.expval(cost_h)

gradient = qml.grad(circuit)
initial_gradient = gradient(params0)

nota

Atualmente, PennyLane calculará índices de agrupamento para hamiltonianos da QAOA e os usará para dividir o hamiltoniano em vários valores de expectativa. Se você quiser usar o recurso de diferenciação adjunta do SV1 ao executar o QAOA a partir dePennyLane, precisará reconstruir o hamiltoniano de custo removendo os índices de agrupamento, da seguinte forma: cost_h, mixer_h = qml.qaoa.max_clique(g, constrained=False) cost_h = qml.Hamiltonian(cost_h.coeffs, cost_h.ops)