Calcolo quantistico interattivo: sessioni

  • Articolo

Questo articolo illustra l'architettura dell'elaborazione quantistica interattiva, nota anche come sessioni e come creare una nuova sessione.

In questo modello di calcolo quantistico ibrido, la risorsa di calcolo client può essere spostata nel cloud, causando una latenza inferiore 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à su processi non sessione. Sebbene gli stati qubit non siano persistenti tra processi, una sessione consente tempi di coda più brevi per i processi e problemi di esecuzione più lunghi.

Calcolo quantistico interattivo

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

  • Ambiente Python con Python e Pip installato.

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

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 i processi in una sessione è parametrizzato algoritmi quantistici 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, attualmente IonQ, Quantinuum e Rigetti. In alcuni casi, i processi inviati all'interno di una sessione vengono classificati in ordine di priorità nella coda di tale target. Per altre informazioni, vedere Comportamento di destinazione.

Introduzione alle sessioni

Le sessioni vengono gestite con Python e possono essere create per qualsiasi programma quantistico QIR, inclusi Q#, Qiskit e programmi Cirq.

In questo esempio viene illustrato come creare una sessione con Q# codice inline usando un 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 sono presenti più ambienti Python, potrebbe essere necessario selezionare un kernel usando il selettore kernel in alto a destra. Se non è stato rilevato alcun ambiente, vedere Jupyter Notebooks in VS Code per informazioni sulla configurazione.

  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 quantistico scelto target . In questo esempio si usa il simulatore IonQ come target.

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

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

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

  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 intero, n, e una matrice di angoli, come angleinput.

    %%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. Successivamente, si crea una sessione. Si supponga di voler eseguire GenerateRandomBit l'operazione tre volte, quindi si usa target.submit per inviare l'operazione con i target dati e ripetere il Q# 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, vengono formattati nell'espressione Q# quando si chiama qsharp.compile. Ciò significa che è necessario essere attenti 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 necessario più gestire per ottenere i valori stringa inseriti nell'oggetto 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.

Sessioni di monitoraggio

È possibile usare il pannello Gestione processi nell'area di lavoro Quantum per visualizzare tutti gli elementi inviati di primo livello, incluse sessioni e singoli processi che non sono associati a alcuna sessione.

  1. Selezionare il pannello Gestione processi nell'area di lavoro Quantum.
  2. Identificare i processi di tipo Sessione. In questa visualizzazione è possibile visualizzare l'ID univoco di una sessione in id colonna e monitorare il relativo stato. Gli stati di una sessione sono:
    • Attesa: i processi all'interno della sessione vengono eseguiti.
    • Esito positivo: la sessione è stata completata correttamente.
    • TimeOut: se non viene inviato alcun nuovo processo all'interno della sessione per 10 minuti, tale sessione viene interrotta. Per altre informazioni, vedere Timeout sessione.
    • Errore: se un processo all'interno di una sessione ha esito negativo, la sessione termina e segnala lo stato Non riuscito. Per altre informazioni, vedere Criteri di errore del processo all'interno delle sessioni.
  3. Fare clic sul nome di una sessione per altri dettagli.
  4. È possibile visualizzare l'elenco di Tutti i processi all'interno della sessione e monitorare lo stato.

Comportamento di destinazione

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

Quantinuum

Se si sceglie di inviare processi all'interno di una sessione a quantinuum target, la sessione avrà accesso esclusivo all'hardware purché i processi in coda entro un minuto dall'altro. In seguito, i processi verranno accettati e gestiti con la logica di accodamento e priorità standard.

Contenuti correlati