Introduzione ai programmi Q# e Visual Studio Code

  • Articolo

In questo articolo sono disponibili i passaggi per usare il codice VC per creare e inviare Q#, Jupyter Notebook o processi di calcolo quantistici 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 del QDK moderno in VS Code.

Caricare un programma di esempio Q#

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

  2. Aprire RandomNum.qs e digitare sample, quindi selezionare Esempio di bit casuale nell'elenco delle 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 passare, entrare e uscire dal codice. Per altre informazioni sul debug dei programmi Q#, vedere Test e debug.

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

Tracciare l'istogramma di frequenza

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

  1. Selezionare Visualizza -> Tavolozza comandi e digitare " istogramma" che dovrebbe visualizzare il file Q#: Eseguire il file e visualizzare l'opzione istogramma . È anche possibile fare clic su Istogram nell'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 colpi per eseguire il programma, ad esempio 100 colpi e premere INVIO. L'istogramma verrà visualizzato nella finestra istogramma Q#.

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

    Screenshot della finestra 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 ci sono due possibili risultati, 0 e 1 e la percentuale di ogni risultato è vicina al 50%.

    Screenshot della finestra istogramma Q# in Visual Studio Code.

Suggerimento

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

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 -> Tavolozza comandi e digitare Q#: Connettersi a un'area di lavoro Di Azure Quantum. Premere INVIO.

  2. Selezionare Account Di 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 la stringa di connessione corrispondente all'area di lavoro 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 Esplora aree di lavoro espandere Aree di lavoro quantistiche.

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

    Nota

    Se si verifica un problema di connessione ad Azure Quantum, viene visualizzata un'icona di avviso accanto al nome dell'area di lavoro. Passare il 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 Rigetti simulatore come target.

  6. Selezionare l'icona di riproduzione a destra del target nome per avviare l'invio del programma Q# corrente. Se si ottiene un popup, selezionare Modifica profilo QIR target e continua.

    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 colpi 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 cloud accanto al nome del processo per scaricare i risultati dall'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 a Jupyter Notebook nel server o notebook jupyter locale nel portale di Azure Quantum.

Prerequisiti

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

Eseguire e testare il programma nel simulatore locale

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

    Nota

    Se il kernel ipykernel Di 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:

    %%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 il shotsnumero 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]]

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

Creare 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