Condividi tramite

Personalizzare i target parametri dello strumento di stima delle risorse

Questo articolo illustra come personalizzare i target parametri di Azure Quantum Resource Estimator in modo che corrispondano alle caratteristiche del computer di destinazione. Lo strumento di stima delle risorse usa questi parametri per stimare le risorse necessarie per eseguire un algoritmo quantistico in un computer quantistico.

Nota

Se si verificano problemi quando si lavora con Lo strumento di stima delle risorse, vedere la pagina Risoluzione dei problemi.

Prerequisiti

Parametri di destinazione

Lo strumento di stima delle risorse calcola la stima delle risorse, ad esempio il numero di qubit e il tempo di esecuzione, che sarebbe necessario implementare un determinato algoritmo quantistico in un computer quantistico con una determinata tecnologia qubit e un set fisso di scelte architetturali.

Lo strumento di stima delle risorse accetta un set di input, con valori predefiniti per iniziare facilmente:

  • Modello di qubit fisico, che definisce le proprietà dei qubit fisici sottostanti.
  • Schema QEC (Quantum Error Correction), che è lo schema di correzione degli errori quantistici presunto.
  • Un budget di errore, ovvero l'errore complessivo consentito, definito come numero di volte in cui il programma può avere esito negativo.
  • Vincoli a livello di componente, ovvero il numero di cicli logici e il numero di copie T della fabbrica.
  • Unità di distillazione per specificare algoritmi di distillazione della fabbrica T.
  • Stima della frontiera Pareto per effettuare più valutazioni per il numero di qubit e il tempo di esecuzione dello stesso algoritmo.

Suggerimento

Se si conoscono già alcune stime pre-calcolate per un'operazione, è possibile incorporarle per ottimizzare l'esecuzione dello strumento di stima delle risorse. Per altre informazioni, vedere Come usare stime note con Lo strumento di stima delle risorse.

Parametri qubit fisici

Quando lo strumento di stima delle risorse modella i presupposti del qubit fisico, usa due diversi set di istruzioni fisiche per operare sui qubit. Il set di istruzioni fisiche può essere basato su porte logiche o su Majorana. Un set di istruzioni basato su gate fornisce la misurazione di qubit singolo, le porte a qubit singolo (incluse le porte T) e le porte a due qubit. Un set di istruzioni Majorana fornisce un gate T fisico, una misura a qubit singolo e operazioni di misurazione congiunta a due qubit.

È possibile scegliere tra sei parametri qubit predefiniti, quattro dei quali hanno set di istruzioni basati su gate e due con un set di istruzioni Majorana. Questi modelli di qubit coprono una serie di tempi operativi e percentuali di errore, consentendo un'esplorazione sufficiente dei costi delle risorse necessari per abilitare applicazioni quantistice pratiche.

Parametro Qubit Classe API Python Descrizione
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 I tempi e le fidelità delle operazioni possono corrispondere alle versioni future dei qubit transconduttori o dei qubit di rotazione, che in genere hanno tempi operativi nel regime nanosecondo. Per questi qubit, si presuppone che le operazioni di porta e misurazione prendano rispettivamente 50 ns e 100 ns. Si presuppone che le percentuali di errore di gate a singolo qubit e a due qubit siano $10^{-3}$ come realistico target, e $10^{-4}$ come ottimistico target per un sistema con scalabilità.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 I tempi e le fidelità delle operazioni possono corrispondere alle versioni future dei qubit in base agli ioni, che in genere hanno tempi di operazioni nel regime di microsecondo. In base ai presupposti tipici per i qubit ionici, si assume che le operazioni di gate e di misurazione richiedano 100 μs. La frequenza di errore per i cancelli clifford a qubit singolo è $10^{-3}$ come realistica target e $10^{-4}$ come ottimistica target, mentre la frequenza di errore per le porte a qubit singolo non Clifford (T gate) è $10^{-6}$. Per i gate a due qubit, il tasso di errore è $10^{-3}$ come realistico target e $10^{-4}$ come ottimistico target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 I tempi e le fidelità delle operazioni possono corrispondere alle versioni future migliorate dei qubit Majorana. Per questi qubit, si presuppone che le operazioni di porta e di misurazione richiedano 100 ns. Per tenere conto della protezione topologica nell'hardware, si presuppone che i tassi di errore di misurazione congiunta a singolo qubit e a due qubit (tassi di errore Clifford) siano $10^{{-4}}$ come scenario realistico e $10^{target}$ come scenario ottimistico. Le operazioni non Clifford in questa architettura non hanno protezione topologica, la frequenza di errore per i cancelli T fisici non Clifford è del 5%.

