Introdução às sessões

As sessões são um recurso fundamental da computação quântica híbrida que permitem 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 um ID exclusivo anexado 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 em 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 subscrição ativa. Se não tiver uma conta do Azure, registe-se gratuitamente e inscreva-se numa subscrição pré-paga.
Um Azure Quantum espaço de trabalho. Para obter mais informações, consulte Criar um espaço de Azure Quantum trabalho.
Um Python ambiente com Python e Pip instalados.
A qdkPython biblioteca. Se quiser usar Qiskit ou Cirq, precisa de instalar os extras azure e qiskit.
```
pip install --upgrade qdk
```
ou
```
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 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.

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. 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.

Como criar uma sessão

Para criar uma sessão, siga estes passos:

Este exemplo mostra como criar uma sessão com Q# código inline ao usar 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# .

Nota

As sessões são geridas com Python, mesmo quando o código em linha é executado Q#.

No VS Code, abra o menu Exibir e escolha Paleta de comandos.
Insira e selecione Criar: Novo Jupyter Notebook.
No canto superior direito, VS Code detetará 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 detetado, consulte Jupyter Notebooks in VS Code para obter informações de configuração.

Na primeira célula do bloco de notas, 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 bloco de anotações e importe o qsharpPython pacote:
```
from qdk import qsharp
```
Escolha o seu quantum target. Neste exemplo, o target é o simulador 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
```
Nota

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

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
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, 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

Quando você passa argumentos como parâmetros para o trabalho, os argumentos são formatados na Q# expressão quando qsharp.compile é chamado. Isso significa que você precisa formatar seus argumentos como Q# objetos. Neste exemplo, como as matrizes em Python já 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 manipulação para inserir os valores de cadeia de caracteres no Q# de forma compatível.
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.

Importe 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 provider objeto com as informações do espaço de trabalho do Quantum.

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

provider = AzureQuantumProvider(workspace)

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

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

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]

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)

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

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

Nota

Cirq circuitos só podem usar IonQ ou Quantinuum targets.
```
target = service.get_target("ionq.simulator")
```
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]
```

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 são aceitos e tratados com a lógica padrão de fila e priorização.

Feedback

Esta página foi útil?

Last updated on 2025-11-12