Condividi tramite

Personalizzare i target parametri dello strumento di stima delle risorse

  • Articolo

Questo articolo illustra come personalizzare i target parametri di Azure Quantum Resource Estimator in base alle caratteristiche del computer in uso target. 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 verifica un problema durante l'uso di Resource Estimator, vedere la pagina Risoluzione dei problemi.

Prerequisiti

Parametri relativi alla 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 usando una determinata tecnologia qubit e con un set fisso di scelte architetturali.

Di conseguenza, 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, ovvero il numero di volte in cui il programma può annullare le operazioni.
  • Vincoli a livello di componente, ovvero il numero di cicli logici e il numero di copie factory T.
  • Unità di classificazione per specificare algoritmi di crittografia T factory.
  • Stima della frontiera Pareto per eseguire più stime del numero di qubit e del runtime per lo stesso algoritmo.

Parametri qubit fisici

Quando lo strumento di stima delle risorse modella i presupposti del qubit fisico, usa due diversi set di istruzioni fisiche per gestire i qubit. Il set di istruzioni fisiche può essere basato sull'attività di controllo o Majorana. Un set di istruzioni basato sull'attività di controllo fornisce la misurazione a qubit singolo, le attività a qubit singole (inclusi le attività T) e le attività T a due qubit. Un set di istruzioni Majorana fornisce un gate T fisico, una misurazione 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 controllo 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 e $10^{-4}$ come ottimistica target per un sistema con scalabilità targetorizzontale.
"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 di ion, si presuppone che le operazioni di gate e misurazione prendano 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, la percentuale di errore è $10^{-3}$ come realistica target e $10^{-4}$ come ottimistica 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 controllo e misurazione prendano 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^$ come realistico e $10^{-4}{-6}$ come ottimistatargettarget. 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 venga specificato un altro valore, il valore predefinito per il modello qubit è "qubit_gate_ns_e3".

Parametri per i parametri 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
    }
}

Passaggio di parametri qubit predefiniti

Esistono due modi per specificare parametri qubit predefiniti a livello di codice. È possibile selezionare il nome del modello qubit per la classe durante l'esecuzione qubitParams di qsharp.estimate. Ad esempio, per selezionare "qubit_maj_ns_e6" il parametro qubit, scrivere:

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

È anche possibile passare i parametri qubit alla EstimatorParams classe usando QubitParams. Ad esempio, per selezionare MAJ_NS_E6 il parametro qubit, scrivere:

from qsharp.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 la frequenza di errore della misura congiunta a due qubit in "qubit_maj_ns_e4", scrivere:

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 = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parametri qubit per qubit basati su gate

