Introduzione alle sessioni

Le sessioni sono una funzionalità chiave del calcolo quantistico ibrido che consente di raggruppare più processi di calcolo quantistico. Una sessione è un raggruppamento logico di uno o più processi inviati a un singolo target. Ogni sessione ha un ID univoco associato a ogni processo in tale sessione. Le sessioni sono utili quando si vogliono eseguire più processi di calcolo quantistico in sequenza ed eseguire codice classico tra processi quantistici.

Questo articolo illustra l'architettura delle sessioni nel calcolo quantistico ibrido e come creare una nuova sessione in Azure Quantum.

Prerequisiti

Per creare una sessione, sono necessari i prerequisiti seguenti:

Un account Azure con una sottoscrizione attiva. Se non si dispone di un account Azure, registrarsi gratuitamente e attivare una sottoscrizione pay-as-you-go.
Un'area Azure Quantum di lavoro. Per altre informazioni, vedere Creare un'area Azure Quantum di lavoro.
Ambiente Python in cui sono installati Python e Pip.
La versione più recente di Visual Studio Code (VS Code), con l'estensione QDK, l'estensione Python e l'estensione Jupyter installate.
La libreria qdkPython. Per inviare programmi Qiskit e Cirq, installare i componenti aggiuntivi azure, qiskit e cirq.
```
pip install --upgrade "qdk[azure,qiskit,cirq]" 
```

Che cos'è una sessione?

Nelle sessioni è possibile spostare la risorsa di calcolo client nel cloud per ridurre la latenza e la possibilità di eseguire il programma quantistico più volte con parametri diversi. È possibile raggruppare logicamente i processi in una sessione ed è possibile classificare in ordine di priorità i processi in tale sessione rispetto ai processi non sessione. Gli stati qubit non persistono tra le attività, ma le attività in una sessione hanno tempi di coda più brevi. I tempi di coda più brevi consentono di eseguire algoritmi complessi per organizzare e tenere traccia dei singoli processi di calcolo quantistico.

Le sessioni sono utili per gli algoritmi quantistici con parametri, in cui l'output di un processo di calcolo quantistico viene usato per definire i parametri di input per il processo di calcolo quantistico successivo. Gli esempi più comuni di questo tipo di algoritmo sono Variational Quantum Eigensolvers (VQE) e Quantum Approximate Optimization Algorithms (QAOA).

Hardware supportato

Le sessioni sono supportate in tutti i provider hardware di calcolo quantistico. In alcuni casi, i processi inviati all'interno di una sessione vengono priorizzati nella coda di target. Per altre informazioni, vedere Comportamento di destinazione.

Come creare una sessione

Per creare una sessione, seguire questa procedura:

Questo esempio illustra come creare una sessione con Q# codice inline in un Jupyter notebook in VS Code.

Nota

Le sessioni vengono gestite con Python, anche quando si esegue Q# codice inline.

In VS Codeaprire il menu Visualizza e scegliere Riquadro comandi.
Inserisci e seleziona Crea: Nuovo Jupyter Notebook.
In alto a destra VS Code , rileverà e visualizzerà la versione di Python e l'ambiente virtuale Python selezionato per il notebook. Se si dispone di più Python ambienti, potrebbe essere necessario selezionare un kernel usando il selettore di kernel in alto a destra. Se non è stato rilevato alcun ambiente, consultare Jupyter Notebook in VS Code per informazioni sull'installazione.

Nella prima cella del notebook eseguire il codice seguente:

from qdk.azure import Workspace

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

Aggiungere una nuova cella nel notebook e importare il qsharpPython pacchetto:
```
from qdk import qsharp
```
Scegli il quantum target. In questo esempio, target è il simulatore IonQ.
```
target = workspace.get_targets("ionq.simulator")
```
Selezionare le configurazioni del target profilo, Base, Adaptive_RIo Unrestricted.
```
qsharp.init(target_profile=qsharp.TargetProfile.Base)
```
Nota

