Esercizio - Iniziare a usare lo strumento di stima delle risorse di Azure Quantum

8 minuti

Nell'unità precedente si è appreso che Lo strumento di stima delle risorse di Azure Quantum accetta tre parametri di input principali: i parametri qubit fisici, lo schema QEC (Quantum Error Correction) e il budget degli errori.

A questo punto è possibile eseguire alcune operazioni con l'oggetto Resource Estimator. In questa unità si usa Lo strumento di stima delle risorse per stimare i requisiti delle risorse fisiche per un semplice programma quantistico.

Installare i pacchetti necessari

Per usare lo strumento di stima delle risorse, installare i pacchetti Python più recenti qsharpqsharp-widgets del kit di sviluppo di Azure Quantum (QDK).

python -m pip install --upgrade qsharp qsharp-widgets

Se non è già stata installata l'estensione QDK per Visual Studio Code (VS Code), vedere Installare l'estensione QDK.

Creare l'algoritmo quantistico in un notebook di Jupyter

Scriviamo l'algoritmo quantistico in un notebook Jupyter. Per creare un notebook jupyter con QDK in VS Code, seguire questa procedura:

Aprire VS Code.
Aprire il menu Visualizza e quindi scegliere Riquadro comandi. Viene visualizzata una casella di input.
Nella casella di input immettere e scegliere Crea: Nuovo notebook di Jupyter.
Nella prima cella del notebook importare il qsharp pacchetto e la EstimateDetails funzione :
```
import qsharp
from qsharp_widgets import EstimateDetails
```
Scegliere il pulsante + Codice per aggiungere una nuova cella.

Copiare il codice seguente RandomBit nella nuova cella:

%%qsharp
/// # Sample
/// Random Bit
///
/// # Description
/// This Q# program generates a random bit by setting a qubit in a superposition
/// of the computational basis states |0〉 and |1〉, and returning the measurement
/// result.

    operation RandomBit() : Result {
        // Qubits are only accessible for the duration of the scope where they
        // are allocated and are automatically released at the end of the scope.
        use qubit = Qubit();

        // Set the qubit in superposition by applying a Hadamard transformation.
        H(qubit);

        // Measure the qubit. There is a 50% probability of measuring either 
        // `Zero` or `One`.
        let result = M(qubit);

        // Reset the qubit so it can be safely released.
        Reset(qubit);
        return result;
    }

Stimare le risorse per l'algoritmo quantistico

Eseguire Resource Estimator per stimare le risorse fisiche necessarie per eseguire l'operazione RandomBit . Se non si specifica alcun parametro, lo strumento di stima delle risorse usa i valori di parametro predefiniti seguenti:

qubit_gate_ns_e3 per il modello qubit
surface_code per il codice di correzione degli errori
0.001 per il margine d'errore

Per eseguire Lo strumento di stima delle risorse, seguire questa procedura:

Aggiungere una nuova cella e copiare il codice seguente in tale cella:
```
result = qsharp.estimate("RandomBit()")

EstimateDetails(result)
```
La qsharp.estimate funzione crea un oggetto risultato che contiene informazioni dall'oggetto Resource Estimator. Si passa result alla funzione EstimateDetails, che visualizza un set di tabelle in menu a discesa che contengono l'output di Resource Estimator.
Espandere la prima tabella, denominata Stime delle risorse fisiche. Questa tabella mostra il runtime, le operazioni quantistiche affidabili al secondo e il numero di qubit necessari per eseguire l'algoritmo.

Stima delle risorse fisiche Valore

Runtime 2 microsecondi

rQOPS 3,00 milioni

Qubit fisici 300

L'operazione RandomBit richiede 300 qubit fisici e richiede due microsecondi per l'esecuzione.
Scegli di nuovo il menu a tendina Stime risorse fisiche per chiudere la tabella.

Stima delle risorse fisiche	Valore
Runtime	2 microsecondi
rQOPS	3,00 milioni
Qubit fisici	300

Per esaminare le altre tabelle, scegliere un elenco a discesa per espandere la tabella corrispondente. Ad esempio, scegliere il menu a discesa Parametri qubit logici. Questa tabella mostra che la distanza del codice è 5 e che sono presenti 50 qubit fisici per qubit logico.

