Come inviare programmi Q# con Visual Studio 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 in VS Code.

• Un'area di lavoro di Azure Quantum nella sottoscrizione di Azure. Per creare un'area di lavoro, vedere Creare un'area di lavoro di Azure Quantum.
• La versione più recente di Visual Studio Code o aprire VS Code sul Web.
• La versione più recente dell'estensione Azure Quantum Development Kit.

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.

   

Eseguire un programma Q#

1. Per testare l'esecuzione del programma in locale nel simulatore predefinito, fare clic su Esegui dall'elenco dei comandi accanto all'operazione del punto di ingresso 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 accanto all'operazione del punto di ingresso oppure premere F5. Usare i controlli di debug nella parte superiore per eseguire la routine, eseguire l'istruzione e uscire dal codice. Per altre informazioni sul debug di programmi Q#, vedere Test 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 possibile risultato e l'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 accanto all'operazione del punto di ingresso. Selezionare questa opzione per aprire la finestra istogramma Q#.

   

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.

   

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

   

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 accanto all'operazione del punto di ingresso.

   

2. Il circuito viene visualizzato nella finestra del circuito Q#. Il diagramma del circuito mostra un registro qubit 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.

   

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 stabilito la connessione, nel riquadro Esplora risorse espandere 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 sull'errore.

5. Selezionare rigetti.sim.qvm come .target

   

6. Selezionare l'icona di riproduzione a destra del target nome per iniziare a inviare il programma Q# corrente. Se si ottiene un popup, selezionare Cambia il profilo qir target e continuare.

   

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, in modo da visualizzare le durate e lo stato del processo.

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

    

Invio di processi di Jupyter Notebook ad Azure Quantum

Informazioni su come usare VS Code per eseguire, eseguire il debug e inviare un notebook jupyter 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 in VS Code.

• Un'area di lavoro di Azure Quantum nella sottoscrizione di Azure. Per creare un'area di lavoro, vedere Creare un'area di lavoro di Azure Quantum.

• Un ambiente Python con Python e Pip installati.

• VS Code con le estensioni Azure Quantum Development Kit, Python e Jupyter installate.

• I pacchetti , qsharp-widgetse azure-quantum di Azure Quantum qsharpe il ipykernel pacchetto.

  python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
  

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 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 Python di Jupyter non viene rilevato, VISUAL Studio Code chiederà 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)"))

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. Successivamente, usare 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

Dopo aver compilato il programma 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 nella portale di Azure.

1. In una nuova cella immettere 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()
   

   {'[0, 1, 1, 1]': 0.08,
    '[1, 1, 0, 0]': 0.1,
    '[0, 0, 1, 0]': 0.04,
    '[0, 1, 0, 0]': 0.05,
    '[1, 0, 1, 0]': 0.05,
    '[1, 0, 0, 0]': 0.07,
    '[0, 1, 0, 1]': 0.07,
    '[1, 0, 1, 1]': 0.07,
    '[0, 0, 0, 0]': 0.08,
    '[1, 1, 1, 0]': 0.05,
    '[0, 0, 0, 1]': 0.1,
    '[0, 0, 1, 1]': 0.04,
    '[0, 1, 1, 0]': 0.09,
    '[1, 0, 0, 1]': 0.04,
    '[1, 1, 1, 1]': 0.05,
    '[1, 1, 0, 1]': 0.02}
   

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
   

Dettagli aggiuntivi sul processo

Il azure.quantum pacchetto Python include metodi aggiuntivi per visualizzare dati di processo più dettagliati.

• job.get_results_histogram(): questo metodo restituisce un dizionario dei risultati e del conteggio degli scatti per ogni misura univoca. Ad esempio, i risultati per il processo precedente saranno

  print(job.get_results_histogram()) 
  

  {   
      '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
      '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
      '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
      '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
      '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
      '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
      '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
      '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
      '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
      '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
      '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
      '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
      '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
      '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
      '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
      '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
  }
  

• job.get_results_shots() : questo metodo restituisce un elenco di ogni risultato dello scatto. Ad esempio, i risultati per il processo precedente saranno

  print(job.get_results_shots()) 
  

  [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]
  

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 in VS Code.

• Un'area di lavoro di Azure Quantum nella sottoscrizione di Azure. Per creare un'area di lavoro, vedere Creare un'area di lavoro di Azure Quantum.
• Un ambiente Python con Python e Pip installati.
• VS Code con l'estensione Azure Quantum Development Kit e Python installata.
• Azure Quantum qsharp e azure-quantum i pacchetti.
• Interfaccia della riga di comando di Azure con l'estensione Azure Quantum più recente installata.

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 qualsiasi 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 nella directory /src nel progetto come Source.qs.

   
       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 cartella radice del progetto (con il file qsharp.json ), 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.

   Nota

   Poiché non è stato specificato alcuno spazio dei nomi in Source.qs, il compilatore usa il nome del file come spazio dei nomi predefinito - Source.RandomNBits(). Per altre informazioni, vedere Progetti e spazi dei nomi impliciti.

   qsharp.init(project_root = '../MyProjectRootFolder')
   print(qsharp.eval("Source.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("Source.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 Base profilo o Adpative_RI . Per altre informazioni, vedere Tipi di profilo in Azure Quantum.

1. Usare il init metodo per impostare il profilo:

   qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
   

   Nota

   Poiché si sta reinizializzando lo stato di qsharp, è necessario impostare di nuovo il project_root parametro in modo che il compilatore sappia dove trovare l'operazione RandomNBits . Questo potrebbe anche essere stato fatto nel passaggio 5 della procedura precedente.

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("Source.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 inviarlo usando un comando dell'interfaccia della riga di comando.