İngilizce dilinde oku

Aracılığıyla paylaş

Kuantum kodunuzun hatalarını ayıklama ve test etme

  • Makale

Klasik programlamada olduğu gibi kuantum programlarının amaçlandığı gibi davranıp davranmadığını denetleyebilmek ve yanlış davranışı tanılayabilmek çok önemlidir. Bu makalede, Azure Quantum Development Kit tarafından kuantum programlarının test edilmesi ve hata ayıklaması için sunulan araçlar ele alınmaktadır.

Programınızda Q# hata ayıklama

Azure Quantum Development Kit (QDK) Visual Studio Code uzantısı, programlar için Q# bir hata ayıklayıcı içerir. Kesme noktaları ayarlayabilir, kodunuzda adım adım ilerleyebilir ve yalnızca yerel değişkenleri değil kubitlerin kuantum durumunu da izleyebilirsiniz.

Not

VS Code hata ayıklayıcısı yalnızca (.qs) dosyalarıyla Q# çalışır ve Jupyter Notebook'taki hücrelerle Q# çalışmaz. Jupyter Notebook hücrelerini test etme için bkz . Kodunuzu test etme.

Aşağıdaki örnekte hata ayıklayıcının temel özellikleri gösterilmektedir. VS Code hata ayıklayıcılarını kullanma hakkında tam bilgi için bkz . Hata Ayıklama.

VS Code'da, aşağıdaki kodla yeni bir .qs dosyası oluşturun ve kaydedin:

Q# 
import Microsoft.Quantum.Arrays.*;
import Microsoft.Quantum.Convert.*;

operation Main() : Result {
    use qubit = Qubit();
    H(qubit);
    let result = M(qubit);
    Reset(qubit);
    return result;
}
  1. Satır numarasının soluna tıklayarak satırda H(qubit) bir kesme noktası ayarlayın.
  2. Hata ayıklayıcı simgesini seçerek hata ayıklayıcı bölmesini açın ve Çalıştır ve Hata Ayıkla'ya tıklayın. Hata ayıklayıcı denetimleri ekranın en üstünde görüntülenir.
  3. Hata ayıklamaya başlamak ve kesme noktasına devam etmek için F5'i seçin. Hata ayıklayıcı Değişkenleri bölmesinde Kuantum Durumu kategorisini genişletin. Kubitin |0> durumunda başlatıldığını görebilirsiniz.
  4. İşlemin H (F11) içine adımlayın ve işlemin kaynak kodu H görüntülenir. İşlemi adım adım ilerlettikçe, işlem kubiti süper pozisyona getirirken kuantum değerinin H değiştiğine dikkat edin.
  5. İşlemin üzerine (F10) M geçtikçe, ölçüm sonucunda kuantum değeri |0> veya |1> olarak çözümlenir ve klasik değişkenin result değeri görüntülenir.
  6. İşlemin Reset üzerinden geçtikçe kubit |0> olarak sıfırlanır.

Kodunuza test etme

Jupyter Notebook'taki hücreler için Q# VS Code Q# hata ayıklayıcısı kullanılamasa da, Azure QDK kodunuzun sorunlarını gidermeye yardımcı olabilecek bazı ifadeler ve işlevler sağlar.

Başarısız ifadesi

İfade, fail programı durduran önemli bir hataya karşılık gelen hesaplamayı tamamen sonlandırır.

Parametre değerini doğrulayan şu basit örneği göz önünde bulundurun:

Python 
# import qsharp package to access the %%qsharp magic command
import qsharp
Q# 
// use the %%qsharp magic command to change the cell type from Python to Q#
%%qsharp 
function PositivityFact(value : Int) : Unit {
    if value <= 0 {
        fail $"{value} isn't a positive number.";
    }   
}
PositivityFact(0);
Output 
Error: program failed: 0 isn't a positive number.
Call stack:
    at PositivityFact in line_2
Qsc.Eval.UserFail

  × runtime error
  ╰─▶ program failed: 0 isn't a positive number.
   ╭─[line_2:5:1]
 5 │ 
 6 │             fail $"{value} isn't a positive number.";
   ·             ────────────────────┬───────────────────
   ·                                 ╰── explicit fail
 7 │     }   
   ╰────

