Introdução às sessões

As sessões são um recurso fundamental da computação quântica híbrida que permite agrupar vários trabalhos de computação quântica. Uma sessão é um agrupamento lógico de um ou mais trabalhos enviados para um único target. Cada sessão tem uma ID exclusiva anexada a cada trabalho nessa sessão. As sessões são úteis quando você deseja executar vários trabalhos de computação quântica em sequência, com a capacidade de executar código clássico entre trabalhos quânticos.

Este artigo explica a arquitetura das sessões na computação quântica híbrida e como criar uma nova sessão.

Pré-requisitos

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

Uma conta do Azure com uma assinatura ativa. Se você não tiver uma conta do Azure, registre-se gratuitamente e inscreva-se para uma assinatura paga conforme o uso.
Um Azure Quantum espaço de trabalho. Para obter mais informações, consulte Como criar um Azure Quantum workspace.
Um ambiente Python com Python e Pip instalado.
A qdkPython biblioteca. Se você quiser usar Qiskit ou Cirq, precisará instalar os extras azure e qiskit.
```
pip install --upgrade qdk
```
or
```
pip install --upgrade "qdk[azure,qiskit]" 
```

O que é uma sessão?

Nas sessões, o recurso de computação do 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 parâmetros diferentes. 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 os trabalhos, uma sessão permite tempos de fila mais curtos para trabalhos e problemas de execução mais longos.

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

Um cenário de usuário importante em que você pode querer combinar trabalhos em uma sessão são os algoritmos quânticos parametrizados em que 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 desse tipo de algoritmo são Variational Quantum Eigensolvers (VQE) e Quantum Approximate Optimization Algorithms (QAOA).

Hardware com suporte

As sessões têm suporte em todos os provedores de hardware de computação quântica. Em alguns casos, os trabalhos enviados em uma sessão são priorizados na fila desse target. Para obter mais informações, consulte o comportamento de destino.

Como criar uma sessão

Para criar uma sessão, siga estas etapas:

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

Observação

As sessões são gerenciadas com Python, mesmo ao executar Q# código embutido.

In VS Code, abra o menu Exibir e escolha Paleta de Comandos.
Insira e selecione Criar: Novo Jupyter Notebook.
No canto superior direito, VS Code detectará e exibirá a versão de Python e o ambiente virtual Python que foi selecionado para o notebook. Se você tiver vários Python ambientes, talvez seja necessário selecionar um kernel usando o seletor de kernel no canto superior direito. Se nenhum ambiente foi detectado, veja Jupyter Notebooks em VS Code para informações de configuração.

Na primeira célula do notebook, execute o seguinte código:

from qdk.azure import Workspace

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

Adicione uma nova célula no notebook e importe o qsharpPython pacote:
```
from qdk import qsharp
```
Escolha seu quantum target. Neste exemplo, é o targetsimulador IonQ.
```
target = workspace.get_targets("ionq.simulator")
```
Selecione as configurações do target
```
qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Adaptive_RI, qsharp.TargetProfile.Unrestricted
```
Observação

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

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

%%qsharp
import Std.Measurement.*;
import Std.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;
}

Em seguida, você cria 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 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

Quando você passa argumentos como parâmetros para o trabalho, os argumentos são formatados na Q# expressão quando qsharp.compile são chamados. Isso significa que você precisa formatar seus argumentos como Q# objetos. Neste exemplo, como as matrizes já Python estão impressas como [item0, item1, ...], os argumentos de entrada correspondem à Q# formatação. Para outras Python estruturas de dados, talvez seja necessário mais tratamento para inserir os valores de strings de maneira compatível no Q#.
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.

Importar módulos adicionais de azure-quantum e qiskit.

from qdk.qiskit import QuantumCircuit
from qdk.azure import Workspace
from azure.quantum.qiskit import AzureQuantumProvider

Crie um objeto provider com as suas informações do workspace Quantum.

workspace = Workspace(
            resource_id = "", # add your resource ID
            location = "") # add your location

provider = AzureQuantumProvider(workspace)

Escreva 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()

Crie uma instância de back-end com o quantum target de sua escolha. Neste exemplo, defina o target para o simulador IonQ.
```
backend = provider.get_backend("ionq.simulator")
```

Crie uma sessão. Digamos que você queira executar o circuito quântico três vezes, portanto, use backend.run para enviar o Qiskit circuito e repita o código três vezes. Em um cenário do mundo real, talvez você queira 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]

Escreva 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)

Crie um objeto service com as suas informações do workspace Quantum.

from azure.quantum.cirq import AzureQuantumService

service = AzureQuantumService(
            resource_id = "", # add your resource ID
            location = "") # add your location

Escolha seu quantum target. Neste exemplo, é o targetsimulador IonQ.

Observação

Cirq os circuitos só podem usar IonQ ou Quantinuum targets.
```
target = service.get_target("ionq.simulator")
```
Crie uma sessão. Digamos que você queira executar o circuito quântico três vezes, portanto, use target.submit para enviar o Cirq circuito e repita o código três vezes. Em um cenário do mundo real, talvez você queira 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]
```

Comportamento-alvo

Cada provedor de hardware quântico define sua própria heurística para gerenciar melhor a priorização de trabalhos em 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, contanto que os trabalhos sejam enfileirados dentro de um minuto entre eles. Depois disso, seus trabalhos são aceitos e tratados com a lógica de fila e priorização padrão.

Comentários

Esta página foi útil?

Last updated on 2025-11-12