Introduzione ai programmi Q# e a Visual Studio Code

  • Articolo

In questo articolo sono disponibili i passaggi per usare VC Code per creare e inviare Q#, Jupyter Notebook o processi di calcolo quantistico Python ad Azure Quantum usando VS Code.

Invio di processi Q# ad Azure Quantum

Informazioni su come usare VS Code per eseguire, eseguire il debug e inviare un programma Q# ad Azure Quantum.

Prerequisiti

Per informazioni dettagliate sull'installazione, vedere Installazione di QDK moderno in VS Code.

Caricare un programma di esempio Q#

  1. In VS Code selezionare File > nuovo file di testo e salvare il file come RandomNum.qs.

  2. Aprire RandomNum.qs e digitare sample, quindi selezionare Esempio di bit casuale nell'elenco di opzioni e salvare il file.

    Screenshot del file Q# in Visual Studio Code che mostra l'elenco di esempi di codice durante la scrittura dell'esempio di parola nel file.

Nota

È anche possibile aprire il proprio file Q#. Se si esegue un programma Q# precedente e si verificano errori, vedere Test e debug o Migrazione dei programmi al QDK moderno.

Eseguire un programma Q#

  1. Per testare l'esecuzione del programma in locale nel simulatore predefinito, fare clic su Esegui dall'elenco dei comandi seguenti @EntryPoint()oppure premere CTRL+F5. L'output verrà visualizzato nella console di debug.

  2. Per eseguire il debug del programma prima di inviarlo ad Azure Quantum, fare clic su Debug dall'elenco dei comandi seguenti @EntryPoint()o premere F5. Usare i controlli di debug nella parte superiore per eseguire un'istruzione all'interno e all'esterno del codice. Per altre informazioni sul debug di programmi Q#, vedere Test e debug.

    Screenshot del file Q# in Visual Studio Code che mostra dove trovare l'obiettivo del codice con i comandi di esecuzione e debug.

Visualizzare l'istogramma di frequenza

L'istogramma di frequenza rappresenta la distribuzione dei risultati ottenuti dall'esecuzione di un programma quantistico più volte o "scatti". Ogni barra nell'istogramma corrisponde a un risultato possibile e la sua altezza rappresenta il numero di volte in cui viene osservato il risultato. L'istogramma di frequenza consente di visualizzare la distribuzione delle probabilità di questi risultati.

  1. Selezionare Visualizza -> Riquadro comandi e digitare "istogramma" che dovrebbe visualizzare il file Q#: Esegui file e visualizzare l'opzione istogramma . È anche possibile fare clic sull'istogramma dall'elenco dei comandi seguenti @EntryPoint(). Selezionare questa opzione per aprire la finestra istogramma Q#.

    Screenshot del file Q# in Visual Studio Code che mostra dove trovare l'obiettivo del codice con il comando istogramma.

  2. Immettere un numero di scatti per eseguire il programma, ad esempio 100 scatti e premere INVIO. L'istogramma verrà visualizzato nella finestra dell'istogramma Q#.

  3. Fare clic sull'icona delle impostazioni in alto a sinistra per visualizzare le opzioni.

    Screenshot della finestra dell'istogramma Q# in Visual Studio Code che mostra come visualizzare le impostazioni.

  4. Fare clic su una barra per visualizzare la percentuale di tale risultato. In questo caso esistono due possibili risultati, 0 e 1 e la percentuale di ogni risultato è vicina al 50%.

    Screenshot della finestra dell'istogramma Q# in Visual Studio Code.

Suggerimento

È possibile ingrandire l'istogramma usando la rotellina del mouse o un movimento del trackpad. Quando si esegue lo zoom avanti, è possibile eseguire la panoramica del grafico premendo 'ALT' durante lo scorrimento.

Visualizzare il circuito quantistico