Nota

A meno che non si specifichi un valore diverso, il valore predefinito per il modello qubit è "qubit_gate_ns_e3".

Parametri per qubit predefiniti

Per riferimento, i parametri qubit predefiniti completi sono i seguenti:

{
    "qubitParams": {
        "name": "qubit_gate_ns_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-3
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_ns_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-4
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e4",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "twoQubitJointMeasurementErrorRate": 1e-4,
        "tGateErrorRate": 0.05
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e6",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-6,
        "twoQubitJointMeasurementErrorRate": 1e-6,
        "tGateErrorRate": 0.01
    }
}

Trasmettere parametri predefiniti dei qubit

Esistono due modi per specificare parametri qubit predefiniti a livello di codice. Un modo consiste nel selezionare il nome del modello qubit per la qubitParams classe quando si esegue qsharp.estimate. Ad esempio, per selezionare il "qubit_maj_ns_e6" parametro qubit, scrivere il codice seguente:

from qdk import qsharp

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

Un altro modo consiste nel passare i parametri qubit alla EstimatorParams classe usando QubitParams. Ad esempio, per selezionare il MAJ_NS_E6 parametro qubit, scrivere il codice seguente:

from qdk import qsharp
from qdk.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E6 # qubit_maj_ns_e6 qubit parameter

qsharp.estimate("RunProgram()", params=params)

Personalizzare i parametri qubit predefiniti

È possibile personalizzare i parametri qubit predefiniti specificando il nome e quindi aggiornando uno degli altri valori. Ad esempio, per ridurre il tasso di errore delle misurazioni comuni a due qubit in qubit_maj_ns_e4, scrivere il codice seguente:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

In alternativa, è possibile passare le istruzioni sotto forma di elenco.

from qsharp.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parametri dei qubit per qubit basati su porte

Identificatore Python Tipo di dati Descrizione
name stringa Nome del modello qubit
instruction_set basato su gate Tecnologia qubit sottostante
one_qubit_measurement_time stringa temporale Il tempo di operazione per la misurazione di singolo qubit ($t_{\rm meas}$) in ns
one_qubit_gate_time stringa temporale Tempo dell'operazione per il gate a qubit singolo ($t_{\rm gate}$) in ns
two_qubit_gate_time stringa temporale Tempo di operazione per la porta a due qubit in ns
t_gate_time stringa temporale Tempo operativo per un singolo qubit del gate non-Clifford in nanosecondi
one_qubit_measurement_error_rate galleggiante Frequenza di errore per la misurazione a qubit singolo
one_qubit_gate_error_rate galleggiante Frequenza di errore per il gate Clifford a qubit singolo ($p$)
two_qubit_gate_error_rate galleggiante Frequenza di errore per il gate Clifford a due qubit
t_gate_error_rate galleggiante Frequenza di errore per preparare lo stato non-Clifford di un singolo qubit ($p_T$)
idle_error_rate galleggiante Frequenza degli errori corrispondente all'inattività

Il codice seguente illustra come specificare parametri qubit personalizzati per un set di istruzioni basato su gate:

from qdk.estimator import EstimatorParams, QubitParams

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "gate_based"
params.qubit_params.t_gate_error_rate = 0.03
params.qubit_params.t_gate_time = "10 ns"
params.qubit_params.idle_error_rate = 0.02

