Aracılığıyla paylaş

target Kaynak tahmin aracının parametrelerini özelleştirme

Bu makaledetarget giriş parametrelerini hedeflediğiniz makine özellikleriyle eşleşecek şekilde nasıl özelleştirebileceğiniz gösterilmektedir. Kaynak tahmin aracı, kuantum bilgisayarda kuantum algoritması çalıştırmak için gereken kaynakları tahmin etmek için bu parametreleri kullanır.

Not

Kaynak tahmin aracıyla çalışırken sorunlarla karşılaşıyorsanız Sorun Giderme sayfasına bakın.

Önkoşullar

Hedef parametreler

Kaynak tahmin aracı, belirli bir kubit teknolojisine ve sabit mimari seçeneklere sahip bir kuantum bilgisayarda belirli bir kuantum algoritması uygulamak için gerekli olan kubit sayısı ve çalışma süresi gibi kaynakların tahminini hesaplar.

Kaynak tahmin aracı, kolayca kullanmaya başlamanızı sağlamak için önceden tanımlanmış değerler içeren bir dizi giriş alır:

İpucu

Bir işlemin önceden hesaplanmış bazı tahminlerini zaten biliyorsanız, kaynak tahmin aracının çalışma süresini iyileştirmek için bunları birleştirebilirsiniz. Daha fazla bilgi için bkz. Bilinen tahminleri kaynak tahmin aracıyla kullanma.

Fiziksel kubit parametreleri

Kaynak tahmin aracı fiziksel kubit varsayımlarını modellediğinde, kubitler üzerinde çalışmak için iki farklı fiziksel yönerge kümesi kullanır. Fiziksel yönerge kümesi, geçit tabanlı veya Majorana olabilir. Geçit tabanlı yönerge kümesi tek kubitli ölçüm, tek kubitli geçitler (T geçitleri dahil) ve iki kubitli geçitler sağlar. Majorana yönerge kümesi fiziksel T kapısı, tek kubitli ölçüm ve iki kubitli ortak ölçüm işlemleri sağlar.

Dört tane geçit tabanlı yönerge kümesi ve ikisi Majorana yönerge kümesine sahip olmak üzere önceden tanımlanmış altı kubit parametresi arasından seçim yapabilirsiniz. Bu kubit modelleri, pratik kuantum uygulamalarını çalıştırmak için gereken kaynak maliyetlerini yeterince inceleyebilmeniz için çeşitli işlem sürelerini ve hata oranlarını kapsar.

Qubit parametresi Python API sınıfı Açıklama
"qubit_gate_ns_e3", "qubit_gate_ns_e4" GATE_NS_E3, GATE_NS_E4 İşlem süreleri ve aslına uygunluklar, süper iletken transmon kubitlerinin gelecekteki sürümlerine veya genellikle nanosaniye rejiminde işlem sürelerine sahip olan spin kubitlerine karşılık gelebilir. Bu kubitler için geçit ve ölçüm işlemlerinin sırasıyla 50 ns ve 100 ns olduğu varsayılır. Tek kubitli ve iki kubitli kapı hata oranlarının gerçekçi {-3}olarak $10^target$ ve ölçeklendirilmiş bir sistem için iyimser {-4} olarak $10^target$ olduğu varsayılır.
"qubit_gate_us_e3", "qubit_gate_us_e4" GATE_US_E3, GATE_US_E4 İşlem süreleri ve aslına uygunlukları, genellikle mikrosaniye rejiminde operasyon süreleri olan iyonları temel alan kubitlerin gelecekteki sürümlerine karşılık gelebilir. İyon kubitleri için tipik varsayımlara göre, geçit ve ölçüm işlemlerinin 100 μs olduğu varsayılır. Tek kubitli Clifford geçitleri için hata oranı gerçekçi {-3} olarak $10^target$ ve iyimser {-4}olarak $10^target$ olurken, Tek kubitli clifford olmayan geçitler (T kapısı) için hata oranı $10^{-6}$'tır. İki kubitli kapılar için hata oranı, gerçekçi bir {-3} olarak $10^target$ ve iyimser bir {-4} olarak $10^target$ olur.
"qubit_maj_ns_e4", "qubit_maj_ns_e6" MAJ_NS_E4, MAJ_NS_E6 İşlem süreleri ve uygunlukları, Majorana kubitlerinin gelecekteki geliştirilmiş sürümlerine karşılık gelebilir. Bu kubitler için geçit ve ölçüm işlemlerinin 100 ns olduğu varsayılır. Donanımda topolojik korumayı hesaba katmak için, tek kubitli ve iki kubitli ortak ölçüm hata oranlarının (Clifford hata oranları) gerçekçi {-4}olarak $10^target$ ve iyimser {-6}olarak $10^target$ olduğu varsayılır. Bu mimarideki Clifford dışı işlemlerin topolojik koruması yoktur, Clifford olmayan fiziksel T geçitleri için hata oranı %5'tir.

