Eseguire la Q# migrazione del codice a QDK moderno

Azure Quantum Development Kit (Modern QDK), rilasciato a gennaio 2024, è il kit di sviluppo predefinito Q# usato in Visual Studio Code e nel portale di Azure Quantum. Per altre informazioni sulle nuove funzionalità e miglioramenti, vedere Novità di QDK moderno.

Se sono presenti programmi esistenti scritti per Microsoft Quantum Development Kit (QDK classico), è necessario modificare almeno alcuni elementi per le nuove API, processi e strumenti. Inoltre, sono stati apportati miglioramenti alla sintassi del linguaggio per semplificare e rendere più flessibile la Q# scrittura di codice.

Questo articolo illustra gli scenari più comuni per rendere operativo il codice nel nuovo QDK. S

Deprecazione di Visual Studio come piattaforma di sviluppo

QDK moderno rimuove il supporto per Visual Studio e le librerie quantistiche .NET associate. Se sono presenti progetti di Visual Studio esistenti, è consigliabile eseguirne la migrazione al QDK moderno usando le indicazioni in questo articolo. Per continuare a usare il QDK classico per i progetti, vedere Continuare a lavorare in QDK classico.

Importazione di moduli da un Q# file

Per i programmi Python che usano Q# file (*.qs) per importare Q# funzioni e operazioni come moduli, la sintassi di importazione è cambiata.

Nel QDK classico, per importare ed eseguire l'operazione Random() dal file source.qs:

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

Si userebbe la sintassi di importazione standard di Python:

from Sample import Random

print(Random.simulate())

con il requisito che source.qs e il programma Python fossero nella stessa cartella.

Per importare la stessa operazione con QDK moderno, si definisce un Q# progetto che consente di organizzare i file e le librerie di origine in modo più efficiente e logico. Per i passaggi dettagliati per definire un Q# progetto, vedere Uso dei Q# progetti.

Dopo aver configurato le cartelle del progetto e creato un semplice file manifesto, usare qsharp.init per puntare alla radice del progetto e qsharp.eval per accedere ai file di origine e importare lo spazio dei< nomi>.<>operation_name.

qsharp.init(project_root = '/MyProjectFolder')
print(qsharp.eval("Sample.Random()"))

Se l'operazione o la funzione che si sta importando accettano valori di input, è anche possibile passare questi valori:

print(qsharp.eval("Sample.Random(4)"))

Esecuzione del programma nel simulatore locale

La maggior parte dei simulatori in memoria del QDK classico è stata deprecata, lasciando il simulatore sparse come simulatore locale predefinito in VS Code e nel portale di Azure Quantum.

Simulatori deprecati:

• Simulatore di stato completo
• Simulatore di rumore
• Simulatore di traccia
• Simulatore di Toffoli

Per eseguire il simulatore sparse predefinito:

Scenario	Metodo
In un Q# programma in VS Code	Selezionare Esegui Q# file
In una cella del notebook Python	result=qsharp.eval("EntryPointOperation()") oppure result=qsharp.run("EntryPointOperation()", shots=##)
In una cella del %%qsharp notebook	EntryPointOperation()

Rilascio del qubit applicato

QDK moderno applica il requisito che i qubit si trovano nello stato di terra o |0⟩ prima di essere rilasciati alla fine dell'ambito. Ciò consente di evitare che i qubit vengano riutilizzati in uno stato imprevisto durante l'esecuzione di programmi su hardware quantistico.

Ad esempio, il codice seguente attiva un errore di runtime:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        return M(q);
}

e devono essere modificati per reimpostare il qubit prima di restituire la misura:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        let r = M(q);
        Reset(q);
        return r;
}

oppure usare un'operazione che reimposta il qubit come parte dell'esecuzione della misurazione:

open Microsoft.Quantum.Measurement;
operation MyOperation() : Result {
    use q = Qubit();
    X(q);
    return MResetZ(q);
}

Configurare il profilo di base

A differenza del simulatore locale, le destinazioni hardware di Azure Quantum non supportano ancora le funzionalità complete necessarie per eseguire tutti i Q# programmi. Se si invia un processo ad Azure Quantum, prima di compilare il programma è necessario impostare il profilo di destinazione per indicare Q# quali funzionalità supportano l'hardware di destinazione. Attualmente, solo i programmi conformi al profilo di base QIR possono essere inviati ad Azure Quantum. Si noti che per l'esecuzione del codice nel simulatore locale è possibile usare qualsiasi configurazione del profilo.