Nota

Il valore predefinito per two_qubit_gate_time e t_gate_time è one_qubit_gate_time, il valore predefinito per two_qubit_gate_error_rate e t_gate_error_rate è one_qubit_gate_error_ratee il valore predefinito per idle_error_rate è one_qubit_measurement_error_rate.

Parametri dei qubit di Majorana

Identificatore Python Tipo di dati Descrizione
name stringa Nome del modello qubit
instruction_set majorana Tecnologia qubit sottostante
one_qubit_measurement_time stringa temporale Il tempo di operazione per la misurazione di singolo qubit ($t_{\rm meas}$) in ns
two-qubit_joint_measurement_time stringa temporale Tempo di operazione per la misurazione di due qubit in ns
t_gate_time stringa temporale Tempo operativo per un singolo qubit del gate non-Clifford in nanosecondi
one_qubit_measurement_error_rate galleggiante Frequenza di errore per la misurazione a qubit singolo
two_qubit_joint_measurement_error_rate galleggiante Frequenza di errore per la misurazione a due qubit
t_gate_error_rate galleggiante Frequenza di errore per preparare lo stato non-Clifford di un singolo qubit ($p_T$)
idle_error_rate galleggiante Frequenza degli errori corrispondente all'inattività

Un modello minimo per un set di istruzioni basato su Majorana con tutti i valori obbligatori è:

from qdk.estimator import EstimatorParams, QubitParams

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "majorana"
params.qubit_params.one_qubit_measurement_time = "10 ns"
params.qubit_params.one_qubit_measurement_error_rate = 0.01

Nota

Il valore predefinito per two_qubitJointMeasurementTime e t_gate_time è one_qubit_measurement_time, il valore predefinito per two_qubit_joint_measurement_error_rate e t_gate_error_rate è one_qubit_measurement_error_ratee il valore predefinito per idle_error_rate è one_qubit_measurement_error_rate.

Per one_qubit_measurement_error_rate e two_qubit_joint_measurement_error_rate, è possibile specificare le percentuali di errore che corrispondono alle letture delle misurazioni, readoute all'elaborazione delle misurazioni, process. Questi valori possono essere <double> numeri o coppie di numeri. Ad esempio:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Nota

Se si specifica un singolo valore numerico per le percentuali di errore a qubit singolo e a due qubit nella misurazione del qubit Majorana, sia la velocità di lettura che di errore del processo potrebbero essere uguali.

Importante

Tutti i valori non specificati accettano un valore predefinito. Ad esempio, specificando "qubit": {"oneQubitGateTime":"200 ns"} si modella un qubit basato su gate in cui sia il tempo di gate a due qubit che il tempo di gate a un qubit sono 200 ns. Per le unità, è necessario specificare stringhe temporali, ovvero numeri a virgola mobile a precisione doppia, seguiti da uno spazio e dall'unità temporale per tali valori. I suffissi time supportati sono ns, µs (o us), mse s.

Schemi di correzione degli errori quantistici

Per eseguire applicazioni quantistice su scala pratica, le operazioni quantistica devono avere frequenze di errore basse. Queste velocità targets di errore sono in genere superiori alle funzionalità dei qubit fisici non elaborati. Per superare questa limitazione, la correzione degli errori quantistici (QEC) e il calcolo a tolleranza di errore sono due tecniche cruciali che costituiscono i blocchi predefiniti dei computer quantistici su larga scala. In primo luogo, QEC consente di comporre più qubit fisici soggetti a errori e creare un qubit logico più affidabile che mantiene le informazioni quantistiche meglio rispetto ai qubit fisici sottostanti.

Lo strumento di stima delle risorse usa la formula seguente per modellare le percentuali di errore logiche usando un modello esponenziale.

$$ P = ad^k\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