Not

Kubit modelinin varsayılan değeridir "qubit_gate_ns_e3".

Önceden tanımlanmış kubit parametreleri için parametreler

Başvuru için, önceden tanımlanmış kubit parametrelerinin tamamı aşağıdaki gibidir:

{
    "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
    }
}

Önceden tanımlanmış kubit parametrelerini geçirme

Program aracılığıyla önceden tanımlanmış kubit parametrelerini belirtmenin iki yolu vardır. Bunun bir yolu, qubitParams çalıştırdığınızda qsharp.estimate sınıfının kubit modeli adını seçmektir. Örneğin, algoritmanızı çalıştırmak için RunProgram() işlemini kullanan bir Q# program için "qubit_maj_ns_e6" qubit parametresini seçmek üzere aşağıdaki Python kodunu çalıştırın.

from qdk import qsharp

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

Başka bir yol, kubit parametrelerini EstimatorParams sınıfınaQubitParamsgeçirmektir. Örneğin, kubit parametresini MAJ_NS_E6 seçmek için aşağıdaki kodu çalıştırın:

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)

Önceden tanımlanmış kubit parametrelerini özelleştirme

Önceden tanımlanmış kubit parametrelerini özelleştirmek için. değiştirmek istediğiniz adı ve diğer değerleri belirtin. Örneğin, içinde qubit_maj_ns_e4iki kubitli birleşim ölçümlerinin hata oranını azaltmak için aşağıdaki kodu çalıştırın:

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

İsterseniz, yönergeleri liste biçiminde de geçirebilirsiniz.

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

Geçit tabanlı kubitler için Kubit parametreleri

Python tanımlayıcısı Veri türü Açıklama
name Dize Kubit modelinin adı
instruction_set kapı_tabanlı Temel kubit teknolojisi
one_qubit_measurement_time zaman stringi Ns cinsinden tek kubitli ölçüm ($t_{\rm meas}$) için işlem süresi
one_qubit_gate_time zaman stringi Ns cinsinden tek kubitli kapı ($t_{\rm gate}$) için işlem süresi
two_qubit_gate_time zaman stringi İki kubitli kapının işlem süresi ns cinsinden
t_gate_time zaman stringi Tek qubit için Clifford olmayan bir kapının işlem süresi (ns cinsinden)
one_qubit_measurement_error_rate float Tek kubitli ölçüm için hata oranı
one_qubit_gate_error_rate float Tek kubitli Clifford kapısı ($p$) için hata oranı
two_qubit_gate_error_rate float İki kubitli Clifford kapısı için hata oranı
t_gate_error_rate float Clifford olmayan tek kubitli durumu ($p_T$) hazırlamak için hata oranı
idle_error_rate float Boşta kalma durumuna karşılık gelen hata oranı

Aşağıdaki kod, geçit tabanlı yönerge kümesi için özel kubit parametrelerinin nasıl belirtileceğini gösterir:

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

Not

two_qubit_gate_time ve t_gate_time için varsayılan değer, one_qubit_gate_time değeridir. two_qubit_gate_error_rate ve t_gate_error_rate için varsayılan değer, one_qubit_gate_error_rate değeridir. idle_error_rate için varsayılan değer, one_qubit_measurement_error_rate değeridir.

