Aula 04 - Computação Quântica - Primeiro Circuito
Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook
Link do código fluente no Pinterest
Meus links de afiliados:
Link do código da aula:
Computação Quântica - IBM Q - Primeiro Circuito
Vamos criar uma aplicação
quântica básica com
mecânica quântica usando o
Qiskit.
Executando sua primeira aplicação quântica
Agora que seu ambiente tá pronto, com tudo o que você precisa instalado e com sua conexão com a máquina quântica da IBM configurada, chegou a hora de rodar sua primeira aplicação quântica.
Abra o Anaconda navigator e em seguida o Jupyter.
O
Jupyter pode solicitar
senha ou
token de acesso, para evitar essa exigência, você pode também rodar o comando abaixo no
Anaconda prompt que ele vai abrir o
Jupyter sem pedir senha nem token:
jupyter notebook --ip='*' --NotebookApp.token='' --NotebookApp.password=''
Com o jupyter aberto
Agora que você tá com o
jupyter aberto, crie um
novo notebook, dê um nome a ele(ex. qiskit01) e crie a célula com o
import do
IBMQ e em seguida configure seu acesso, substituindo
MY_API_TOKEN no código abaixo, pelo valor do
token da
API que você criou em:
https://quantum-computing.ibm.com/account
from qiskit import IBMQ
IBMQ.save_account('MY_API_TOKEN')
Pronto, agora você tá credenciado para acessar a máquina da IBM.
Importe tudo do
Qiskit:
from qiskit import *
Pronto, com o
Qiskit importado, o próximo passo é construir um circuito quântico, para isso, precisaremos de
dois bits quânticos, ou seja,
dois qbits.
Então o que vamos fazer primeiro é
criar os
dois registradores quânticos, isto é, os
dois bits quânticos.
qr = QuantumRegister(2)
A segunda coisa é
criar os
dois registradores clássicos, isto é, os
dois bits binários.
cr = ClassicalRegister(2)
Agora que temos dois registradores quânticos e dois clássicos, podemos criar um circuito.
circuit = QuantumCircuit(qr, cr)
Criamos um circuito quântico, em qualquer ponto que nós modificarmos o circuito, podemos visualizar ele com:
%matplotlib inline
circuit.draw()
Saída:
q0_0: |0>
q0_1: |0>
c1_0: 0
c1_1: 0
No circuito temos dois bits quânticos,
q0_0 e
q0_1, e dois bis clássicos
c1_0 e
c1_1.
Até agora nada de mais, não há nada de interessante nisso ainda, não temos nenhum gate.
Então vamos criar um gate.
Para criar esse emaranhamento quântico, o primeiro passo é aplicar o que é chamado de hadamard gate no seu primeiro
qbit.
O que vamos fazer então é criar um circuito
hadamard e aplicar ao primeiro
qbit.
E também plotar a saída usando o
matplotlib.
# the quantum circuit has one qubit. It is indexed as qubit 0
circuit.h(0)
circuit.draw(output='mpl')
Saída:
Vamos criar agora uma
operação com os
dois qbits chamada de
controle X, funciona parecido com a lógica condicional do
if.
circuit.cx(0,1) # order is: control(0) and target(1)
Saída:
<qiskit.circuit.instructionset.InstructionSet at 0x208316deb48>
Vamos desenhar o circuito com:
circuit.draw(output='mpl')
Saída:
O circuito agora tem um hadamard gate e um controle.
A ideia é que com essas duas operações simples, nós seremos capazes de gerar emaranhamentos em bits quânticos
q0_0,
q0_1.
Então, agora que criamos nosso circuito quântico, usando o
hadamard gate e o
controle x, o que vamos fazer agora é medir o bit quântico, pegar sua medição e armazenar em um bit clássico.
circuit.measure(qr, cr)
circuit.draw(output='mpl')
Saída:
Nosso circuito quântico está da forma mostrada acima.
Temos uma operação quântica, o
hadamard gate e o
controlled x gate e temos a medição.
O próximo passo é executar o circuito, e iremos fazer duas coisas:
- Executar o circuito em um computador clássico e ver o que acontece quando simulamos um computador quântico.
- Executar em um dispositivo quântico real da IBM e então observar os resultados retornados.
Para simular o circuito quântico, o que vamos fazer é importar o componente
Aer do
Qiskit.
A ideia é usar o
Aer no nosso computador local para simular o circuito quântico.
simulator = Aer.get_backend('qasm_simulator')
Execute:
result = execute(circuit, backend=simulator).result()
Faça o import do plot_histogram
from qiskit.visualization import plot_histogram
Agora vamos plotar o resultado
plot_histogram(result.get_counts(circuit))
Saída:
Tivemos aproximadamente
50% ou
0.5 de
probabilidade de
zero zero e quase
50% também de
um um.
Esse pequeno erro é porque estamos executando um limitado número de tentativas em nossa simulação ao invés de infinitas.
Vamos executar agora o mesmo experimento em um dispositivo quântico real e ver o que acontece.
Vamos carregar nossas
credenciais de
acesso, a
máquina quântica da
IBM.
IBMQ.load_account()
Diga ao
provider para usar o
ibm-q:
provider = IBMQ.get_provider('ibm-q')
Agora defina qual é a máquina, o dispositivo que vai rodar o circuito:
qcomp = provider.get_backend('ibmq_16_melbourne')
Esse dispositivo fica em algum lugar em Melbourne.
Defina o job.
job = execute(circuit, backend=qcomp)
Importe o
job_monitor
from qiskit.tools.monitor import job_monitor
job_monitor(job)
A ideia aqui é que esse
job seja submetido a o computador quântico real, e como ele é um dispositivo público, existe uma fila.
É o
job_monitor que permite que eu coloque esse
job criado na fila do processamento da máquina quântica real.
Depois de concluído, você vai ver a mensagem:
Job Status: job has successfully run
Você pode rodar então:
result = job.result()
plot_histogram(result.get_counts(circuit))
Comparando o resultado das duas plotagens, o da simulação você só teve estados
zero zero e
um um.
No dispositivo quântico tivemos um pequeno número de resultados aparecendo estados
zero um e
um zero.
Mesmo a maioria dos resultados tendo sido estados
zero zero e
um um tivemos esse pequeno número de '
erros' estados
zero um e
um zero.
Isso acontece porque a simulação emula um computador quântico perfeito, só que o dispositivo quântico real é suscetível a pequenos erros quânticos.
Esses erros quânticos tem sido melhorados a cada dia como resultado do avanço tecnológico, então podemos esperar que esses erros diminuam ao longo dos próximos anos, chegando cada vez mais perto da perfeição.
Valeu, ficamos por aqui. :)
Link do código da aula:
Se tiverem curtido o conteúdo, dêem um joinha 👍 na página do Código Fluente no
Facebook
Link do código fluente no Pinterest
Novamente deixo meus link de afiliados:
Obrigado ;)
