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á.
# Compilar seu primeiro circuito
Depois que a instância do caderno for iniciada, abra a instância com uma interface Jupyter padrão escolhendo o caderno que você acabou de criar.
As instâncias do caderno Amazon Braket são pré-instaladas com o Amazon Braket SDK e todas as suas dependências. Comece criando um novo caderno com kernel `conda_braket`.
Você pode começar com um simples “Olá, mundo\!” exemplo. Primeiro, construa um circuito que prepare um estado de Bell e, em seguida, execute esse circuito em dispositivos diferentes para obter os resultados.
Comece importando os módulos do Amazon Braket SDK e definindo um módulo simpleBRAKETlong; SDK e definindo um circuito Bell State básico.
```
import boto3
from braket.aws import AwsDevice
from braket.devices import LocalSimulator
from braket.circuits import Circuit
# Create the circuit
bell = Circuit().h(0).cnot(0, 1)
```
É possível visualizar o circuito com este comando:
```
print(bell)
```
```
T : │ 0 │ 1 │
┌───┐
q0 : ─┤ H ├───●───
└───┘ │
┌─┴─┐
q1 : ───────┤ X ├─
└───┘
T : │ 0 │ 1 │
```
**Execute seu circuito no simulador local**
Em seguida, escolha o dispositivo quântico no qual executar o circuito. O Amazon Braket SDK vem com um simulador local para prototipagem e testes rápidos. Recomendamos usar o simulador local para circuitos menores, que podem ser de até 25 qubits (dependendo do hardware local).
Para instanciar o simulador local:
```
# Instantiate the local simulator
local_sim = LocalSimulator()
```
e executar o circuito:
```
# Run the circuit
result = local_sim.run(bell, shots=1000).result()
counts = result.measurement_counts
print(counts)
```
Você deverá ver um resultado semelhante a este:
```
Counter({'11': 503, '00': 497})
```
O estado de Bell específico que você preparou é uma superposição igual de \|00⟩ e \|11⟩ e uma distribuição quase igual (até ruído shot) de 00 e 11 como resultados de medição, conforme esperado.
**Execute seu circuito em um simulador sob demanda**
O Amazon Braket também fornece acesso a um simulador SV1 de alto desempenho sob demanda para executar circuitos maiores. SV1é um simulador vetorial de estado sob demanda que permite a simulação de circuitos quânticos de até 34 qubits. Você pode encontrar mais informações SV1 na seção [Dispositivos compatíveis](braket-devices.md) e no AWS console. Ao executar tarefas quânticas em SV1 (e sobre TN1 ou em qualquer QPU), os resultados de sua tarefa quântica são armazenados em um bucket S3 em sua conta. Se você não especificar um bucket, o Braket SDK criará um bucket `amazon-braket-{region}-{accountID}` padrão para você. Para saber mais, consulte [Gerenciando o acesso ao Amazon Braket](braket-manage-access.md).
**nota**
Preencha o nome real do bucket existente, onde o exemplo a seguir aparece `amazon-braket-s3-demo-bucket` como o nome do bucket. Os nomes de bucket para Amazon Braket sempre começam com `amazon-braket-`, seguidos por outros caracteres de identificação que você adiciona. Se você precisar de informações sobre como configurar um bucket do S3, consulte [Conceitos básicos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html).
```
# Get the account ID
aws_account_id = boto3.client("sts").get_caller_identity()["Account"]
# The name of the bucket
my_bucket = "amazon-braket-s3-demo-bucket"
# The name of the folder in the bucket
my_prefix = "simulation-output"
s3_folder = (my_bucket, my_prefix)
```
Para executar um circuito SV1, você deve fornecer a localização do bucket S3 que você selecionou anteriormente como argumento posicional na chamada `.run()`.
```
# Choose the cloud-based on-demand simulator to run your circuit
device = AwsDevice("arn:aws:braket:::device/quantum-simulator/amazon/sv1")
# Run the circuit
task = device.run(bell, s3_folder, shots=100)
# Display the results
print(task.result().measurement_counts)
```
O console Amazon Braket fornece mais informações sobre sua tarefa quântica. Navegue até a guia **Tarefas quânticas** no console e sua tarefa quântica deve estar no topo da lista. Como alternativa, você pode pesquisar sua tarefa quântica usando o ID exclusivo da tarefa quântica ou outros critérios.
**nota**
Depois de 90 dias, o Amazon Braket remove automaticamente todas as IDs de tarefas quânticas e outros metadados associados às suas tarefas quânticas. Para obter mais informações, consulte [Retenção de dados](https://docs.aws.amazon.com/braket/latest/developerguide/security.html#braket-data-retention).
**Executando em uma QPU**
Com o Amazon Braket, você pode executar o exemplo anterior de circuito quântico em um computador quântico físico alterando apenas uma única linha de código. O Amazon Braket fornece acesso a uma variedade de dispositivos de unidade de processamento quântico (QPU). Você pode encontrar informações sobre os diferentes dispositivos e janelas de disponibilidade na seção [Dispositivos compatíveis](braket-devices.md) e no AWS console, na guia **Dispositivos**. O exemplo a seguir mostra como instanciar um dispositivo IQM.
```
# Choose the IQM hardware to run your circuit
device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")
```
Ou escolha um dispositivo IonQ com esse código:
```
# Choose the Ionq device to run your circuit
device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1")
```
Depois de selecionar um dispositivo e antes de executar sua workload, você pode consultar a profundidade da fila do dispositivo com o código a seguir para determinar o número de tarefas quânticas ou trabalhos híbridos. Além disso, os clientes podem visualizar as profundidades de fila específicas do dispositivo na página Dispositivos do Amazon Braket Management Console.
```
# Print your queue depth
print(device.queue_depth().quantum_tasks)
# Returns the number of quantum tasks queued on the device
# {: '0', : '0'}
print(device.queue_depth().jobs)
# Returns the number of hybrid jobs queued on the device
# '2'
```
Quando você executa sua tarefa, o Amazon Braket SDK pesquisa um resultado (com um tempo limite padrão de 5 dias). Você pode alterar esse padrão modificando o parâmetro `poll_timeout_seconds` no comando `.run()`, conforme mostrado no exemplo a seguir. Lembre-se de que, se o tempo limite da pesquisa for muito curto, os resultados podem não ser retornados dentro do tempo da pesquisa, como quando uma QPU não está disponível e um erro de tempo limite local é retornado. Você pode reiniciar a pesquisa chamando a função `task.result()`.
```
# Define quantum task with 1 day polling timeout
task = device.run(bell, s3_folder, poll_timeout_seconds=24*60*60)
print(task.result().measurement_counts)
```
Além disso, depois de enviar sua tarefa quântica ou trabalho híbrido, você pode chamar a função `queue_position()` para verificar a posição da fila.
```
print(task.queue_position().queue_position)
# Return the number of quantum tasks queued ahead of you
# '2'
```