Majorana kubitleri için kubit parametreleri

Python tanımlayıcısı Veri türü Açıklama
name Dize Kubit modelinin adı
instruction_set majorana Temel kubit teknolojisi
one_qubit_measurement_time zaman stringi Ns cinsinden tek kubitli ölçüm ($t_{\rm meas}$) için işlem süresi
two-qubit_joint_measurement_time zaman stringi n cinsinden iki kubitli ölçüm için işlem süresi
t_gate_time zaman stringi Tek kubitli Clifford olmayan kapı için işlem süresi ns cinsindendir.
one_qubit_measurement_error_rate float Tek kubitli ölçüm için hata oranı
two_qubit_joint_measurement_error_rate float İki kubitli ölçüm için hata oranı
t_gate_error_rate float Clifford olmayan tek kubitli durumu ($p_T$) hazırlamak için hata oranı
idle_error_rate float Boşta çalışma ile ilişkili hata oranı

Tüm gerekli değerleri içeren bir Majorana yönerge kümesi için en düşük şablon:

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

Not

two_qubitJointMeasurementTime ve t_gate_time için varsayılan değer, one_qubit_measurement_time'nin değeridir. two_qubit_joint_measurement_error_rate ve t_gate_error_rate için varsayılan değer, one_qubit_measurement_error_rate değeridir. idle_error_rate için varsayılan değer, one_qubit_measurement_error_rate değeridir.

one_qubit_measurement_error_rate için ve two_qubit_joint_measurement_error_rate için, ölçüm okumalarına readout ve ölçüm işlemeye process karşılık gelen hata oranlarını belirtebilirsiniz. Bu değerler sayı veya sayı çifti olabilir <double> . Örneğin:

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

Not

Majorana kubit ölçümünde tek kubit ve iki kubit hata oranları için tek bir sayısal değer belirtirseniz, hem okuma hem de işlem hata oranları eşit olabilir.

Belirtmediğiniz tüm değerler varsayılan bir değer alır. Örneğin, "qubit": {"oneQubitGateTime":"200 ns"} belirtilirse, kaynak tahmincisi hem iki-kubit kapı süresinin hem de tek-kubit kapı süresinin 200 ns olduğu bir geçit tabanlı kubitin modelini oluşturur. Birimler için, çift duyarlıklı kayan nokta sayıları ve ardından bir boşluk ve bu değerler için zaman birimi olan zaman dizelerini belirtmeniz gerekir. Desteklenen zaman sonekleri şunlardır: ns, µs (veya us), msve s.

Kuantum hata düzeltme düzenleri

Pratik ölçekli kuantum uygulamalarını çalıştırmak için kuantum işlemleri düşük hata oranlarına sahip olmalıdır. Bu hata oranı targets genellikle ham fiziksel kubitlerin özelliklerinin ötesindedir. Bu sınırlamayı aşmak için kuantum hata düzeltmesi (QEC) ve hataya dayanıklı hesaplama, büyük ölçekli kuantum bilgisayarların yapı taşları oluşturan iki önemli tekniktir. QEC şemaları, hataya açık fiziksel kubitlerden oluşan daha büyük gruplardan hataya dayanıklı mantıksal kubitler oluşturur. Mantıksal kubitler, kuantum bilgilerini temel alınan fiziksel kubitlerden daha iyi korur.

Kaynak tahmin aracı, mantıksal hata oranlarını modellemek için aşağıdaki üstel formülü kullanır,

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

burada $a$ bir geçiş ön faktörüdür, $d$ kod uzaklığıdır, $k$ bir uzaklık katsayısı gücüdür (genellikle 0 olarak ayarlanır), $p$ fiziksel hata oranıdır ve $p^*$ kuantum hata düzeltme eşiğidir. Simülasyonlarda kullanmak üzere kesit ön faktörü $a$ değerini sayısal olarak alabilirsiniz.