I diagrammi di circuito quantistico sono una rappresentazione visiva delle operazioni quantistiche. Mostrano il flusso dei qubit attraverso il programma quantistico, inclusi i cancelli e le misurazioni applicati. Per altre informazioni, vedere Diagrammi di circuiti quantistici in Visual Studio Code.

  1. Selezionare Visualizza -> Riquadro comandi e digitare "circuito" che dovrebbe visualizzare l'opzione Q#: Mostra circuito . È anche possibile fare clic su Circuito dall'elenco dei comandi seguenti @EntryPoint().

    Screenshot del file Q# in Visual Studio Code che mostra dove trovare il comando del circuito code lens.

  2. Il circuito viene visualizzato nella finestra del circuito Q#. Il diagramma del circuito mostra un registro qubit che viene inizializzato nello stato |0⟩. Quindi, un cancello Hadamard, H, viene applicato al qubit, seguito da un'operazione di misurazione, rappresentata da un simbolo di contatore. Per altre informazioni, vedere Convenzioni dei circuiti quantistici.

    Screenshot della finestra del circuito Q# che mostra il diagramma del circuito risultante per l'operazione di bit casuale.

Connettersi ad Azure Quantum e inviare il processo

È possibile connettersi e inviare processi direttamente da VS Code. Per questo esempio si invierà un processo al simulatore Rigetti.

  1. Selezionare Visualizza -> Riquadro comandi e digitare Q#: Connettersi a un'area di lavoro di Azure Quantum. Premere INVIO.

  2. Selezionare Account Azure e seguire le istruzioni per connettersi alla directory, alla sottoscrizione e all'area di lavoro preferita.

    Nota

    Se si dispone di un stringa di connessione, è possibile selezionare Stringa di connessione e incollare il stringa di connessione corrispondente all'area di lavoro di Azure Quantum. Per altre informazioni, vedere Connettersi a un'area di lavoro Quantum usando un stringa di connessione.

  3. Dopo aver eseguito la connessione, nel riquadro Explorer espandere Quantum Workspaces (Aree di lavoro quantistiche).

  4. Espandere l'area di lavoro ed espandere il provider Rigetti .

    Nota

    Se si verifica un problema di connessione ad Azure Quantum, accanto al nome dell'area di lavoro viene visualizzata un'icona di avviso. Passare il puntatore del mouse sul nome dell'area di lavoro per visualizzare le informazioni sugli errori.

  5. Selezionare rigetti.sim.qvm come .target

    Screenshot di Visual Studio Code che mostra come selezionare Il simulatore Rigetti come target.

  6. Selezionare l'icona di riproduzione a destra del target nome per iniziare a inviare il programma Q# corrente. Se viene visualizzata una finestra popup, selezionare Cambia il profilo QIR target e continuare.

    Screenshot di Visual Studio Code che mostra come eseguire il simulatore Rigetti come target.

  7. Aggiungere un nome per identificare il processo.

  8. Aggiungere il numero di scatti o il numero di volte in cui viene eseguito il programma.

  9. Premere INVIO per inviare il processo. Lo stato del processo verrà visualizzato nella parte inferiore della schermata.

  10. Espandere Processi e passare il puntatore del mouse sul processo, che visualizza i tempi e lo stato del processo.

  11. Per visualizzare i risultati, selezionare l'icona del cloud accanto al nome del processo per scaricare i risultati dalla risorsa di archiviazione dell'area di lavoro e visualizzarla in VS Code.

    Screenshot di Visual Studio Code che mostra come scaricare e visualizzare i risultati del processo quantistico.

Invio di processi di Jupyter Notebook ad Azure Quantum

Informazioni su come usare VS Code per eseguire, eseguire il debug e inviare un Jupyter Notebook Q# ad Azure Quantum. I passaggi descritti in questo articolo si applicano anche ai notebook di Jupyter nel server o nei notebook Jupyter locali nel portale di Azure Quantum.

Prerequisiti

Per informazioni dettagliate sull'installazione, vedere Installazione di QDK moderno in VS Code.

Eseguire e testare il programma nel simulatore locale

  1. In VS Code selezionare Visualizza > riquadro comandi e selezionare Create: 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 il codice Python seguente per importare i moduli necessari:

    import qsharp
import azure.quantum
    • Il qsharp modulo attiva il %%qsharp comando magic che consente di immettere il codice Q# direttamente in una cella.
    • Il azure-quantum modulo fornisce la connettività all'area di lavoro di Azure Quantum.

    Nota

    Se il kernel ipykernel Jupyter Python non viene rilevato, VS Code richiederà di installarlo.

  4. Aggiungere un'altra cella e immettere questo codice Q# che restituisce un numero specificato dall'utente di bit casuali:

    Nota

    Si noti che non appena si digita il comando %%qsharpmagic , la cella del notebook cambia il tipo da Python a Q#.

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  5. Per testare l'operazione, è possibile usare il eval metodo , che può chiamare qualsiasi operazione Q# definita in precedenza nel notebook:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Per eseguire il programma nel simulatore locale, usare il run metodo . Specificare , shotso il numero di volte in cui eseguire il programma e il simulatore restituisce i risultati come elenco Python.

    qsharp.run("RandomNBits(4)", shots=10)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Visualizzare il circuito quantistico

