Computação quântica interativa: sessões

Este artigo explica a arquitetura da computação quântica interativa, também conhecida como sessões, e como criar uma nova sessão.

Neste modelo de computação quântica híbrida, o recurso de computação cliente pode ser movido para a nuvem, resultando em menor latência e na capacidade de repetir a execução do circuito quântico com diferentes parâmetros. Os trabalhos podem ser agrupados logicamente em uma sessão, e os trabalhos nessa sessão podem ser priorizados em relação aos trabalhos que não são de sessão. Embora os estados de qubit não persistam entre trabalhos, uma sessão permite tempos de fila mais curtos para trabalhos e problemas de execução mais longos.

Pré-requisitos

Para criar uma sessão, você precisa dos seguintes pré-requisitos:

• Uma conta do Azure com uma subscrição ativa. Se não tiver uma conta do Azure, registe-se gratuitamente e inscreva-se numa subscrição pré-paga.

• Um espaço de trabalho do Azure Quantum. Para obter mais informações, consulte Criar um espaço de trabalho do Azure Quantum.

• Um ambiente Python com Python e Pip instalados.

• O pacote Azure Quantum azure-quantum . Se você quiser usar Qiskit ou Cirq, você precisa instalar o azure-quantum pacote com as tags [qiskit] ou [cirq].

  pip install --upgrade azure-quantum[qiskit] 
  

O que é uma sessão?

Uma sessão é um agrupamento lógico de um ou mais trabalhos enviados para um único target. Cada sessão tem um ID exclusivo anexado a cada trabalho nessa sessão.

As sessões permitem organizar vários trabalhos de computação quântica com a capacidade de executar código clássico entre trabalhos quânticos. Você será capaz de executar algoritmos complexos para organizar e rastrear melhor seus trabalhos individuais de computação quântica.

Um cenário de usuário chave onde você pode querer combinar trabalhos em uma sessão são algoritmos quânticos parametrizados , onde a saída de um trabalho de computação quântica informa os parâmetros do próximo trabalho de computação quântica. Os exemplos mais comuns deste tipo de algoritmo são Variational Quantum Eigensolvers (VQE) e Quantum Approximate Optimization Algorithms (QAOA).

Hardware suportado

As sessões são suportadas em todos os fornecedores de hardware de computação quântica, atualmente IonQ, Quantinuum e Rigetti. Em alguns casos, os trabalhos enviados dentro de uma sessão são priorizados na fila desse target. Para obter mais informações, consulte Comportamento de destino.

Introdução às sessões

As sessões são gerenciadas com Python e podem ser criadas para qualquer programa quântico QIR, incluindo Q#programas , Qiskit e Cirq.

Q# + Python

Este exemplo mostra como criar uma sessão com Q# código embutido usando um Jupyter Notebook no Visual Studio Code. Você também pode criar sessões usando um programa Python que invoca um programa adjacente Q# .

Nota

As sessões são gerenciadas com Python, mesmo quando se executa Q# código embutido.

1. No VS Code, selecione View > Command palette e selecione Create: New Jupyter Notebook.

2. No canto superior direito, o VS Code detetará e exibirá a versão do Python e o ambiente Python virtual que foi selecionado para o notebook. Se você tiver vários ambientes Python, talvez seja necessário selecionar um kernel usando o seletor de kernel no canto superior direito. Se nenhum ambiente foi detetado, consulte Jupyter Notebooks no VS Code para obter informações de configuração.

3. Na primeira célula do bloco de notas, execute

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

4. Clique em + Código para adicionar uma nova célula no bloco de anotações e importar qsharp o Python SDK.

   import qsharp
   

5. Selecione o quantum target de sua escolha. Neste exemplo, você está usando o simulador IonQ como target.

   target = workspace.get_targets("ionq.simulator")
   

6. Selecione as configurações do perfil, , Adaptive_RIBaseou Unrestricted.target

   qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Adaptive_RI, qsharp.TargetProfile.Unrestricted
   

   Nota

   Adaptive_RItarget trabalhos de perfil são atualmente suportados no Quantinuum targets. Para obter mais informações, consulte Computação quântica híbrida integrada.

7. Escreva o seu Q# programa. Por exemplo, o seguinte Q# programa gera um bit aleatório. Para ilustrar o uso de argumentos de entrada, este programa usa um inteiro, n, e uma matriz de ângulos, anglecomo entrada.

   %%qsharp
   open Microsoft.Quantum.Measurement;
   open Microsoft.Quantum.Arrays;
   
   operation GenerateRandomBits(n: Int, angle: Double[]) : Result[] {
      use qubits = Qubit[n]; // n parameter as the size of the qubit array
      for q in qubits {
          H(q);
      }
      R(PauliZ, angle[0], qubits[0]); // arrays as entry-points parameters
      R(PauliZ, angle[1], qubits[1]);
      let results = MeasureEachZ(qubits);
      ResetAll(qubits);
      return results;
   }
   

8. Em seguida, crie uma sessão. Digamos que você queira executar GenerateRandomBit a operação três vezes, então você usa target.submit para enviar a Q# operação com os target dados e você repete o código três vezes - em um cenário do mundo real, você pode querer enviar programas diferentes em vez do mesmo código.

   angle = [0.0, 0.0]
   with target.open_session(name="Q# session of three jobs") as session:
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 1", shots=100) # First job submission
       angle[0] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 2", shots=100) # Second job submission
       angle[1] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 3", shots=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

   Importante

   Ao passar argumentos como parâmetros para o trabalho, eles são formatados na Q# expressão ao chamar qsharp.compile. Isso significa que você precisa ter cuidado para formatar seus argumentos como Q# objetos. Neste exemplo, como matrizes em Python já são impressas como [item0, item1, ...], os argumentos de entrada correspondem à Q# formatação. Para outras estruturas de dados Python, você pode precisar de mais manipulação para obter os valores de cadeia de caracteres inseridos Q# no de forma compatível.