$d$ kod uzaklığı, düzeltilebilen hata sayısını denetleen bir parametredir. Kod uzaklığı, mantıksal kubitlerin hata oranını ve mantıksal kubitleri kodlamak için gereken fiziksel kubit sayısını tanımlar. Kod uzaklığı ile hem doğruluk hem de fiziksel kubit sayısı artar. QEC şemasının amacı, belirli bir uygulama için ayarladığınız gerekli hata oranına ulaşabilecek en düşük kod uzaklığı bulmaktır.

$p$ fiziksel hata oranı, kubit parametrelerinden, cihazda gerçekleştirilen fiziksel Clifford işleminin en kötü durum hata oranı olarak ayıklanır. Özellikle, geçit tabanlı yönerge kümesine sahip kubit parametreleri için $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate), Majorana yönerge kümesine sahip kubit parametreleri için $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) . QEC şemaları, genellikle hata oranı $p^*$ eşiğinin altında olduğunda, hata düzeltmenin hataları bastırdığı bir eşiğe sahiptir.

Microsoft Quantum kaynak tahmin aracı, önceden tanımlanmış iki QEC şemasını destekler: bir yüzey kodu ve bir floquet kodu.

QEC protokolü Python API sınıfı Açıklama
surface_code SURFACE_CODE Geçit tabanlı yüzey kodu arXiv:1208.0928 ve arXiv:1009.3686'ya dayanır. Majorana yüzey kodu arXiv:1909.03002 ve arXiv:2007.00307'yi temel alır.
floquet_code FLOQUET_CODE Sadece Majorana kubitleri için. Floquet kodu arXiv:2202.11829'a dayanır.

Not

QEC şeması için varsayılan değerdir "surface_code".

Önceden tanımlanmış QEC düzenleri için parametreler

Önceden tanımlanmış her QEC şeması için tam parametreler şunlardır:

{
    "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)"
    }
}

Önceden tanımlanmış QEC düzenlerini geçirme

Önceden tanımlanmış QEC düzenlerini belirtmenin iki yolu vardır. "qecScheme" sınıfını çalıştırdığınızda, QEC model adını qsharp.estimate için seçebilirsiniz. Örneğin, floquet kodunu seçmek için aşağıdaki kodu çalıştırın:

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

Ayrıca QECScheme sınıfını kullanarak EstimatorParams sınıfına tahmin parametreleri listesini geçirebilirsiniz. Örneğin, floquet kodunu seçmek için aşağıdaki kodu çalıştırın:

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)

Önceden tanımlanmış QEC düzenlerini özelleştirme

Önceden tanımlanmış QEC düzenlerini özelleştirmek için, değiştirmek istediğiniz adı ve diğer değerleri belirtin. Örneğin, floquet kodunda geçiş ön faktörünü artırmak için aşağıdaki kodu çalıştırın:

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

Not

"logicalCycleTime" ve "physicalQubitsPerLogicalQubit" için varsayılan değer, "oneQubitMeasurementTime" değeridir. "errorCorrectionThreshold" için varsayılan değer 0.01değeridir. "crossingPrefactor" için varsayılan değer 0.03değeridir.

QEC şemalarınızı özelleştirme

Kaynak tahmin aracı, $a$, "crossingPrefactor" $k$ ve distanceCoefficientPower $p^*$ değerlerini "errorCorrectionThreshold" belirleyerek yukarıdaki formüle göre özelleştirilmiş bir QEC örgüsünü soyutlayabilir. Ayrıca, kod uzaklığı ve temel alınan fiziksel kubitlerin fiziksel işlem süresi varsayımlarına bağlı olan, tek bir mantıksal işlemi çalıştırmak için gereken süre olan "logicalCycleTime" değerini belirtmeniz gerekir. Başka bir formül, bir mantıksal kubiti kod uzaklığı temelinde kodlamak için gereken fiziksel kubit sayısı olan değerini hesaplar "physicalQubitsPerLogicalQubit".

QEC düzenleri için şablon olarak aşağıdaki kodu kullanabilirsiniz:

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

