Aracılığıyla paylaş

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

Bu makaledetarget 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, bunları birleştirerek kaynak tahmin aracının yürütülmesini iyileş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 kapı 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 çeşitli işlem sürelerini ve hata oranlarını kapsar ve pratik kuantum uygulamalarını etkinleştirmek için gereken kaynak maliyetlerinin yeterince araştırılmasını sağlar.

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 geçitler için hata oranı gerçekçi {-3} olarak $10^target$ ve iyimser {-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

Farklı bir değer belirtmediğiniz sürece kubit modelinin varsayılan değeri şeklindedir "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, kubit parametresini "qubit_maj_ns_e6" seçmek için aşağıdaki kodu yazın:

from qdk import qsharp

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

Bir diğer yol, qubit parametrelerini EstimatorParams sınıfınaQubitParams kullanarak geçirmektir. Örneğin, kubit parametresini MAJ_NS_E6 seçmek için aşağıdaki kodu yazı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, adı belirtip diğer değerlerden herhangi birini güncelleştirerek özelleştirebilirsiniz. Örneğin, içindeki qubit_maj_ns_e4iki kubitli birleştirme ölçümlerinin hata oranını azaltmak için aşağıdaki kodu yazı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 "gate_based" Temel kubit teknolojisi
one_qubit_measurement_time zaman dizesi Ns cinsinden tek kubitli ölçüm ($t_{\rm meas}$) için işlem süresi
one_qubit_gate_time zaman dizesi Ns cinsinden tek kubitli kapı ($t_{\rm gate}$) için işlem süresi
two_qubit_gate_time zaman dizesi ns olarak iki kubitli kapı için işlem süresi
t_gate_time zaman dizesi Ns olarak Clifford olmayan tek kubitli kapı için işlem süresi
one_qubit_measurement_error_rate kayan noktalı sayı Tek kubitli ölçüm için hata oranı
one_qubit_gate_error_rate kayan noktalı sayı Tek kubitli Clifford kapısı ($p$) için hata oranı
two_qubit_gate_error_rate kayan noktalı sayı İki kubitli Clifford kapısı için hata oranı
t_gate_error_rate kayan noktalı sayı Clifford olmayan tek kubitli durumu ($p_T$) hazırlamak için hata oranı
idle_error_rate kayan noktalı sayı Aylaklık için 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, two_qubit_gate_error_rate ve t_gate_error_rate için varsayılan değer one_qubit_gate_error_rate, ve idle_error_rate için varsayılan değer one_qubit_measurement_error_rate.

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 dizesi Ns cinsinden tek kubitli ölçüm ($t_{\rm meas}$) için işlem süresi
two-qubit_joint_measurement_time zaman dizesi n cinsinden iki kubitli ölçüm için işlem süresi
t_gate_time zaman dizesi Ns olarak Clifford olmayan tek kubitli kapı için işlem süresi
one_qubit_measurement_error_rate kayan noktalı sayı Tek kubitli ölçüm için hata oranı
two_qubit_joint_measurement_error_rate kayan noktalı sayı İki kubitli ölçüm için hata oranı
t_gate_error_rate kayan noktalı sayı Clifford olmayan tek kubitli durumu ($p_T$) hazırlamak için hata oranı
idle_error_rate kayan noktalı sayı Aylaklık için karşılık gelen hata oranı

Tüm gerekli değerleri içeren Majorana tabanlı 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, two_qubit_joint_measurement_error_rate ve t_gate_error_rate için varsayılan değer one_qubit_measurement_error_rate, ve idle_error_rate için varsayılan değer one_qubit_measurement_error_rate.

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.

Önemli

Belirtilmeyen tüm değerler varsayılan bir değer alır. Örneğin, hem iki kubitli kapı süresinin hem de tek kubitli kapı süresinin 200 ns olduğu geçit tabanlı bir kubit modellemek "qubit": {"oneQubitGateTime":"200 ns"} . Birimler için, çift duyarlıklı kayan nokta sayıları olan zaman dizelerini ve ardından bu değerler için bir boşluk ve zaman birimini 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ı yürütmek 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. İlk olarak, QEC birden çok hataya açık fiziksel kubit oluşturmamıza ve kuantum bilgilerini temel alınan fiziksel kubitlerden daha iyi koruyan daha güvenilir bir mantıksal kubit oluşturmamıza olanak tanır.

Kaynak tahmin aracı, üstel bir model kullanarak mantıksal hata oranlarını modellemek için aşağıdaki 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. Çapraz ön faktör $a$ simülasyonlar için sayısal olarak ayıklanabilir.

$d$ kod uzaklığı, düzeltilebilen hata sayısını denetleen bir parametredir. Bu nedenle, kod uzaklığı mantıksal kubitlerin hata oranını ve bunları 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 ayarlanan 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 düzenleri genellikle hata düzeltmenin hataları gizlediği^*$ $p bir hata oranı eşiğine 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

Başka bir değer belirtilmediği sürece, QEC şeması için varsayılan değer "surface_code" olur.

Ö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. çalıştırırken "qecScheme"sınıfı için qsharp.estimate QEC modeli adını seçebilirsiniz. Örneğin, floquet kodunu seçmek için şunu yazın:

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

Ayrıca, sınıfını kullanarak tahmin parametrelerinin listesini sınıfına EstimatorParams geçirebilirsiniz. Örneğin, floquet kodunu seçmek için şunu yazı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, adı belirtip diğer değerlerden herhangi birini güncelleştirerek özelleştirebilirsiniz. Örneğin, floquet kodunda geçiş ön faktörünü artırmak için şunu yazın:

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

Not

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

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, tek bir mantıksal işlemi yürütme zamanı olan ve temel alınan fiziksel kubitlerin kod uzaklığı ve fiziksel işlem süresi varsayımlarına bağlı olan değerini belirtmeniz "logicalCycleTime"gerekir. Son olarak, ikinci 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, değerleri fiziksel kubit parametrelerinden karşılık gelen alandan one_qubit_gate_timetwo_qubit_gate_time yanı sıra fiziksel kubit özelliklerine, hata düzeltme eşiğine ve geçiş ön düzenlemesine göre mantıksal kubit için hesaplanan kod uzaklığı değişkenini one_qubit_measurement_time kullanabilirsiniz. ve zaman değişkenleri eccDistance formülü açıklamak logicalCycleTime için kullanılabilir. formül physicalQubitsPerLogicalQubit için yalnızca eccDistance kullanılabilir.

Hata bütçesi

Toplam hata bütçesi $\epsilon$ algoritma için genel tolere edilen hatayı, yani algoritmanın izin verilen hata olasılığını 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'un tamsayıları çarpanlara ayırma algoritmasını çalıştırıyorsanız, çıktıların gerçekten girişin en önemli faktörleri olup olmadığını denetleyebildiği için hata bütçesi için büyük bir değere tolerans gösterilebilir. Öte yandan, etkili bir şekilde doğrulanabilen bir çözümle ilgili bir sorunu çözen bir algoritma için daha küçük bir hata bütçesi gerekebilir.

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

Başka bir değer belirtilmediği 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.

Distilasyon ve döndürme sentezi için ilgili $\epsilon_{\rm dis}$ ve $\epsilon_{\rm syn}$ hata bütçelerinin sırasıyla tüm gerekli T durumları ve tüm gerekli döndürme geçitleri arasında eşit olarak dağıtıldığını unutmayın. 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

0 ile 1 arasında bir sayı ayarlayarak hata bütçesini belirtmenin iki yolu vardır. komutunu çalıştırırken qsharp.estimatehata bütçesini geçirebilirsiniz. Örneğin, 1/3 hata bütçesini seçmek için şunu yazın:

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

Hata bütçesi parametrelerini sınıfına EstimatorParamsda 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ürmeleri içermiyorsa ve t_states değerleri rotations 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

T fabrikası"constraints"uygulamak için sınıfını kullanabilirsiniz. Kısıtlamaları ayarlayarak, kubit sayısını azaltmaya veya çalışma zamanını azaltmaya yönelik tahminleri iyileştirebilirsiniz.

Parametre Veri türü Açıklama
logical_depth_factor kayan noktalı sayı 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. değerini azaltarak logical_depth_factor, belirli bir süre içinde T fabrikasının çağrı sayısını artırarak aynı sayıda T durumu üretmek için gereken T fabrika kopyasının daha az olmasına neden olabilirsiniz. T fabrika kopyalarının sayısını azalttığınızda algoritma çalışma zamanı buna göre artar. Ek döngü sayısı nedeniyle gerekli mantıksal hata oranı arttığından toplam çalışma zamanı için ölçeklendirme faktörü daha büyük olabilir.
max_t_factories integer En fazla T fabrika kopyası 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 bkz . T factory fiziksel tahmini.
max_duration zaman dizesi Algoritma için en yüksek çalışma zamanı. 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 integer 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. Eğer max_physical_qubits belirtilirse, kaynak tahmin aracı, belirtilen en yüksek sayı ile sınırlı çö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

Not

sağlanan max_duration veya max_physical_qubits değeri uygulanabilir bir çözüm bulmak için çok küçükse, kaynak tahmin aracı bir hata döndürür. Ne max_duration ne de max_physical_qubits kısıtlamaları belirtilmediğinde, kaynak tahmin aracı en kısa sürede bir çözüm bulmayı amaçlar.

İpucu

çözüm alanını etkileyip daha uzun çalışma zamanına ancak bu kısıtlamalara sahip olmayan çözümlere kıyasla daha az sayıda kubite sahip çözümler bulmak için ve max_duration kullanabilirsinizmax_physical_qubits. Çalışma zamanı ile kubit sayısı arasında bir denge vardır ve bu dengeleme bazı algoritmalar için verimli bir şekilde yönetilebilir ve farklı algoritmalar üzerinde değişen etkilere sahiptir. [arXiv:2211.07629] içindeki Tablo IV, kuantum dinamiği algoritmaları için kubit sayısı ve çalışma zamanı 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

Sınıfıyla DistillationUnitSpecificationT fabrikaları damıtma algoritmaları için belirtimler sağlayabilirsiniz. Belirtim önceden tanımlanmış veya özel olabilir. Damıtma birimi adını seçerek önceden tanımlanmış bir belirtim belirtebilirsiniz: 15-1 RM veya 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)