dove $a$ è un pre-fattore di attraversamento, $d$ è la distanza di codice, $k$ è una potenza del coefficiente di distanza (in genere impostata su 0), $p$ è la frequenza di errore fisica e $p^*$ è la soglia di correzione degli errori quantistici. Il pre-fattore di attraversamento $a$ può essere estratto numericamente per le simulazioni.

La distanza di codice $d$ è un parametro che controlla il numero di errori che possono essere corretti. Di conseguenza, la distanza del codice definisce la frequenza di errore dei qubit logici e il numero di qubit fisici necessari per codificarli. Sia l'accuratezza che il numero di qubit fisici aumentano con la distanza del codice. L'obiettivo di uno schema QEC è trovare la distanza minima del codice che può raggiungere il tasso di errore richiesto impostato per una determinata applicazione.

La frequenza di errore fisica $p$ viene estratta dai parametri qubit come percentuale di errori peggiore di qualsiasi operazione Clifford fisica eseguita nel dispositivo. In particolare, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) per i parametri qubit con un set di istruzioni basato su gate e $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) per i parametri qubit con un set di istruzioni Majorana. Gli schemi QEC hanno in genere una soglia di frequenza degli errori $p^*$ al di sotto della quale la correzione degli errori elimina gli errori.

Azure Quantum Resource Estimator supporta due schemi QEC predefiniti: un codice di superficie e un codice floquet.

Protocollo QEC Classe API Python Descrizione
surface_code SURFACE_CODE Il codice di superficie basato su gate è basato su arXiv:1208.0928 e arXiv:1009.3686. Il codice della superficie di Majorana si basa su arXiv:1909.03002 e arXiv:2007.00307.
floquet_code FLOQUET_CODE Solo per qubit Majorana. Il codice floquet è basato su arXiv:2202.11829.

Nota

A meno che non venga specificato un altro valore, il valore predefinito per lo schema QEC è "surface_code".

Parametri per schemi QEC predefiniti

Di seguito sono riportati i parametri esatti per ogni schema QEC predefinito.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Passaggio di schemi QEC predefiniti

Esistono due modi per specificare schemi QEC predefiniti. È possibile selezionare il nome del modello QEC per la classe "qecScheme" durante l'esecuzione qsharp.estimate. Ad esempio, per selezionare il codice floquet, scrivere:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

È anche possibile passare un elenco di parametri di stima alla classe utilizzando la classe . Ad esempio, per selezionare il codice floquet, scrivere:

from qdk import qsharp
from qsharp.estimator import EstimatorParams, QubitParams, QECScheme

params = EstimatorParams()
params.items.qec_scheme.name = QECScheme.FLOQUET_CODE # floquet code QEC scheme

qsharp.estimate("RunProgram()", params=params)

Personalizzare gli schemi QEC predefiniti

È possibile personalizzare schemi QEC predefiniti specificando il nome e quindi aggiornando qualsiasi altro valore. Ad esempio, per aumentare il pre-fattore di attraversamento nel codice del floquet, scrivere:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

Nota

Il valore predefinito per "logicalCycleTime" e "physicalQubitsPerLogicalQubit" è "oneQubitMeasurementTime", il valore predefinito per "errorCorrectionThreshold" è 0.01e il valore predefinito per "crossingPrefactor" è 0.03.

Personalizzare gli schemi QEC

L'oggetto Resource Estimator può astrarre uno schema QEC personalizzato basato sulla formula precedente fornendo valori per il "crossingPrefactor" $a$, il distanceCoefficientPower $k$ e il "errorCorrectionThreshold" $p^*$. È anche necessario specificare "logicalCycleTime", ovvero il tempo necessario per eseguire una singola operazione logica e che dipende dalla distanza del codice e dai presupposti del tempo dell'operazione fisica dei qubit fisici sottostanti. Infine, una seconda formula calcola , "physicalQubitsPerLogicalQubit"ovvero il numero di qubit fisici necessari per codificare un qubit logico in base alla distanza del codice.

È possibile usare il codice seguente come modello per gli schemi QEC:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "distanceCoefficientPower": <integer>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

