Condividi tramite

Introduzione alle sessioni

  • Articolo

Le sessioni sono una funzionalità chiave del calcolo quantistico ibrido che consente di raggruppare più processi di calcolo quantistico.

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

Prerequisiti

Per creare una sessione, sono necessari i prerequisiti seguenti:

  • Un account Azure con una sottoscrizione attiva. Se non si ha un account Azure, registrarsi gratuitamente e iscriversi per ottenere una sottoscrizione con pagamento in base al consumo.

  • Un'area di lavoro di Azure Quantum. Per altre informazioni, vedere Creare un'area di lavoro di Azure Quantum.

  • Un ambiente Python con Python e Pip installati.

  • Pacchetto di Azure Quantum azure-quantum . Se si vuole usare Qiskit o Cirq, è necessario installare il azure-quantum pacchetto con i tag [qiskit] o [cirq].

    pip install --upgrade azure-quantum[qiskit]

Che cos'è una sessione?

Una sessione è un raggruppamento logico di uno o più processi inviati a un singolo targetoggetto . Ogni sessione ha un ID univoco associato a ogni processo in tale sessione.

Nelle sessioni, la risorsa di calcolo client può essere spostata nel cloud, con conseguente minore latenza e la possibilità di ripetere l'esecuzione del circuito quantistico con parametri diversi. I processi possono essere raggruppati logicamente in una sessione e i processi in tale sessione possono essere classificati in ordine di priorità rispetto ai processi non sessione. Anche se gli stati del qubit non vengono mantenuti tra processi, una sessione consente tempi di coda più brevi per i processi e problemi di esecuzione più lunghi.

Le sessioni consentono di organizzare più processi di calcolo quantistico con la possibilità di eseguire codice classico tra processi quantistici. Sarà possibile eseguire algoritmi complessi per organizzare e tenere traccia dei singoli processi di calcolo quantistico.

Uno scenario utente chiave in cui è possibile combinare processi in una sessione è costituito da algoritmi quantistici con parametri in cui l'output di un processo di calcolo quantistico informa i parametri del 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 classificati in ordine di priorità nella coda di tale targetoggetto . Per altre informazioni, vedere Target Comportamento.

Come creare una sessione

Per creare una sessione, seguire questa procedura:

Questo esempio illustra come creare una sessione con Q# codice inline usando jupyter Notebook in Visual Studio Code. È anche possibile creare sessioni usando un programma Python che richiama un programma adiacente Q# .

Nota

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

  1. In VS Code, selezionare Visualizza > Riquadro comandi e selezionare Crea: Nuovo Jupyter Notebook.

  2. In alto a destra VS Code rileverà e visualizzerà la versione di Python e l'ambiente Python virtuale selezionato per il notebook. Se si dispone di più ambienti Python, potrebbe essere necessario selezionare un kernel usando la selezione kernel in alto a destra. Se non è stato rilevato alcun ambiente, vedere Jupyter Notebooks in VS Code per informazioni sull'installazione.

  3. Nella prima cella del notebook eseguire

    import azure.quantum

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

  4. Fare clic su + Codice per aggiungere una nuova cella nel notebook e importare qsharp Python SDK.

    import qsharp

  5. Selezionare il quantum target di propria scelta. In questo esempio si usa il simulatore IonQ come target.

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

  6. Selezionare le configurazioni del target profilo, Base, Adaptive_RIo Unrestricted.

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

    Nota

    Adaptive_RItarget i processi profilo sono attualmente supportati in Quantinuum targets. Per altre informazioni, vedere Integrated Hybrid Quantum Computing (Calcolo quantistico ibrido integrato).

  7. Scrivere il 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;
}

  8. 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, questi vengono formattati nell'espressione Q# quando si chiama qsharp.compile. Ciò significa che è necessario prestare attenzione a formattare gli argomenti come Q# oggetti. In questo esempio, poiché le matrici in Python sono già stampate come [item0, item1, ...], gli argomenti di input corrispondono alla Q# formattazione. Per altre strutture di dati Python potrebbe essere necessaria una gestione maggiore per ottenere i valori stringa inseriti in Q# in modo compatibile.

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

Comportamento Target

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 processi all'interno di una sessione a un Quantinuum target, la sessione avrà accesso esclusivo all'hardware, purché i processi vengano accodati entro un minuto l'uno dall'altro. Successivamente, i processi verranno accettati e gestiti con la logica standard di accodamento e definizione delle priorità.

Contenuto correlato