Her iki durumda da, 15-1 gösterimi 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 fazla çalışma zamanı 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 parametrelerin pozitif olması beklenir. , displayName distilasyon biriminin çıkış sonuçlarında nasıl görüntüleneceğini belirtir.

Aşağıdaki kod, sınıfını ve sınıfını kullanarak bir kuantum algoritması için distilasyon birimi parametrelerinin DistillationUnitSpecificationProtocolSpecificDistillationUnitSpecification 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

ve failure_probability_formula formüllerioutput_error_rate_formula, temel aritmetik işlemler, sabitler ve yalnızca üç parametre içeren özel formüllerdir:

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

Uzun ve kısa gösterimi kullanan aşağıdaki özel formül örneklerine bakın. Bu örnekler, standart uygulama içinde varsayılan olarak kullanılan formülleri gösterir.

Parametre Uzun formül Kısa formül
failure_probability_formula "15.0 * giriş_hata_oranı + 356.0 * clifford_hata_oranı" "15.0 * z + 356.0 * c"
output_error_rate_formula "35.0 * girdi_hata_oranı ^ 3 + 7.1 * clifford_hata_oranı" "35.0 * z ^ 3 + 7.1 * c"

Parametrelerden physical_qubit_specification en az biri veya logical_qubit_specification sağlanmalıdır. Yalnızca önceki sağlanırsa, damıtma birimi fiziksel kubitlere uygulanabilir. Yalnızca ikincisi sağlanmışsa, damıtma birimi mantıksal kubitlere uygulanabilir. Her ikisi de sağlanırsa, damıtma birimi her iki kubit türüne de uygulanabilir.