All'interno delle formule è possibile usare le variabili one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timee two_qubit_joint_measurement_time, i cui valori vengono ricavati dal campo corrispondente dai parametri del qubit fisico, nonché la variabile eccDistance per la distanza di codice calcolata per il qubit logico, in base alle proprietà del qubit fisico, alla soglia di correzione degli errori e al prefactoring di attraversamento. Le variabili di ora e eccDistance possono essere usate per descrivere la logicalCycleTime formula. Per la formula physicalQubitsPerLogicalQubit, è possibile usare solo il eccDistance.

Budget di errore

Il budget totale degli errori $\epsilon$ imposta l'errore complessivo tollerato per l'algoritmo, ovvero la probabilità di errore consentita dell'algoritmo. Il valore globale deve essere compreso tra 0 e 1 e il valore predefinito è 0,001, che corrisponde allo 0,1%. In altre parole, l'algoritmo può non riuscire al massimo una volta in 1000 esecuzioni. Questo parametro è estremamente specifico dell'applicazione.

Ad esempio, se si esegue l'algoritmo di Shor per i numeri interi di factoring, è possibile tollerare un valore elevato per il budget degli errori perché è possibile verificare che gli output siano effettivamente i fattori primi dell'input. D'altra parte, potrebbe essere necessario un budget di errore inferiore per un algoritmo che risolve un problema con una soluzione, che non può essere verificato in modo efficiente.

Il budget degli errori corrisponde alla somma di tre parti:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

Gli errori logici $\epsilon_{\log}$ sono l'errore di implementazione di qubit logici, l'errore di stato T $\epsilon_{\rm dis}$ è l'errore di produzione di stati T tramite la distillazione e l'errore del gate di rotazione $\epsilon_{\rm syn}$ è l'errore di sintesi dei cancelli di rotazione con angoli arbitrari.

Nota

A meno che non venga specificato un altro valore, il budget degli errori $\epsilon$ viene distribuito in modo uniforme tra l'errore logico, l'errore di stato T e l'errore di controllo di rotazione.

Si noti che per la distillazione e la sintesi delle rotazioni, i rispettivi budget di errore $\epsilon_{\rm dis}$ e $\epsilon_{\rm syn}$ sono distribuiti in modo uniforme tra tutti gli stati T richiesti e tra tutti i cancelli di rotazione necessari, rispettivamente. Se non sono presenti porte di rotazione nell'algoritmo di input, il budget degli errori viene distribuito in modo uniforme agli errori logici e agli errori di stato T.

Superare il limite degli errori

Esistono due modi per specificare il budget degli errori impostando un numero compreso tra 0 e 1. È possibile superare il budget degli errori durante l'esecuzione di qsharp.estimate. Ad esempio, per selezionare un budget di errore di 1/3, scrivere:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

È anche possibile passare i parametri del budget degli errori alla classe .

from qdk import qsharp
from qdk.estimator import EstimatorParams, QubitParams, QECScheme

params = EstimatorParams()
params.items.error_budget = 0.333 # error budget of 1/3

qsharp.estimate("RunProgram()", params=params)

Inoltre, è possibile specificare singolarmente ogni componente del budget degli errori. La somma di tutti i valori è il budget totale degli errori e deve essere compresa tra 0 e 1. Se un algoritmo quantistico non contiene stati O rotazioni T, i valori di t_states e rotations possono essere rispettivamente 0.

Il codice seguente illustra come specificare il parametro budget degli errori con stati T e rotazioni:

from qdk.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.error_budget.logical = 0.01
params.error_budget.t_states = 0.02
params.error_budget.rotations = 0.03

Vincoli

È possibile usare la classe "constraints" per applicare vincoli a livello di componente T factory. Modificando i vincoli, è possibile ottimizzare le stime per ridurre il numero di qubit o ridurre il runtime.