Formüllerin içinde , , one_qubit_gate_timetwo_qubit_gate_timeve one_qubit_measurement_timedeğişkenlerini two_qubit_joint_measurement_timekullanabilirsiniz. Bu değişkenlerin değerleri fiziksel kubit parametrelerinden ilgili alanların yanı sıra mantıksal kubit için hesaplanan kod uzaklığı değişkeni eccDistance , hata düzeltme eşiği ve geçiş ön düzenlemesinden gelir. Zaman değişkenleri ve eccDistance, logicalCycleTime formülünü açıklamak için kullanılabilir. formül physicalQubitsPerLogicalQubit için yalnızca eccDistance kullanılabilir.

Hata bütçesi

Toplam hata bütçesi $\epsilon$, algoritmanın izin verilen hata olasılığı olan algoritma için genel olarak tolere edilen hatayı ayarlar. Genel değeri 0 ile 1 arasında olmalıdır ve varsayılan değer %0,1'e karşılık gelen 0,001'dir. Başka bir deyişle algoritmanın 1000 yürütmede en fazla bir kez başarısız olmasına izin verilir. Bu parametre yüksek oranda uygulamaya özgüdür.

Örneğin, Shor algoritmasını büyük tamsayıları çarpanlarına ayırmak için çalıştırıyorsanız, sonuçların girişin asal çarpanları olup olmadığını kontrol edebileceğinizden büyük bir hata toleransı değeri tolere edebilirsiniz. Öte yandan, çözümünü verimli bir şekilde doğrulayamadığınız bir sorun için bir algoritma kullanıyorsanız, daha küçük bir hata bütçesine ihtiyacınız olabilir.

Hata bütçesi üç bölümün toplamına karşılık gelir:

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

Mantıksal hatalar $\epsilon_{\log}$ mantıksal kubit uygulama hatasıdır, T durumu hatası $\epsilon_{\rm dis}$ damıtma yoluyla T durumları oluşturma hatasıdır ve döndürme kapısı hatası $\epsilon_{\rm syn}$ döndürme geçitlerini rastgele açılarla sentezleme hatasıdır.

Not

Farklı bir değer belirtmediğiniz sürece$\epsilon$ hata bütçesi mantıksal hata, T durumu hatası ve döndürme kapısı hatası arasında tekdüzen olarak dağıtılır.

Damıtma ve döndürme sentezi için ilgili hata bütçeleri $\epsilon_{\rm dis}$ ve $\epsilon_{\rm syn}$ sırasıyla tüm gerekli T durumları ve tüm gerekli döndürme geçitleri arasında eşit olarak dağıtılır. Giriş algoritmasında döndürme kapıları yoksa, hata bütçesi mantıksal hatalara ve T durumu hatalarına eşit olarak dağıtılır.

Hata bütçesini geçirme

Hata bütçesini belirtmenin iki yolu vardır. Hata bütçesini aşmanın bir yolu, qsharp.estimate komutunu çalıştırmaktır. Örneğin, 1/3 hata bütçesini seçmek için aşağıdaki kodu çalıştırın:

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

Hata bütçesi parametrelerini EstimatorParams sınıfına da geçirebilirsiniz.

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)

Ayrıca, hata bütçesinin her bileşenini ayrı ayrı belirtebilirsiniz. Tüm değerlerin toplamı toplam hata bütçesidir ve 0 ile 1 arasında olmalıdır. Kuantum algoritması T durumları veya döndürmeler içermiyorsa, t_states ve rotations değerleri sırasıyla 0 olabilir.

Aşağıdaki kod, T durumları ve döndürmeleri ile hata bütçesi parametresinin nasıl belirtileceğini gösterir:

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

Sınırlamalar

EstimatorParams sınıfının constraints özniteliğini T fabrikası bileşen düzeyinde kısıtlamalar uygulamak için kullanabilirsiniz. Kısıtlamaları ayarladığınızda, kubit sayısını azaltmak, ancak çalışma süresini artırmak veya çalışma süresini azaltmak ancak kubit sayısını artırmak için tahminleri iyileştirebilirsiniz.