Burada ifade, fail programın geçersiz verilerle çalışmaya devam etmesini engeller.

Fact() işlevi

Ad alanından işlevini Microsoft.Quantum.Diagnostics kullanarak önceki örnekle Fact() aynı davranışı uygulayabilirsiniz. İşlev, Fact() belirli bir klasik koşulu değerlendirir ve false ise bir özel durum oluşturur.

Python 
import qsharp
Q# 
%%qsharp
function PositivityFact(value : Int) : Unit {
    Fact(value > 0, "Expected a positive number."); 
}
PositivityFact(4);
Output 
Error: program failed: Expected a positive number.
Call stack:
    at Microsoft.Quantum.Diagnostics.Fact in diagnostics.qs
    at PositivityFact in line_4
Qsc.Eval.UserFail

  × runtime error
  ╰─▶ program failed: Expected a positive number.
    ╭─[diagnostics.qs:29:1]
 29 │         if (not actual) {
 30 │             fail message;
    ·             ──────┬─────
    ·                   ╰── explicit fail
 31 │         }
    ╰────

DumpMachine() işlevi

DumpMachine(), makinenin geçerli durumu target hakkındaki bilgileri konsola döküm etmenizi ve programınızı çalıştırmaya devam etmenizi sağlayan bir Q# işlevdir.

Not

Azure Quantum Development KitDumpMachine() sürümüyle işlev artık çıktısı için büyük endian sıralamasını kullanıyor.

Python 
import qsharp
Q# 
%%qsharp
import Microsoft.Quantum.Diagnostics.*;
operation MultiQubitDumpMachineDemo() : Unit {
    use qubits = Qubit[2];
    X(qubits[1]);
    H(qubits[1]);
    DumpMachine();

    R1Frac(1, 2, qubits[0]);
    R1Frac(1, 3, qubits[1]);
    DumpMachine();
    
    ResetAll(qubits);
}
MultiQubitDumpMachineDemo();
Output 
Basis State
(|𝜓₁…𝜓ₙ⟩)	Amplitude	Measurement Probability	Phase
|00⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000
|01⟩	−0.7071+0.0000𝑖	 50.0000%	↓	-3.1416

Basis State
(|𝜓₁…𝜓ₙ⟩)	Amplitude	Measurement Probability	Phase
|00⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000
|01⟩	−0.6533−0.2706𝑖	 50.0000%	↙	-2.7489

dump_machine() işlevi

dump_machine , ayrılmış geçerli kubit sayısını ve ayrıştırabileceğiniz seyrek durum genliklerinin Python sözlüğü döndüren bir Python işlevidir. Jupyter Notebook'ta bu işlevlerden birini kullanmak, işlemlerinizde hata ayıklayıcı gibi adım adım ilerleyebilirsiniz. Önceki örnek programı kullanarak:

Python 
import qsharp
Q# 
%%qsharp
use qubits = Qubit[2];
X(qubits[0]);
H(qubits[1]);
Python 
dump = qsharp.dump_machine()
dump
Output 

Basis State
(|𝜓₁…𝜓ₙ⟩)	Amplitude	Measurement Probability	Phase
|10⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000
|11⟩	0.7071+0.0000𝑖	 50.0000%	↑	0.0000
Q# 
%%qsharp
R1Frac(1, 2, qubits[0]);
R1Frac(1, 3, qubits[1]);
Python 
dump = qsharp.dump_machine()
dump
Output 
Basis State
(|𝜓₁…𝜓ₙ⟩)	Amplitude	Measurement Probability	Phase
|10⟩	0.5000+0.5000𝑖	 50.0000%	↗	0.7854
|11⟩	0.2706+0.6533𝑖	 50.0000%	↗	1.1781
Python 
# you can print an abbreviated version of the values
print(dump)
Output 
STATE:
|10⟩: 0.5000+0.5000𝑖
|11⟩: 0.2706+0.6533𝑖
Python 
# you can access the current qubit count
dump.qubit_count
Output 
2
Python 
# you can access individual states by their index
dump[2]
Output 
(0.5+0.5000000000000001j)
Python 
dump[3]
Output 
(0.27059805007309845+0.6532814824381883j)