Parametro Tipo di dati Descrizione
logical_depth_factor galleggiante Controllare il tempo di esecuzione. Se ha un valore maggiore di 1, il numero iniziale di cicli logici, detto anche profondità logica, viene moltiplicato per questo numero. logical_depth_factorRiducendo , è possibile aumentare il numero di chiamate della factory T in un determinato periodo di tempo, riducendo così il numero di copie factory T necessarie per produrre lo stesso numero di stati T. Quando si riduce il numero di copie factory T, il runtime dell'algoritmo aumenta di conseguenza. Il fattore di ridimensionamento per il runtime totale potrebbe essere maggiore, poiché il tasso di errore logico necessario aumenta a causa del numero aggiuntivo di cicli.
max_t_factories integer Numero massimo di copie della fabbrica T. Lo strumento di stima delle risorse determina le risorse necessarie selezionando il numero ottimale di copie factory T che riduce al minimo il numero di qubit fisici usati, senza considerare il sovraccarico di tempo. Il max_t_factories parametro limita il numero massimo di copie e quindi regola il numero di cicli logici di conseguenza. Per altre informazioni, vedere Stima fisica della fabbrica T.
max_duration stringa temporale Tempo di esecuzione massimo per l'algoritmo. Lo strumento di stima delle risorse accetta solo uno dei vincoli max_duration o max_physical_qubits per volta, ma non due. Se max_duration viene specificato, l'oggetto Resource Estimator tenta di trovare la stima migliore per max_physical_qubits tra le soluzioni vincolate dal numero massimo specificato.
max_physical_qubits integer Numero massimo di qubit fisici per l'algoritmo. Lo strumento di stima delle risorse accetta solo uno dei vincoli max_duration o max_physical_qubits per volta, ma non due. Se max_physical_qubits viene specificato, l'oggetto Resource Estimator tenta di trovare la stima migliore per max_duration tra le soluzioni vincolate dal numero massimo specificato.

Il codice seguente illustra come specificare i vincoli per un algoritmo quantistico:

from qdk.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

Nota

Se il valore fornito a max_duration o max_physical_qubits è troppo piccolo per trovare una soluzione fattibile, lo strumento di stima delle risorse restituisce un errore. Se né i vincoli max_duration né i vincoli max_physical_qubits sono specificati, lo strumento di stima delle risorse mira a trovare una soluzione con il tempo più breve.

Suggerimento

È possibile usare max_duration e max_physical_qubits per influenzare lo spazio della soluzione, potenzialmente trovare soluzioni con runtime più lungo, ma un numero inferiore di qubit rispetto alle soluzioni senza questi vincoli. Esiste un compromesso tra il runtime e il numero di qubit e questo compromesso può essere gestito in modo efficiente per alcuni algoritmi, con effetti variabili su algoritmi diversi. La tabella IV in [arXiv:2211.07629] illustra l'utilizzo effettivo del compromesso tra il numero di qubit e il runtime per gli algoritmi di dinamica quantistica. Per altre informazioni, vedere il campione Stima delle risorse quantistiche con vincoli di tempo o numero di qubit.

Unità di distillazione

È possibile fornire le specifiche per gli algoritmi di distillazione delle fabbriche T con la DistillationUnitSpecification classe. La specifica può essere predefinita o personalizzata. È possibile specificare una specifica predefinita selezionando il nome dell'unità di distillazione: 15-1 RM o 15-1 space-efficient.

from qdk.estimator import EstimatorParams, DistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.name = "15-1 RM" # predefined distillation unit

params.distillation_unit_specifications.append(unit)

In entrambi i casi, la notazione 15-1 indica 15 stati T di input e 1 stato T di output. L'unità 15-1 space-efficient di crittografia usa meno qubit rispetto a 15-1 RM ma richiede più runtime. Per altre informazioni, vedi Tabella VI.

Suggerimento

Si ottengono prestazioni migliori quando si usano unità di conversione predefinite anziché unità personalizzate.

Personalizza le unità di distillazione

È possibile personalizzare le proprie unità distillazione. I parametri esatti per le unità distillazione sono i seguenti.