Parametre logical_qubit_specification_first_round_override yalnızca belirtilirse logical_qubit_specification sağlanabilir. Bu tür bir durumda, distilasyonun ilk turunda logical_qubit_specification uygulandığında değerleri geçersiz kılar. <protocol specific parameters> için gereken logical_qubit_specification_first_round_override değeri aşağıdaki şemaya sahip olmalıdır:

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

Pareto sınır tahmini

Bir algoritmanın kaynaklarını tahmin ederken, fiziksel kubit sayısı ile algoritmanın çalışma zamanı arasındaki dengeyi göz önünde bulundurmak önemlidir. Algoritmanın çalışma zamanını azaltmak için mümkün olduğunca çok fiziksel kubit ayırmayı düşünebilirsiniz. Ancak, fiziksel kubitlerin sayısı kuantum donanımında bulunan fiziksel kubit sayısıyla sınırlıdır. Çalışma zamanı ile sistem ölçeği arasındaki dengeyi anlamak, kaynak tahmininin en önemli yönlerinden biridir.

Pareto sınır tahmini, aynı algoritma için her biri kubit sayısı ile çalışma zamanı arasındaki dengeleri gösteren birden çok tahmin sağlar.

Not

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

Python'da kaynak tahmin aracını çalıştırırsanız 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 istiyorsanız işlevini kullanabilirsiniz EstimatesOverview . Bu işlevler, tablodaki sınır tahmininin sonuçlarını ve bir uzay-zaman diyagramı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