Visual Studio Code

VS Code visualizza la modalità profilo nella barra di stato nella parte inferiore per Q# i file, ovvero QIR: Base o Senza restrizioni. La modalità senza restrizioni è particolarmente utile per l'esecuzione del codice nel simulatore. Se si invia un processo ad Azure Quantum e viene visualizzato un avviso che indica che un programma non è impostato per il profilo di base, selezionare Senza restrizioni nella barra di stato e selezionare QIR: Base come profilo.

Jupyter Notebook e Python

Per impostare il profilo di base, usare la qsharp.init funzione :

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

Nota

• La qsharp.init funzione sostituisce il comando magic %azure.target-capability .
• Se si reimposta il profilo di destinazione, sarà necessario rieseguire le Q# celle o le importazioni prima della compilazione.

Compilazione di un Q# programma da inviare ad Azure Quantum

Con QDK moderno, il programma deve essere compilato prima di inviare il processo ad Azure Quantum.

Nota

Per scenari passo-passo per inviare processi ad Azure Quantum usando Q# programmi, programmi Python o Jupyter Notebook, vedere Inviare processi ad Azure Quantum.

Visual Studio Code

Q#i programmi in VS Code compilano automaticamente il programma quando si seleziona una destinazione del provider nell'area di lavoro e si seleziona Invia programma correnteQ#. In caso di errori del compilatore, è possibile eseguire il debug del file premendo F5. Per altre informazioni, vedere Inviare processi ad Azure Quantum.

Jupyter Notebook e Python

Per i programmi Jupyter Notebook e Python che usano la Workspace classe per connettersi ad Azure Quantum, è necessario compilare il programma e quindi inviarlo ad Azure Quantum con il processo submittal.

1. Eseguire il Q# codice importato o scritto in una %%qsharp cella.

2. Usare la qsharp.compile funzione , passando l'operazione o la Q# funzione da usare come punto di ingresso. Ad esempio, per questo Q# programma:

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

   passare l'operazione MyOperation() come segue:

   MyProgram = qsharp.compile("MyOperation()")
   

3. Il risultato MyProgram compilato viene quindi passato ad Azure Quantum con la target.submit funzione :

   job = target.submit(MyProgram, "job name", ...)
   

Interfaccia della riga di comando di Azure

È anche possibile usare l'interfaccia della riga di comando di Azure per connettere e inviare Python e Q# processi ad Azure Quantum. Per questo scenario, è necessario salvare il programma compilato come file di testo. Per la procedura dettagliata, vedere Inviare processi ad Azure Quantum.

Connessione ad Azure Quantum

Per Q# i programmi in VS Code, è possibile connettersi all'area di lavoro di Azure Quantum e inviare processi all'interno di VS Code.

Per i programmi Python e Jupyter Notebook, il metodo di connessione predefinito è la azure.quantum.Workspace classe , che sostituisce i comandi magic IQ#%azure deprecati e il qsharp.azure modulo. Per esempi di tutti questi comandi, vedere Inviare processi ad Azure Quantum.

Comando magic o API deprecato	Uso
%azure.connect qsharp.azure.connect()	wksp = azure.quantum.Workspace( resource_id="", location="")
%azure.target qsharp.azure.target()	target = wksp.get_targets("<target_name>")
%azure.execute qsharp.azure.execute()	job = target.submit(...) I/O non bloccante
%azure.submit qsharp.azure.submit()	job = target.submit(<QirInputData>, <jobName>, input_params={"count: <##>"})
%azure.jobs qsharp.azure.jobs()	wksp.list_jobs()
%azure.output qsharp.azure.output()	job.get_results()
%azure.status qsharp.azure.status()	job.details.status
%azure.quotas	wksp.get_quotas()

Altri comandi magic deprecati

Comando magic deprecato
%check_kata	Deprecato
%chemistry.broombridge	Deprecato
%chemistry.encode	Deprecato
%chemistry.fh.add_terms	Deprecato
%chemistry.fh.load	Deprecato
%chemistry.inputstate.load	Deprecato
%config	Deprecato
%debug	Deprecato
%experimental.build_info	Deprecato
%kata	Deprecato
%lsmagic	Deprecato
%lsopen	Deprecato
%noise_model	Deprecato
%package	Deprecato
%prestazioni	Deprecato
%project	Deprecato
%who	Deprecato
%workspace	Deprecato