Parametro qubit logico	Valore
Schema Correzione degli errori quantistici	`surface_code`
Distanza di codice	5
Qubit fisici	50
Durata ciclo logico	2 microsecondi
Frequenza di errore del qubit logico	3.00e-5
Prefactoring di incrocio	0.03
Soglia di correzione degli errori	0,01
Formula del tempo di ciclo logico	(4 * `twoQubitGateTime` + 2 * `oneQubitMeasurementTime`) * `codeDistance`
Formula dei qubit fisici	2 * `codeDistance` * `codeDistance`

Usare il campo jobParams per accedere a tutti i parametri di destinazione che è possibile passare al processo e per esaminare i valori predefiniti per i parametri non specificati. Creare una nuova cella e copiare il codice seguente in tale cella:
```
result['jobParams']
```

Eseguire la nuova cella ed esaminare l'output:

{'qecScheme': {'name': 'surface_code',
  'errorCorrectionThreshold': 0.01,
  'crossingPrefactor': 0.03,
  'distanceCoefficientPower': 0,
  'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
  'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance',
  'maxCodeDistance': 50},
 'errorBudget': 0.001,
 'qubitParams': {'instructionSet': 'GateBased',
  'name': 'qubit_gate_ns_e3',
  'oneQubitMeasurementTime': '100 ns',
  'oneQubitGateTime': '50 ns',
  'twoQubitGateTime': '50 ns',
  'tGateTime': '50 ns',
  'oneQubitMeasurementErrorRate': 0.001,
  'oneQubitGateErrorRate': 0.001,
  'twoQubitGateErrorRate': 0.001,
  'tGateErrorRate': 0.001,
  'idleErrorRate': 0.001},
 'constraints': {'maxDistillationRounds': 3},
 'estimateType': 'singlePoint'}

Per questo algoritmo, Lo strumento di stima delle risorse usa il qubit_gate_ns_e3 modello qubit, il surface_code codice di correzione degli errori e 0,001 per il budget degli errori. Questi sono i valori predefiniti per questi parametri perché non sono stati specificati i relativi valori quando è stato chiamato Resource Estimator.

Modificare i valori predefiniti e stimare nuovamente le risorse

Per eseguire Estimator con valori di parametro diversi dai valori predefiniti, specificare altri valori per i parametri quando si chiama Resource Estimator. Cambiamo il modello di qubit, lo schema QEC e il budget degli errori.

Modificare il modello qubit

Stimare il costo per eseguire lo stesso algoritmo in un computer Majorana. A tale scopo, passare il parametro qubitParams con il campo name impostato su qubit_maj_ns_e6 quando si chiama Resource Estimator.

In una nuova cella copiare ed eseguire il codice seguente:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})

EstimateDetails(result_maj)

Espandere gli elenchi a discesa nell'output per esplorare come i costi delle risorse differiscono per il computer Majorana rispetto al computer basato su gate.

Modificare lo schema QEC

Successivamente, stimare il costo per lo stesso algoritmo in una macchina Majorana con uno schema QEC Floquet. A tale scopo, passare il parametro qecScheme con il campo name impostato su floquet_code quando si chiama Resource Estimator.

In una nuova cella copiare ed eseguire il codice seguente:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})

EstimateDetails(result_maj)

Espandi i menu a discesa nell'output per esplorare come i costi delle risorse differiscono per lo schema QEC di Floquet rispetto allo schema di codice di superficie.

Modificare il margine di errore

Infine, stimare il costo per gli stessi parametri della stima precedente, ma aumentare il budget degli errori a 10%. A tale scopo, passare il errorBudget parametro con il valore impostato su 0.1 quando si chiama Resource Estimator.

In una nuova cella copiare ed eseguire il codice seguente:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})

EstimateDetails(result_maj)

Congratulazioni! È stato usato correttamente Resource Estimator per stimare le risorse fisiche necessarie per eseguire un algoritmo quantistico semplice. Sono stati personalizzati anche i parametri per vedere come influiscono sulle stime delle risorse.

Nell'unità successiva si stimano le risorse necessarie per un programma quantistico molto più complesso: algoritmo di Shor.

Commenti e suggerimenti

Questa pagina è stata utile?