È possibile visualizzare i circuiti quantistici usando il qsharp-widgets pacchetto . Questo pacchetto fornisce un widget che esegue il rendering di un diagramma di circuito quantistico come immagine SVG. Per altre informazioni, vedere Diagrammi di circuito quantistici con Jupyter Notebook.

Aggiungere il codice seguente a una nuova cella per visualizzare il circuito:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Screenshot di Jupyter Notebook che mostra come visualizzare il circuito per un'operazione Q#.

Per altre informazioni, vedere Convenzioni dei circuiti quantistici.

Compilare il processo usando il profilo di base

Quando si eseguono programmi nel simulatore quantistico locale, è possibile inviare qualsiasi tipo di programma Q#. Tuttavia, l'hardware targets di Azure Quantum non supporta ancora le funzionalità complete necessarie per eseguire tutti i programmi Q#. Per compilare e inviare programmi Q# ad Azure Quantum, è necessario impostare il target profilo per indicare a Q# quali funzionalità supportano l'hardware target . Attualmente, ovvero il profilo di base. Per altre informazioni, vedere Tipi di profilo in Azure Quantum.

Per reinizializzare l'interprete Q# e compilare il programma con il profilo di base:

  1. Usare il init metodo per impostare il profilo:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Poiché l'interprete è stato reinizializzato, è necessario eseguire di nuovo il codice con il nuovo profilo:

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. Usare quindi il compile metodo per specificare l'operazione o la funzione che rappresenta il punto di ingresso del programma. In questo modo il codice viene compilato in formato QIR, che può quindi essere inviato a qualsiasi hardware quantistico:

    MyProgram = qsharp.compile("RandomNBits(4)")

Connettersi ad Azure Quantum e inviare il processo

Ora che il programma è stato compilato nel formato corretto, creare un azure.quantum.Workspace oggetto per connettersi ad Azure Quantum. Per connettersi si userà l'ID risorsa dell'area di lavoro di Azure Quantum. L'ID risorsa e il percorso possono essere copiati dalla pagina di panoramica dell'area di lavoro nel portale di Azure.

  1. In una nuova cella compilare l'ID risorsa e la posizione dall'area di lavoro di Azure Quantum:

    MyWorkspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Usare il get_targets metodo per visualizzare l'hardware targets disponibile nell'area di lavoro:

    MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets

  3. Selezionare :rigetti.sim.qvmtarget

    MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")

  4. Infine, usare il metodo per inviare il submit programma con i relativi parametri e visualizzare i risultati:

    job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
job.get_results()

    {'Histogram': ['[0, 0, 0, 0]',
  0.3,
  '[1, 0, 0, 0]',
  0.1,
  '[1, 1, 1, 1]',
  0.3,
  '[0, 1, 1, 1]',
  0.3]}

  5. Tutte le proprietà del processo sono accessibili in job.details, ad esempio:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
Job name: MyQuantumJob
Job status: Succeeded
Job ID: 0150202e-9638-11ee-be2f-b16153380354

Invio di Python con processi Q# ad Azure Quantum

Informazioni su come usare VS Code per scrivere un programma Python che chiama le operazioni Q#, connettersi ad Azure usando i comandi Python o l'interfaccia della riga di comando di Azure e inviare il processo.

Prerequisiti

Per informazioni dettagliate sull'installazione, vedere Installazione di QDK moderno in VS Code.

Create e importare le operazioni Q#

