Notas de versão do Qiskit 0.6

0.6

Terra 0.6

Destaques

Esta versão inclui uma reformulação dos componentes internos centrada em um novo formato de comunicação formal (Qobj), além de recursos há muito esperados para melhorar a experiência do usuário como um todo. Os destaques, em comparação com a versão 0.5, são:

• Aprimoramentos para interoperabilidade (com base na especificação Qobj) e extensibilidade (recursos para estender o Qiskit com novos back-ends de forma contínua)
• Novas opções para lidar com credenciais e autenticação para os back-ends do IBM Q, com o objetivo de simplificar o processo e oferecer suporte ao carregamento automático de credenciais de usuário
• Uma reformulação dos utilitários de visualização: visualizações interativas elegantes agora estão disponíveis para os usuários do Jupyter, juntamente com refinamentos para a gaveta de circuitos (incluindo uma versão baseada em matplotlib)
• Melhorias no desempenho centradas na transpilação de circuitos: a base para uma arquitetura mais flexível e modular foi definida, incluindo a paralelização da compilação de circuitos e várias otimizações

Considerações de Compatibilidade

Observe que algumas alterações incompatíveis com versões anteriores foram introduzidas durante esta versão - as observações a seguir contêm informações sobre como se adaptar às novas alterações.

Remoção de QuantumProgram

Conforme sugerido durante a versão 0.5, a descontinuação da classe QuantumProgram foi concluída e não está mais disponível, em favor do trabalho com os componentes individuais (BaseJob, QuantumCircuit, ClassicalRegister, QuantumRegister, qiskit) diretamente.

Consulte as notas de versão do site 0.5 e os exemplos para obter detalhes sobre a transição:

from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import Aer, execute

q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)

qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q, c)

backend = get_backend('qasm_simulator')

job_sim = execute(qc, backend)
sim_result = job_sim.result()

print("simulation: ", sim_result)
print(sim_result.get_counts(qc))

IBM Autenticação Q e Qconfig.py

O gerenciamento de credenciais para autenticação ao usar os back-ends do IBM Q foi ampliado, e há novas opções que podem ser usadas por conveniência:

1. salve suas credenciais no disco uma vez e carregue-as automaticamente em sessões futuras. Isso proporciona um mecanismo único:

   from qiskit import IBMQ
   IBMQ.save_account('MY_API_TOKEN', 'MY_API_URL')

   depois disso, suas credenciais podem ser carregadas automaticamente do disco, invocando load_accounts():

   from qiskit import IBMQ
   IBMQ.load_accounts()

   ou você pode carregar apenas contas específicas se quiser usá-las somente em uma sessão:

   IBMQ.load_accounts(project='MY_PROJECT')

2. usar variáveis de ambiente. Se QE_TOKEN e QE_URL estiverem definidos, a chamada IBMQ.load_accounts() carregará automaticamente as credenciais a partir deles.

Além disso, o método anterior de ter um arquivo Qconfig.py na pasta do programa e passar as credenciais explicitamente ainda é suportado.

Trabalhando com backends

Um novo mecanismo foi introduzido no Terra 0.6 como a forma recomendada para obter um backend, permitindo uma filtragem mais poderosa e unificada e integrada ao novo sistema de credenciais. Os métodos anteriores de nível superior register(), available_backends() e get_backend() ainda são compatíveis, mas serão preteridos nas próximas versões em favor do uso direto dos objetos qiskit.IBMQ e qiskit.Aer, que permitem uma filtragem mais complexa.

Por exemplo, para listar e usar um backend local:

from qiskit import Aer

all_local_backends = Aer.backends(local=True)  # returns a list of instances
qasm_simulator = Aer.backends('qasm_simulator')

E para listar e usar back-ends remotos:

from qiskit import IBMQ

IBMQ.enable_account('MY_API_TOKEN')
5_qubit_devices = IBMQ.backends(simulator=True, n_qubits=5)
ibmqx4 = IBMQ.get_backend('ibmqx4')

Observe também que os nomes dos simuladores locais foram simplificados. Os nomes anteriores ainda podem ser usados, mas é recomendável usar os nomes novos e mais curtos:

Alterações no backend e na API de tarefas

• Os trabalhos enviados aos backends do IBM Q têm recursos aprimorados. É possível cancelá-los e reabastecer os créditos (job.cancel()) e recuperar trabalhos anteriores executados em um backend específico por ID de trabalho (backend.retrieve_job(job_id)) ou em lote dos trabalhos mais recentes (backend.jobs(limit))

• As propriedades para verificar cada status de trabalho individual (queued, running, validating, done e cancelled) não existem mais. Se você quiser verificar o status do trabalho, use a comparação de identidade com job.status:

  from qiskit.backends import JobStatus
  
  job = execute(circuit, backend)
  if job.status() is JobStatus.RUNNING:
      handle_job(job)

Consulte a nova documentação da classe IBMQJob para obter mais informações sobre como usar a API simplificada.

• Vários membros de BaseBackend e BaseJob não são mais propriedades, mas métodos e, como resultado, precisam ser chamados como funções.

  Qiskit Terra 0.5	Qiskit Terra 0.6
  backend.name	backend.name()
  backend.status	backend.status()
  backend.configuration	backend.configuration()
  backend.calibration	backend.properties()
  backend.parameters	backend.jobs () backend.retrieve_job (job_id)
  job.status	job.status()
  job.cancelled	job.queue_position()
  job.running	job.cancel()
  job.queued
  job.done

Ferramentas Jupyter aprimoradas

A nova versão contém melhorias na experiência do usuário ao usar os notebooks Jupyter.

Primeiro, são fornecidas novas visualizações interativas de histogramas de contagens e estados quânticos: plot_histogram() e plot_state(). Esses métodos usarão como padrão o novo tipo interativo quando o ambiente for o Jupyter e houver conexão com a Internet.

Em segundo lugar, a nova versão fornece Jupyter cell magics para acompanhar o progresso do seu código. Use %%qiskit_job_status para acompanhar o status dos trabalhos enviados aos backends do IBM Q. Use o site %%qiskit_progress_bar para acompanhar o progresso da compilação/execução.