Parametre Veri türü Açıklama
logical_depth_factor float Yürütme süresini denetleme. Değeri 1'den büyükse, mantıksal derinlik olarak da adlandırılan ilk mantıksal döngü sayısı bu sayı ile çarpılır. logical_depth_factor azaltarak, belirli bir süre içinde T fabrika kopyasının çağrı sayısını artırabilirsiniz, bu da aynı sayıda T durumu üretmek için gereken T fabrika kopyasının daha az olmasına yol açar. T fabrika kopyalarının sayısını azalttığınızda algoritma çalışma süresi buna göre artar. Ek döngü sayısı nedeniyle gerekli mantıksal hata oranı arttığı için toplam çalışma süresi için ölçeklendirme faktörü daha büyük olabilir.
max_t_factories tam sayı T fabrikası kopyalarının azami sayısı. Kaynak tahmin aracı, zaman ek yükünü dikkate almadan kullanılan fiziksel kubit sayısını en aza indiren en uygun T fabrika kopyası sayısını seçerek gerekli kaynakları belirler. max_t_factories parametresi maksimum kopya sayısını sınırlar ve bu nedenle mantıksal döngü sayısını buna göre ayarlar. Daha fazla bilgi için T factory fiziksel tahmini bölümüne bakın.
max_duration zaman stringi Algoritma için en uzun çalışma süresi. Kaynak tahmin aracı aynı anda yalnızca birini max_duration veya max_physical_qubits kısıtlamalarını kabul eder, ancak ikisini kabul etmemektedir. Belirtilirse max_duration , kaynak tahmin aracı belirtilen en yüksek sayı ile kısıtlanmış çözümler arasında en max_physical_qubits iyi tahmini bulmaya çalışır.
max_physical_qubits tam sayı Algoritma için en fazla fiziksel kubit sayısı. Kaynak tahmin aracı aynı anda yalnızca birini max_duration veya max_physical_qubits kısıtlamalarını kabul eder, ancak ikisini kabul etmemektedir. Belirtilirse max_physical_qubits , kaynak tahmin aracı belirtilen en yüksek sayı ile kısıtlanmış çözümler arasında en max_duration iyi tahmini bulmaya çalışır.

Aşağıdaki kod, kuantum algoritması için kısıtlamaların nasıl belirtileceğini gösterir:

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

Eğer max_duration veya max_physical_qubits için sağladığınız değer uygun bir çözüm bulamayacak kadar küçükse, kaynak tahminleyici bir hata döndürür. veya max_durationiçin max_physical_qubits bir değer sağlamazsanız, kaynak tahmin aracı en kısa çalışma süresi için en iyi duruma getirilmiş tahminlere öncelik verir.

Not

Çalışma süresi ile kubit sayısı arasında bir denge vardır. Bazı algoritmalar için bu dengeyi max_duration ve max_physical_qubits ile yönetebilirsiniz. [arXiv:2211.07629] içindeki Tablo IV, kuantum dinamiği algoritmaları için kubit sayısı ve çalışma süresi arasındaki dengenin etkin kullanımını göstermektedir. Daha fazla bilgi için bkz . Zaman veya kubit sayısı sınırlamalarıyla kuantum kaynağı tahmini örneği.

Damıtma birimleri

DistillationUnitSpecification sınıfı ile T fabrika damıtma algoritmaları için spesifikasyonlar sağlayabilirsiniz. Belirtim önceden tanımlanmış veya özel olabilir. Önceden tanımlanmış bir belirtim belirtmek için damıtma birimi adını 15-1 RM veya 15-1 space-efficientkullanın. Örneğin, aşağıdaki koda bakın:

from qdk.estimator import EstimatorParams, DistillationUnitSpecification

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

params.distillation_unit_specifications.append(unit)

Her iki durumda 15-1 da 15 giriş T durumu ve 1 çıkış T durumu anlamına gelir. 15-1 space-efficient Damıtma birimi daha 15-1 RM az kubit kullanır ancak daha uzun bir çalışma süresi gerektirir. Daha fazla bilgi için bkz . Tablo VI.

İpucu