Adaptive_RI target i lavori di profilo sono attualmente supportati su Quantinuum targets. Per altre informazioni, vedere Integrated Hybrid Quantum Computing (Calcolo quantistico ibrido integrato).

Scrivi il tuo Q# programma. Ad esempio, il programma seguente Q# genera un bit casuale. Per illustrare l'uso di argomenti di input, questo programma accetta un numero intero, ne una matrice di angoli, , anglecome input.

%%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;
}

Successivamente, si crea una sessione. Si supponga di voler eseguire GenerateRandomBit l'operazione tre volte, quindi si usa target.submit per inviare l'operazione Q# con i target dati e ripetere il codice tre volte, in uno scenario reale, è possibile inviare programmi diversi anziché lo stesso codice.
```
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 si passano argomenti come parametri al processo, gli argomenti vengono formattati nell'espressione Q# quando qsharp.compile viene chiamato. Ciò significa che è necessario formattare gli argomenti come oggetti Q#. In questo esempio, poiché le matrici in Python sono già stampate come [item0, item1, ...], gli argomenti di input corrispondono alla formattazione Q#. Per altre Python strutture di dati, potrebbe essere necessaria una gestione maggiore per ottenere i valori stringa inseriti in Q# in modo compatibile.
Dopo aver creato una sessione, è possibile usare workspace.list_session_jobs per recuperare un elenco di tutti i processi nella sessione. Per altre informazioni, vedere Come gestire le sessioni.

Importare moduli aggiuntivi da azure-quantum e qiskit.

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

Creare un oggetto provider con le informazioni della tua area di lavoro Quantum.

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

provider = AzureQuantumProvider(workspace)

Scrivere il circuito quantistico. Ad esempio, il circuito seguente genera un bit casuale.

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

Crea un'istanza back-end con il quantum preferito target. Imposta l'oggetto target sul simulatore IonQ.
```
backend = provider.get_backend("ionq.simulator")
```

Creare una sessione. Si supponga di voler eseguire il circuito quantistico tre volte, quindi si usa backend.run per inviare il Qiskit circuito e ripetere il codice tre volte. In uno scenario reale, è possibile inviare programmi diversi anziché lo stesso codice. È possibile usare workspace.list_session_jobs per recuperare un elenco di tutti i processi nella sessione. Per altre informazioni, vedere Come gestire le sessioni.

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]

Scrivere il circuito quantistico. Ad esempio, il circuito seguente genera un bit casuale.

from cirq import LineQubit, Circuit, H, CNOT, measure

q0 = LineQubit(0)
q1 = LineQubit(1)
circuit = Circuit(
    H(q0),
    CNOT(q0, q1),
    measure(q0, key='q0'),
    measure(q1, key='q1')
)

print(circuit)

Creare un oggetto service con le informazioni della tua area di lavoro Quantum.

from qdk.azure.cirq import AzureQuantumService

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

Scegli il quantum target. In questo esempio, target è il simulatore IonQ.

Nota

Cirq i circuiti possono usare solo IonQ o Quantinuum targets.
```
target = service.get_target("ionq.simulator")
```

Creare una sessione. Si supponga di voler eseguire il circuito quantistico tre volte, quindi si usa target.submit per inviare il Cirq circuito e ripetere il codice tre volte. In uno scenario reale, è possibile inviare programmi diversi anziché lo stesso codice. È possibile usare workspace.list_session_jobs per recuperare un elenco di tutti i lavori nella sessione. Per altre informazioni, vedere Come gestire le sessioni.

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 di destinazione

Ogni provider hardware quantistico definisce le proprie euristiche per gestire al meglio la definizione delle priorità dei processi all'interno di una sessione.

Quantinuum

Se si sceglie di inviare compiti all'interno di una sessione a un Quantinuum target, la sessione ha accesso esclusivo all'hardware, a condizione che i compiti vengano messi in coda a un minuto l'uno dall'altro. Successivamente, i tuoi lavori vengono accettati e gestiti con i metodi di accodamento e definizione delle priorità standard.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-02-25