Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Informazioni su come usare Visual Studio Code per creare e inviare programmi Q# a hardware quantistico reale. È possibile inviare processi di calcolo quantistico ad Azure Quantum come programma Q# autonomo, combinare Q# con Python in un progetto Q# ed eseguire jupyter Notebook.
Invio di job 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 Configurare l'estensione QDK.
- 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#
In VS Code selezionare File > nuovo file di testo e salvare il file come RandomNum.qs.
Aprire RandomNum.qs e digitare
sample
, quindi selezionare Esempio di bit casuale nell'elenco di opzioni e salvare il file.
Nota
È anche possibile aprire il proprio file Q#. Se si esegue un programma Q# precedente e si verificano errori, vedere Test e debug.
Eseguire un programma Q#
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.
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 passare sopra, entrare ed 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.
Selezionare Visualizza -> Tavolozza comandi e digitare "istogramma", che dovrebbe visualizzare l'opzione Q#: Esegui file e mostra 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#.
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#.
Fare clic sull'icona delle impostazioni in alto a sinistra per visualizzare le opzioni.
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%.
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.
Selezionare Visualizza -> Palette 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.
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.
Collegarsi ad Azure Quantum e inviare l'attività
È possibile connettersi e inviare processi direttamente da VS Code. Per questo esempio, invii un lavoro al simulatore Rigetti.
Seleziona Visualizza -> Palette dei comandi e digita Q#: Connetti a un'area di lavoro di Azure Quantum. Premere Invio.
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.
Dopo aver stabilito la connessione, nel riquadro di esplorazione, espandere Aree di lavoro quantistiche.
Espandi l'area di lavoro ed espandi 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.
Selezionare rigetti.sim.qvm come target.
Selezionare l'icona di riproduzione a destra del nome target per iniziare a sottoporre il programma Q# corrente. Se si ottiene un popup, selezionare Cambia il profilo qir target e continuare.
Aggiungere un nome per identificare il lavoro.
Aggiungere il numero di scatti o il numero di volte in cui viene eseguito il programma.
Premere INVIO per inviare l'operazione. Lo stato del lavoro verrà visualizzato nella parte inferiore della schermata.
Espandere Attività e passare il puntatore del mouse sull'attività, per visualizzare le durate e lo stato dell'attività.
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 dei lavori di Jupyter Notebooks 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 Jupyter sul vostro server locale o nel portale Azure Quantum.
Prerequisiti
Per informazioni dettagliate sull'installazione, vedere Configurare l'estensione QDK.
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 di Azure Quantum
qsharp
,qsharp-widgets
, eazure-quantum
, e il pacchettoipykernel
.python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
Eseguire e testare il programma nel simulatore locale
In VS Code, selezionare Visualizza > Riquadro comandi e selezionare Crea: Nuovo Jupyter Notebook.
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.
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.- Il
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
%%qsharp
magic , 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(); results += [r]; } return results }
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]
Per eseguire il programma nel simulatore locale, usare il
run
metodo . Specifica ilshots
, ovvero quante volte eseguire il programma, e il simulatore restituisce i risultati come una lista 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 l'operazione usando il profilo 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, questo è 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:
Usare il
init
metodo per impostare il profilo:qsharp.init(target_profile=qsharp.TargetProfile.Base)
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(); results += [r]; } return results }
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)")
Collegarsi ad Azure Quantum e inviare l'attività
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 nel portale di Azure.
In una nuova cella, inserisci l'ID risorsa e la posizione della tua area di lavoro di Azure Quantum.
MyWorkspace = azure.quantum.Workspace( resource_id = "MyResourceID", location = "MyLocation" )
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
Selezionare :
rigetti.sim.qvm
targetMyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
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}
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 sulla posizione lavorativa
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 sarannoprint(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 sarannoprint(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 processi Python con Q# ad Azure Quantum
Scopri come usare VS Code per scrivere un programma Python che chiama le operazioni Q#, connetterti ad Azure usando i comandi Python o il CLI di Azure e inviare l'attività.
Prerequisiti
Per informazioni dettagliate sull'installazione, vedere Configurare l'estensione QDK.
- 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.
- I pacchetti di Azure Quantum
qsharp
eazure-quantum
. - 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.
Seguire la procedura per creare un progetto Q#.
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(); results += [r]; } return results }
Nella cartella radice del progetto (con il file qsharp.json ), aprire un altro file e salvarlo come
randomNum.py
.Aggiungere il codice seguente per importare i
qsharp
moduli eazure.quantum
.import qsharp import azure.quantum
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 da <namespace>.<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]
È anche possibile testare l'operazione con il
run
metodo , che passa un parametro aggiuntivoshots
e restituisce i risultati in un elenco Python. InrandomNum.py
, sostituire 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 l'operazione usando il profilo 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, si tratta del profilo Base
o del profilo Adpative_RI
. Per altre informazioni, vedere Tipi di profilo in Azure Quantum.
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'operazioneRandomNBits
. Questo potrebbe anche essere stato fatto nel passaggio 5 della procedura precedente.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)")
Collegarsi ad Azure Quantum e inviare l'attività
È 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.
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 nel portale di Azure.
Aggiungere il codice seguente a
randomNum.py
, inserendo l'ID risorsa e la posizione dall'area di lavoro di Azure Quantum:workspace = azure.quantum.Workspace( resource_id = "MyResourceID", location = "MyLocation" )
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)
Selezionare :
rigetti.sim.qvm
targetMyTarget = workspace.get_targets("rigetti.sim.qvm")
Infine, usa il metodo
submit
per inviare il programma con i relativi parametri. I risultati del lavoro vengono restituiti come dizionario Python.job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100) results = job.get_results() print("\nResults: ", results)
Per estrarre solo i valori e visualizzarli:
for x in results: 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
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
Dettagli aggiuntivi sulla posizione lavorativa
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 sarannoresults = job.get_results_histogram() for x in results.items(): print(x)
{ '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30}, '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10}, '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30}, '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30} }
job.get_results_shots()
: questo metodo restituisce un elenco di ogni risultato dello scatto. Ad esempio, i risultati per il processo precedente sarannoprint(job.get_results_shots())
[ [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]