9. Depois de criar uma sessão, você pode usar workspace.list_session_jobs para recuperar uma lista de todos os trabalhos na sessão. Para obter mais informações, consulte Como gerenciar sessões.

Qiskit

1. Primeiro, você precisa importar módulos adicionais de azure-quantum e qiskit. Em seguida, crie um provider objeto com as informações do espaço de trabalho do Quantum.

   from qiskit import QuantumCircuit
   from azure.quantum import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   
   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

2. Escreva o seu circuito quântico. Por exemplo, o circuito a seguir gera um bit aleatório.

   circuit = QuantumCircuit(2, 2)
   circuit.name = "GenerateRandomBit"
   circuit.h(0)
   circuit.cx(0,1)
   circuit.measure([0,1], [0,1])
   circuit.draw()
   

3. Em seguida, crie uma instância de back-end com o quantum target de sua escolha. Neste exemplo, defina o simulador IonQ como o target.

   backend = provider.get_backend("ionq.simulator")
   

4. Em seguida, crie uma sessão. Digamos que você queira executar seu circuito quântico três vezes, então você usa backend.run para enviar o circuito Qiskit, e você repete o código três vezes - em um cenário do mundo real, você pode querer enviar programas diferentes em vez do mesmo código. Você pode usar workspace.list_session_jobs para recuperar uma lista de todos os trabalhos na sessão. Para obter mais informações, consulte Como gerenciar sessões.

   with backend.open_session(name="Qiskit Session") as session:
       job1 = backend.run(circuit=circuit, shots=100, job_name="Job 1") # First job submission
       job1.wait_for_final_state()
       job2 = backend.run(circuit=circuit, shots=100, job_name="Job 2") # Second job submission
       job2.wait_for_final_state()
       job3 = backend.run(circuit=circuit, shots=100, job_name="Job 3") # Third job submission
       job3.wait_for_final_state()
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

Cirq

1. Primeiro, escreva o seu circuito quântico. Por exemplo, o circuito a seguir gera um bit aleatório.

   import cirq
   
   q0 = cirq.LineQubit(0)
   q1 = cirq.LineQubit(1)
   circuit = cirq.Circuit(
       cirq.H(q0),  # H gate
       cirq.CNOT(q0, q1),
       cirq.measure(q0, key='q0'),
       cirq.measure(q1, key='q1')
   )
   print(circuit)
   

2. Em seguida, crie um service objeto com as informações do espaço de trabalho do Quantum.

   from azure.quantum.cirq import AzureQuantumService
   
   service = AzureQuantumService(
               resource_id = "", # add your resource ID
               location = "") # add your location
   

3. Selecione o quantum target de sua escolha. Neste exemplo, você está usando o simulador IonQ como target.

   Nota

   Os circuitos Cirq só podem usar IonQ ou Quantinuum targets.

   target = service.get_target("ionq.simulator")
   

4. Em seguida, crie uma sessão. Digamos que você queira executar seu circuito quântico três vezes, então você usa target.submit para enviar o circuito Cirq, e você repete o código três vezes - em um cenário do mundo real, você pode querer enviar programas diferentes em vez do mesmo código. Você pode usar workspace.list_session_jobs para recuperar uma lista de todos os trabalhos na sessão. Para obter mais informações, consulte Como gerenciar sessões.

   with target.open_session(name="Cirq Session") as session:
       target.submit(program=circuit, name="Job 1", repetitions=100) # First job submission
       target.submit(program=circuit, name="Job 2", repetitions=100) # Second job submission
       target.submit(program=circuit, name="Job 3", repetitions=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

Sessões de monitorização

Você pode usar a folha Gerenciamento de tarefas em seu espaço de trabalho do Quantum para exibir todos os itens enviados de nível superior, incluindo sessões e trabalhos individuais que não estão associados a nenhuma sessão.

1. Selecione a folha Gerenciamento de tarefas no espaço de trabalho do Quantum.
2. Identifique os trabalhos do tipo Sessão. Nesta vista, pode ver o ID Exclusivo de uma Sessão na coluna ID e monitorizar o seu Estado. Os estados de uma sessão são:
   • Aguardando: Os trabalhos dentro da sessão estão sendo executados.
   • Êxito: A sessão terminou com êxito.
   • Tempo limite: Se nenhum novo trabalho for enviado dentro da sessão por 10 minutos, esse tempo limite da sessão expira. Para obter mais informações, consulte Tempos limite de sessão.
   • Falha: Se um trabalho dentro de uma sessão falhar, essa sessão termina e relata um status de Falha. Para obter mais informações, consulte Política de falha de trabalho em sessões.
3. Clique no nome de uma sessão para obter mais detalhes.
4. Você pode ver a lista de Todos os trabalhos dentro da sessão e monitorar seu status.

Comportamento do alvo

Cada provedor de hardware quântico define sua própria heurística para melhor gerenciar a priorização de trabalhos dentro de uma sessão.

Quantinuum

Se você optar por enviar trabalhos dentro de uma sessão para um Quantinuum target, sua sessão terá acesso exclusivo ao hardware, desde que você enfileire trabalhos dentro de um minuto um do outro. Depois disso, seus trabalhos serão aceitos e tratados com a lógica padrão de fila e priorização.

Conteúdos relacionados

• Como gerir sessões
• Computação quântica integrada