Con il qsharp pacchetto è possibile archiviare le funzioni e le operazioni nei file Q# e creare progetti Q# che consentono di chiamare uno di essi dal codice Python. Ciò è particolarmente utile quando è necessario avviare un programma che accetta parametri di input.

  1. Seguire la procedura per creare un progetto Q#.

  2. Aprire un nuovo file di testo, aggiungere il codice Q# seguente che restituisce un numero specificato dall'utente di bit casuali e salvare il file nel progetto come source.qs.

    Nota

    Si noti che questo codice Q# non ha una @EntryPoint funzione come un programma Q# (vedere Invio di processi Q# ad Azure Quantum), ma richiede uno spazio dei nomi, a differenza di una Jupyter Notebook (vedere Invio di processi Jupyter Notebook ad Azure Quantum).

    namespace Sample {

  operation Random() : Result {
        use q = Qubit();
        H(q);
        let result = M(q);
        Reset(q);
        return result
  }

  operation RandomNBits(N: Int): Result[] {
        mutable results = [];
        for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
        }
        return results
  }
}

  3. Nella stessa cartella aprire un altro file e salvarlo come randomNum.py.

  4. Aggiungere il codice seguente per importare i qsharp moduli e azure.quantum .

    import qsharp
import azure.quantum

  5. Aggiungere quindi il codice per definire la cartella radice del progetto Q# ed eseguire il test dell'operazione target nel simulatore locale. L'operazione viene chiamata dallo <spazio dei nomi> .<operation_name( )>, e in questo caso si passa il numero di bit casuali da restituire.

    qsharp.init(project_root = '/MyProjectRootFolder')
print(qsharp.eval("Sample.RandomNBits(4)"))

    [Zero, One, One, Zero]

  6. È anche possibile testare l'operazione con il run metodo , che passa un parametro aggiuntivo shots e restituisce i risultati in un elenco Python. In randomNum.pysostituire l'istruzione print precedente con quanto segue:

    result = qsharp.run("Sample.RandomNBits(4)", shots=10)
for x in result:
    print(x)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Compilare il processo usando il profilo di base

Quando si eseguono programmi nel simulatore quantistico locale, è possibile inviare qualsiasi tipo di programma Q#. Tuttavia, l'hardware targets di Azure Quantum non supporta ancora le funzionalità complete necessarie per eseguire tutti i programmi Q#. Per compilare e inviare programmi Q# ad Azure Quantum, è necessario impostare il target profilo per indicare a Q# quali funzionalità supportano l'hardware target . Attualmente, ovvero il profilo di base. Per altre informazioni, vedere Tipi di profilo in Azure Quantum.

Nota

Per i programmi Q# solo in VS Code, VS Code imposta automaticamente il profilo di base.

  1. Usare il init metodo per impostare il profilo:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Usare quindi il compile metodo per specificare l'operazione o la funzione che rappresenta il punto di ingresso del programma. Il programma compilato può quindi essere inviato a qualsiasi hardware quantistico:

    MyProgram = qsharp.compile("Sample.RandomNBits(4)")

Connettersi ad Azure Quantum e inviare il processo

È possibile connettersi ad Azure Quantum e inviare il processo usando un oggetto creato da Workspace Python oppure connettersi e inviare il processo usando l'interfaccia della riga di comando di Azure. Per usare l'interfaccia della riga di comando di Azure è necessario salvare il programma compilato come file di testo e inviare tale file usando un comando dell'interfaccia della riga di comando.

Ora che il programma è stato compilato nel formato corretto, creare un azure.quantum.Workspace oggetto per connettersi ad Azure Quantum. Per connettersi si userà l'ID risorsa dell'area di lavoro di Azure Quantum. L'ID risorsa e il percorso possono essere copiati dalla pagina di panoramica dell'area di lavoro nel portale di Azure.

  1. Aggiungere il codice seguente a randomNum.py, specificando l'ID risorsa e la posizione dall'area di lavoro di Azure Quantum:

    workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Usare il get_targets metodo per visualizzare l'hardware targets disponibile nell'area di lavoro:

    MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)

  3. Selezionare :rigetti.sim.qvmtarget

    MyTarget = workspace.get_targets("rigetti.sim.qvm")

  4. Infine, usare il metodo per inviare il submit programma con i relativi parametri. I risultati del processo vengono restituiti come dizionario Python.

    job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)

  5. Per estrarre solo i valori e visualizzarli:

    resultList = results.get("Histogram")
for x in resultList:
    print(x)

    [0, 0, 0, 0]
0.3
[1, 0, 0, 0]
0.1
[1, 1, 1, 1]
0.3
[0, 1, 1, 1]
0.3

  6. Tutte le proprietà del processo sono accessibili in job.details, ad esempio:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

Passaggi successivi