Özel birimler yerine önceden tanımlanmış damıtma birimleri kullandığınızda daha iyi performans elde edersiniz.

Damıtma birimlerinizi özelleştirme

Kendi damıtma birimlerinizi özelleştirebilirsiniz. Damıtma birimleri için tam parametreler şunlardır:

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"
                        }
                })

Tüm sayısal parametreler pozitif olmalıdır. , displayName distilasyon biriminin çıkış sonuçlarında nasıl görüntüleneceğini belirtir.

Aşağıdaki kod, DistillationUnitSpecification sınıfı ve ProtocolSpecificDistillationUnitSpecification sınıfı ile bir kuantum algoritması için damıtma birimi parametrelerinin nasıl belirtileceğini gösterir.

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

failure_probability_formula ve output_error_rate_formula formülleri, temel aritmetik işlemler ve sabitlerle oluşturulmuş özel formüllerdir. Bu formüller yalnızca aşağıdaki parametrelere sahiptir:

  • clifford_error_rateolarak da belirtilir c.
  • readout_error_rateolarak da belirtilir r.
  • input_error_rateolarak da belirtilir z.

Uzun ve kısa gösteriminde aşağıdaki özel formül örneklerine bakın. Bu örnekler, standart uygulama tarafından kullanılan varsayılan formüllerdir.

Parametre Uzun formül Kısa formül
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"

Parametrelerin physical_qubit_specification en az biri veya logical_qubit_specificationiçin değerler sağlayın. Eğer yalnızca failure_probability_formula sağlarsanız, o zaman distilasyon birimi fiziksel kubitlere uygulanır. output_error_rate_formula yalnızca sağlarsanız, damıtma işlemi mantıksal kubitlere uygulanır. Her iki parametreyi de sağlarsanız, damıtma birimi her iki kubit türüne de uygulanır.

logical_qubit_specification_first_round_override parametresi için yalnızca bir değer sağlayabilirsiniz, eğer logical_qubit_specification parametresi için de bir değer sağlıyorsanız. logical_qubit_specification_first_round_override parametresi, distilasyonun ilk turunda uygulandığında, logical_qubit_specification değerinin yerine geçer. logical_qubit_specification_first_round_override için <protocol specific parameters> değeri gereklidir ve aşağıdaki şemaya sahip olmalıdır:

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

Pareto sınır tahmini

Pareto sınır tahmini çalıştırma

Bir algoritmayı çalıştırmak için gereken kaynakları tahmin ettiğinizde, fiziksel kubit sayısı ile algoritmanın çalışma zamanı arasındaki dengeyi göz önünde bulundurmanız önemlidir. Daha fazla kubit kullanıyorsanız algoritmanızın çalışma zamanını azaltabilirsiniz. Ancak, kullanabileceğiniz fiziksel kubitlerin sayısı donanım tasarımıyla sınırlıdır.

Pareto sınır tahmini, aynı algoritma için birden çok tahmin sağlar. Her tahmin, kubit sayısı ile çalışma süresi arasındaki dengeleri gösterir.

Not

VS Code'da kaynak tahmin aracını : Kaynak Tahminlerini Hesapla komutuylaQDK çalıştırırsanız, Pareto sınır tahmini varsayılan olarak etkinleştirilir.

Python'da kaynak tahmin aracısını çalıştırmak için parametresini "estimateType" olarak "frontier"belirtmeniz gerekir.

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

Pareto sınır tahmininin sonuçlarını görselleştirmek için işlevini kullanabilirsiniz EstimatesOverview . Bu işlevler, bir tablodaki ve uzay-zaman diyagramındaki sınır tahminlerinin sonuçlarını görüntüler. Daha fazla bilgi için bkz . Uzay-zaman diyagramı.

from qdk.widgets import EstimatesOverview

EstimatesOverview(result)

Not

Kaynak tahmin aracıyla çalışırken sorunlarla karşılaşırsanız Sorun giderme sayfasına bakın veya ile iletişime geçin AzureQuantumInfo@microsoft.com.

Sonraki adımlar

  • Last updated on