CheckZero() ve CheckAllZero() işlemleri

CheckZero() ve CheckAllZero() bir Q# kubit veya kubit dizisinin geçerli durumunun |0⟩ olup olmadığını denetleyebilen işlemlerdir. CheckZero(), kubit |0⟩ durumundaysa ve false başka bir durumdaysa döndürürtrue. CheckAllZero()dizideki tüm kubitler |0⟩ durumundaysa ve false kubitler başka bir durumdaysa döndürürtrue.

Q# 
import Microsoft.Quantum.Diagnostics.*;

operation Main() : Unit {
    use qs = Qubit[2];
    X(qs[0]); 
    if CheckZero(qs[0]) {
        Message("X operation failed");
    }
    else {
        Message("X operation succeeded");
    }
    ResetAll(qs);
    if CheckAllZero(qs) {
        Message("Reset operation succeeded");
    }
    else {
        Message("Reset operation failed");
    }
}

dump_operation() işlevi

dump_operation bir işlemi veya işlem tanımını ve kullanılacak bir dizi kubiti alan ve işlemin çıkışını temsil eden karmaşık sayıların kare matrisini döndüren bir Python işlevidir.

uygulamasından qsharp.utilsiçeri aktarırsınızdump_operation.

Python 
import qsharp
from qsharp.utils import dump_operation

Bu örnekte tek kubitli kimlik kapısı ve Hadamard kapısı matrisi yazdırılır.

Python 
res = dump_operation("qs => ()", 1)
print(res)
res = dump_operation("qs => H(qs[0])", 1)
print(res)
Output 
[[(1+0j), 0j], [0j, (1+0j)]]
[[(0.707107+0j), (0.707107+0j)], [(0.707107+0j), (-0.707107-0j)]]

Ayrıca kullanarak qsharp.eval() bir işlev veya işlem tanımlayabilir ve ardından içinden bu işleve dump_operationbaşvurabilirsiniz. Daha önce temsil edilen tek kubit de

Python 
qsharp.eval("operation SingleQ(qs : Qubit[]) : Unit { }")

res = dump_operation("SingleQ", 1)
print(res)
Output 
[[(1+0j), 0j], [0j, (1+0j)]]

Bu örnekte ikinci kubite döndürme uygulamak için bir geçit kullanılır Controlled Ry

Python 
qsharp.eval ("operation ControlRy(qs : Qubit[]) : Unit {qs[0]; Controlled Ry([qs[0]], (0.5, qs[1]));}")

res = dump_operation("ControlRy", 2)
print(res)
Output 
[[(1+0j), 0j, 0j, 0j], [0j, (1+0j), 0j, 0j], [0j, 0j, (0.968912+0j), (-0.247404+0j)], [0j, 0j, (0.247404+0j), (0.968912+0j)]]

Aşağıdaki kod işlemi ApplySWAP tanımlar Q# ve matrisini iki kubitli kimlik işlemininkiyle birlikte yazdırır.

Python 
qsharp.eval("operation ApplySWAP(qs : Qubit[]) : Unit is Ctl + Adj { SWAP(qs[0], qs[1]); }")

res = dump_operation("qs => ()", 2)
print(res)
res = dump_operation("ApplySWAP", 2)
print(res)
Output 
[[(1+0j), 0j, 0j, 0j], [0j, (1+0j), 0j, 0j], [0j, 0j, (1+0j), 0j], [0j, 0j, 0j, (1+0j)]]
[[(1+0j), 0j, 0j, 0j], [0j, 0j, (1+0j), 0j], [0j, (1+0j), 0j, 0j], [0j, 0j, 0j, (1+0j)]]

kullanarak dump_operation() test işlemlerine daha fazla örnek, QDK'daki Test İşlemleri örnek sayfasında bulunabilir.