Identificatore Python Tipo di dati Descrizione
name stringa Nome del modello qubit
instruction_set "gate_based" Tecnologia qubit sottostante
one_qubit_measurement_time stringa temporale Tempo operazione per la misurazione a qubit singolo ($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 operativo per il gate a due qubit in ns
t_gate_time stringa temporale Tempo operativo per il gate non Clifford a qubit singolo in ns
one_qubit_measurement_error_rate float Frequenza di errore per la misurazione a qubit singolo
one_qubit_gate_error_rate float Frequenza di errore per il gate Clifford a qubit singolo ($p$)
two_qubit_gate_error_rate float Frequenza di errore per il gate Clifford a due qubit
t_gate_error_rate float Frequenza di errore per preparare lo stato non Clifford a qubit singolo ($p_T$)
idle_error_rate float Frequenza degli errori corrispondente all'inattività

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

from qsharp.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

Se non specificato, i valori per two_qubit_gate_time e t_gate_time per impostazione predefinita sono one_qubit_gate_time, i valori per two_qubit_gate_error_rate e t_gate_error_rate per impostazione predefinita sono e il valore per idle_error_rate l'impostazione predefinita one_qubit_gate_error_rateè one_qubit_measurement_error_rate.

Parametri qubit per qubit 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 Tempo operazione per la misurazione a qubit singolo ($t_{\rm meas}$) in ns
two-qubit_joint_measurement_time stringa temporale Tempo operativo per la misurazione a due qubit in ns
t_gate_time stringa temporale Tempo operativo per il gate non Clifford a qubit singolo in ns
one_qubit_measurement_error_rate float Frequenza di errore per la misurazione a qubit singolo
two_qubit_joint_measurement_error_rate float Frequenza di errore per la misurazione a due qubit
t_gate_error_rate float Frequenza di errore per preparare lo stato non Clifford a qubit singolo ($p_T$)
idle_error_rate float Frequenza degli errori corrispondente all'inattività

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

from qsharp.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

Se non specificato, i valori per two_qubitJointMeasurementTime e t_gate_time per impostazione predefinita sono one_qubit_measurement_time, i valori per two_qubit_joint_measurement_error_rate e t_gate_error_rate per impostazione predefinita sono e il valore per idle_error_rate l'impostazione predefinita one_qubit_measurement_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 corrispondenti 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 possono essere uguali.

Importante

Tutti i valori non specificati accettano un valore predefinito, ad esempio se si specifica "qubit": {"oneQubitGateTime":"200 ns"} un qubit basato su gate in cui sia il tempo di gate-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, dove possibili suffissi temporali 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 la modellazione delle frequenze di errore logiche usando un modello esponenziale.

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

dove $a$ è un fattore di pre-fattore, $d$ è la distanza di codice, $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,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

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

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "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 durante l'esecuzione "qecScheme" di 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 usando laQECSchemeclasse .EstimatorParams Ad esempio, per selezionare il codice floquet, scrivere:

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

Se non specificato, i valori per "logicalCycleTime" e "physicalQubitsPerLogicalQubit" per impostazione predefinita sono "oneQubitMeasurementTime", il valore predefinito per "errorCorrectionThreshold" l'impostazione predefinita è e il valore per "crossingPrefactor" l'impostazione predefinita 0.01è 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$ e il "errorCorrectionThreshold" $p^*$. È inoltre necessario specificare , "logicalCycleTime"ovvero il tempo necessario per eseguire una singola operazione logica, 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>,
                        "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 utilizzare solo .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 normalizzazione e l'errore del gate di rotazione $\epsilon_{\rm syn}$ è l'errore di diffusione 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 sintesi della rotazione e della rotazione, i rispettivi budget di errore $\epsilon_{\rm dis}$ e $\epsilon_{\rm syn}$ sono distribuiti in modo uniforme tra tutti gli stati T obbligatori e tutti i cancelli di rotazione necessari, rispettivamente. Se non sono presenti controlli di rotazione nell'algoritmo di input, il budget degli errori viene distribuito in modo uniforme agli errori logici e agli errori di stato T.

Passaggio del budget degli errori

Esistono due modi per specificare il budget degli errori impostando un numero compreso tra 0 e 1. È possibile passare 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 EstimatorParams classe .

from qsharp.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 qsharp.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 "constraints" classe per applicare vincoli a livello di componente della factory T. 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 float 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 può essere maggiore, perché la frequenza di errore logica necessaria aumenta a causa del numero aggiuntivo di cicli.
max_t_factories integer Numero massimo di copie factory 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 factory T.
max_duration stringa temporale Runtime massimo per l'algoritmo. Lo strumento di stima delle risorse accetta solo uno dei max_duration vincoli o max_physical_qubits al momento, 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 max_duration vincoli o max_physical_qubits al momento, 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 qsharp.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 non max_durationmax_physical_qubits vengono specificati né vincoli, 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 Stima delle risorse quantistiche con il tempo o il numero di vincoli di qubit.

Unità di crittografia

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

from qsharp.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

L'uso di unità di conversione predefinite offre prestazioni migliori rispetto a quelle personalizzate.

Personalizzare le unità di personalizzazione

È 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 compilazione nei risultati dell'output.

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

from qsharp.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 viene fornito solo il primo, l'unità di inizialità 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 inizialità 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 nel caso se applicati al primo round di soia. Il valore <protocol specific parameters> necessario per logical_qubit_specification_first_round_override deve seguire lo schema:

{
    "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 usando l'opzione Q#: 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 qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Nota

Se si verifica un problema durante l'uso dello strumento di stima delle risorse, consultare la pagina Risoluzione dei problemi o contattare AzureQuantumInfo@microsoft.com.

Passaggi successivi