qsharp.estimate("RunProgram()", params=
                    {"distillationUnitSpecifications": {
                        "displayName": <string>, 
                        "numInputTs": <int>,
                        "numOutputTs": <int>,
                        "failureProbabilityFormula": <string>,
                        "outputErrorRateFormula": <string>,
                        "physicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecificationFirstRoundOverride": <protocol specific parameters>, # Only if "logicalQubitSpecification"
                        }
                })

Tutti i parametri numerici devono essere positivi. displayName Specifica la modalità di visualizzazione dell'unità di distillazione nei risultati di output.

Il codice seguente illustra come specificare i parametri dell'unità di distillazione per un algoritmo quantistico usando la classe e la classe .

from qdk.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

Le formule per failure_probability_formula e output_error_rate_formula sono formule personalizzate con operazioni aritmetiche di base, costanti e solo tre parametri:

  • clifford_error_rate, indicato anche come c.
  • readout_error_rate, indicato anche come r.
  • input_error_rate, indicato anche come z.

Vedere gli esempi seguenti di formule personalizzate che usano notazione lunga e breve. Questi esempi illustrano le formule usate per impostazione predefinita nell'implementazione standard.

Parametro Formula lunga Formula breve
failure_probability_formula 15.0 * input_error_rate + 356.0 * clifford_error_rate "15.0 * z + 356.0 * c"
output_error_rate_formula 35,0 * input_error_rate ^ 3 + 7,1 * clifford_error_rate "35.0 * z ^ 3 + 7.1 * c"

È necessario specificare almeno uno dei parametri physical_qubit_specification o logical_qubit_specification . Se è fornito solo il primo, l'unità di distillazione può essere applicata ai qubit fisici. Se viene fornito solo quest'ultimo, l'unità distillazione può essere applicata ai qubit logici. Se vengono forniti entrambi, l'unità di distillazione può essere applicata a entrambi i tipi di qubit.

Il parametro logical_qubit_specification_first_round_override può essere fornito solo se logical_qubit_specification è specificato. In tal caso, sostituisce i valori di logical_qubit_specification quando applicati al primo ciclo di distillazione. Il valore <protocol specific parameters> necessario per logical_qubit_specification_first_round_override deve avere lo schema seguente:

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Stima della frontiera Pareto

Quando si stimano le risorse di un algoritmo, è importante considerare il compromesso tra il numero di qubit fisici e il runtime dell'algoritmo. È possibile considerare l'allocazione del maggior numero possibile di qubit fisici per ridurre il runtime dell'algoritmo. Tuttavia, il numero di qubit fisici è limitato dal numero di qubit fisici disponibili nell'hardware quantistico. Comprendere il compromesso tra runtime e scalabilità di sistema è uno degli aspetti più importanti della stima delle risorse.

La stima della frontiera Pareto fornisce più stime per lo stesso algoritmo, ognuna delle quali mostra compromessi tra il numero di qubit e il runtime.

Nota

Se si esegue Lo strumento di stima delle risorse in Visual Studio Code con il QDKcomando : Calculate Resource Estimates (Calcola stime delle risorse ), la stima della frontiera Pareto è abilitata per impostazione predefinita.

Se si esegue Lo strumento di stima delle risorse in Python, è necessario specificare il "estimateType" parametro come "frontier".

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Se si desidera visualizzare i risultati della stima della frontiera Pareto, è possibile usare la EstimatesOverview funzione . Queste funzioni visualizzano i risultati della stima della frontiera nella tabella e in un diagramma spazio-tempo. Per altre informazioni, vedere Diagramma spazio-tempo.

from qdk.widgets import EstimatesOverview

EstimatesOverview(result)

Nota

Se si verificano problemi quando si lavora con Lo strumento di stima delle risorse, vedere la pagina Risoluzione dei problemi o contattare AzureQuantumInfo@microsoft.com.

Passaggi successivi

  • Last updated on