Uyarlamalı target bir profille hibrit kuantum bilgi işlem işleri çalıştırma

Karma bilgi işlem, karmaşık sorunları çözmek için klasik ve kuantum bilişim süreçlerini birleştirir.

Karma bilgi işlemde klasik kod, fiziksel kubitler etkin kalırken orta devre ölçümlerine göre kuantum işlemlerinin yürütülmesini denetler. Karmaşık sorunları çalıştırmak için tek bir kuantum programında iç içe geçmiş koşullular, döngüler ve işlev çağrıları gibi yaygın programlama tekniklerini kullanarak gereken çekim sayısını azaltabilirsiniz. Kubit yeniden kullanma teknikleriyle, daha büyük programlar daha az sayıda kubit kullanarak makinelerde çalıştırılabilir.

Bu makalede, profili kullanarak Azure Quantum'a karma işleri gönderme işlemi Adaptive RItarget açıklanmaktadır. Profil, Adaptive RItarget orta devre ölçümleri, ölçüm tabanlı denetim akışı, kubit sıfırlama ve klasik tamsayı hesaplama desteği sunar.

Önkoşullar

Etkin aboneliği olan bir Azure hesabı. Azure hesabınız yoksa ücretsiz kaydolun ve kullandıkça öde aboneliğine kaydolun.
Azure Quantum çalışma alanı. Daha fazla bilgi için bkz . Azure Quantum çalışma alanı oluşturma.

Tek başına programlar göndermek Q# istiyorsanız aşağıdaki önkoşullara da ihtiyacınız vardır:

Visual Studio Code'u (VS Code) yükleyin.
Microsoft Quantum Development Kit uzantısının en son sürümünü yükleyin.

Python ve Q# programları göndermek istiyorsanız aşağıdaki önkoşullara da ihtiyacınız vardır:

Python ve Pip'in yüklü olduğu bir Python ortamı.
En son qdk Python kitaplığı, isteğe bağlı azure ekstra ile birlikte.
```
pip install --upgrade "qdk[azure]"
```

Destekli targets

Hibrit kuantum bilişim işlerini çalıştırmak için profili destekleyen Adaptive RItargetbir kuantum sağlayıcısı seçmeniz gerekir.

Şu anda Azure Quantum'daki uyarlamalı target profil, Quantinuumtargets üzerinde desteklenmektedir.

Uyarlamalı RI işlerini gönderme

Hibrit kuantum hesaplama işleri göndermek için, profilitarget olarak yapılandırmanız gerekir; burada RI, "Adaptive RIqubit Reset" anlamına gelirInteger computations.

Profil, Adaptive RItarget orta devre ölçümleri, ölçüm tabanlı denetim akışı, kubit sıfırlama ve klasik tamsayı hesaplama desteği sunar.

Hibrit kuantum işlerini Azure Quantum'a tek başına programlar veya Python + Q# programlar olarak Q# gönderebilirsiniz. Hibrit kuantum işleri için target profilini yapılandırmak üzere aşağıdaki bölümlere bakın.

Q# Visual Studio Code'da
Q# + Python

Visual Studio Code'da karma işler için profili yapılandırmak target için aşağıdaki seçeneklerden birini belirleyin:

Dosyanız Q# bir Q# projenin parçası değilse, dosyayı açın ve programınızın başlangıç işleminden önce @EntryPoint(Adaptive_RI) giriniz.
Dosyanız Q# bir Q# projenin parçasıysa, projenizin qsharp.json dosyasına aşağıdakileri ekleyin:
```
{
  "targetProfile": "adaptive_ri"
}
```

Profilinizi target olarak Adaptive RIayarladığınızda programınızı Q# karma kuantum işi olarak Quantinuum'a gönderebilirsiniz. Bunu yapmak için şu adımları izleyin:

Görünüm menüsünü açın ve Komut Paleti'ni seçin, QDK: Azure Quantum çalışma alanına bağlanma yazın ve Enter tuşuna basın.
Azure hesabı'nı seçin ve tercih ettiğiniz dizine, aboneliğe ve çalışma alanına bağlanmak için istemleri izleyin.
Bağlandıktan sonra , Gezgin bölmesinde Quantum Çalışma Alanları'nı genişletin.
Çalışma alanınızı genişletin ve Quantinuum sağlayıcısını genişletin.
Mevcut Quantinuum seçeneklerinden biri olan target, örneğin quantinuum.sim.h2-1e'yi seçin.
Geçerli target programını göndermeye başlamak için Q# adının sağında yer alan oynat simgesini seçin.
İşi ve çekim sayısını tanımlamak için bir ad girin.
İşi göndermek için Enter tuşuna basın. İş durumu ekranın en altında görüntülenir.
İşler'i genişletin ve işinizin üzerine gelin ve işinizin zamanlarını ve durumunu görüntüleyin.

qdk Python paketiyle, init ve TargetProfile nesnelerini kullanarak target_profile parametresini Adaptive_RI olarak ayarlayın.
```
from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)
```

Azure Quantum çalışma alanınıza bağlanın.

from qdk.azure import Workspace

workspace = Workspace(resource_id="") # add your resource ID

target parametresini, kullanmak istediğiniz Quantinuum target olarak ayarlayın. Örneğin, quantinuum.sim.h2-1e ve target kullanmak için:
```
target = workspace.get_targets("quantinuum.sim.h2-1e")
```

işlevini kullanarak bir target.open_session içinde birden çok karma kuantum işini birleştirebilirsiniz. Daha fazla bilgi için bkz Oturumları kullanmaya başlama.

Not

Oturumlar tüm kuantum bilgi işlem donanım sağlayıcıları için kullanılabilir olsa da, Adaptive_RItarget profil işleri şu anda yalnızca Quantinuum targetsüzerinde desteklenmektedir.

Desteklenen özellikler

Aşağıdaki tabloda, Azure Quantum'da Quantinuum ile hibrit kuantum bilişimi için desteklenen özellikler listelenmiştir.

Desteklenen özellik	Notlar
Dynamics değerleri	Değeri bir ölçüm sonucuna bağlı olan bools ve tamsayılar
Döngüler	Yalnızca klasik sınırlanmış döngüler
Rastgele denetim akışı	if/else dallanma kullanımı
Orta devre ölçümü	Klasik kayıt kaynaklarını kullanır
Kübit yeniden kullanımı	Desteklenir
Gerçek zamanlı klasik işlem	64 bit imzalı tamsayı aritmetik, klasik yazmaç kaynaklarını kullanır

QDK, target dil özellikleri seçilen Q# için desteklenmediğinde, target ile ilgili özel geri bildirim sağlar. Karma kuantum işlerini çalıştırdığınızda programınız Q# desteklenmeyen özellikler içeriyorsa, tasarım zamanında bir hata iletisi alırsınız. Daha fazla bilgi için wiki sayfasına bakınQIR.

Not

Kullanmakta olduğunuz ve Adaptive RI'ün desteklemediği target özellikleri için uygun geri bildirim almak amacıyla uygun Q#target profili seçmeniz gerekir.

Desteklenen özellikleri çalışır durumda görmek için aşağıdaki kodu bir Q# dosyaya kopyalayın ve sonraki kod parçacıklarını ekleyin.

import Std.Measurement.*;
import Std.Math.*;
import Std.Convert.*;

operation Main() : Result {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);
    let r0 = MResetZ(q0);

    // Copy here the code snippets below to see the supported features 
    // in action.
    // Supported features include dynamic values, classically-bounded loops, 
    // arbitrary control flow, and mid-circuit measurement.

    r0
}

Quantinuum, ölçüm sonuçlarına bağlı olan bool'lar ve tamsayılar anlamına gelen dinamik bool'ları ve tamsayıları destekler. r0 Dinamik bool ve tamsayı değerleri oluşturmak için kullanılabilecek bir Result tür olduğunu unutmayın.

    let dynamicBool = r0 != Zero; 
    let dynamicBool = ResultAsBool(r0); 
    let dynamicInt = dynamicBool ? 0 | 1;

Quantinuum dinamik boolları ve tamsayıları destekler, ancak çift gibi diğer veri türleri için dinamik değerleri desteklemez. Dinamik değerlerin sınırlamalarıyla ilgili geri bildirimleri görmek için aşağıdaki kodu kopyalayın.

    let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
    let dynamicInt = r0 == One ? 1 | 0;
    let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
    let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Bazı veri türleri için dinamik değerler desteklenmese de, bu veri türleri statik değerlerle kullanılabilir.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Desteklenen türdeki dinamik değerler bile belirli durumlarda kullanılamaz. Örneğin Quantinuum, boyutu ölçüm sonucuna bağlı olan dinamik dizileri, yani dizileri desteklemez. Quantinuum dinamik olarak sınırlanmış döngüleri de desteklemez. Dinamik değerlerin sınırlamalarını görmek için aşağıdaki kodu kopyalayın.

    let dynamicInt = r0 == Zero ? 2 | 4;
    let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
    let staticallySizedArray = [0, size = 10];
    // Loops with a dynamic condition are not supported by Quantinuum.
    for _ in 0..dynamicInt {
         Rx(PI(), q1);
    }
        
    // Loops with a static condition are supported.
    let staticInt = 3;
    for _ in 0..staticInt {  
         Rx(PI(), q1);  
    }

Quantinuum, hem statik hem de dinamik koşulları kullanarak dallanma da dahil olmak üzere if/else denetim akışını destekler. Dinamik koşullarda dallanma, ölçüm sonuçlarına göre dallanma olarak da bilinir.

    let dynamicInt = r0 == Zero ? 0 | 1; 
    if dynamicInt > 0 {
        X(q1);
     }
    let staticInt = 1;
    if staticInt > 5 {
         Y(q1);
    } else {
         Z(q1);
    }

Quantinuum, klasik koşullara ve ifadelere sahip if döngüleri destekler.

    for idx in 0..3 {
        if idx % 2 == 0 {
            Rx(ArcSin(1.), q0);
            Rz(IntAsDouble(idx) * PI(), q1)
        } else {
            Ry(ArcCos(-1.), q1);
             Rz(IntAsDouble(idx) * PI(), q1)
        }
     }

Quantinuum, ölçüm sonuçlarına göre dallanma gibi orta devre ölçümlerini destekler.

    if r0 == One {
        X(q1);
    }
    let r1 = MResetZ(q1);
    if r0 != r1 {
        let angle = PI() + PI() + PI()* Sin(PI()/2.0);
        Rxx(angle, q0, q1);
    } else {
        Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
    }

Hibrit kuantum bilişim işinin maliyetini tahmin eder

önce işi bir öykünücüde çalıştırarak Quantinuum donanımında hibrit kuantum bilgi işlem işini çalıştırma maliyetini tahmin edebilirsiniz.

Öykünücüde başarıyla çalıştırıldıktan sonra:

Azure Quantum çalışma alanınızda İş yönetimi'ne tıklayın.
Gönderdiğiniz işi seçin.
İş ayrıntıları açılır penceresinde Maliyet Tahmini'ni seçin ve kaç eHQC (Quantinuum öykünücüsü kredisi) kullanıldığını görüntüleyin. Bu sayı, işi Quantinuum donanımında çalıştırmak için gereken HQC'lerin (Quantinuum kuantum kredileri) sayısına doğrudan çevrilir.

Maliyet tahmini

Not

Quantinuum tüm devreyi açar ve koşullu olarak yürütülüp yürütülmediklerine bakılmaksızın tüm kod yollarındaki maliyeti hesaplar.

Hibrit kuantum bilgi işlem örnekleri

Aşağıdaki örnekler kod örnekleri deposundaQ#. Hibrit kuantum bilişimi için geçerli özellik kümesini gösterir.

Üç kubitli yineleme kodu

Bu örnek, bit çevirme hatalarını algılamak ve düzeltmek için kullanılabilecek üç kubitli bir yineleme kodunun nasıl oluşturulacağını gösterir.

Mantıksal kubit yazmacının durumu tutarlıyken hata düzeltmesinin kaç kez gerçekleştirildiğini saymak için tümleşik karma bilgi işlem özelliklerinden yararlanıyor.

Kodu bu örnekte bulabilirsiniz.

Yinelemeli faz tahmini

Bu örnek program, Q# içinde yinelemeli bir faz tahminini gösterir. Yinelemeli faz tahmini kullanarak target qubit ve bir ancilla qubit üzerinde kodlanmış iki adet 2 boyutlu vektörün iç çarpımını hesaplar. Ölçüm için kullanılan tek kubit olan ek bir denetim kubiti de başlatılır.

Devre, target kubiti ve ancilla kubiti üzerindeki vektör çiftini kodlayarak başlar. Ardından, $\ket +$ durumunda ayarlanan kontrol kubiti tarafından kontrol edilen tüm yazmaç için bir Oracle işleci uygular. Denetlenen Oracle operatörü, denetim qubitinin $\ket 1$ durumunda bir faz oluşturur. Daha sonra, ölçüm sırasında fazı gözlemlenebilir kılmak için kontrol kubitine bir H kapısı uygulanarak okunabilir.

Kodu bu örnekte bulabilirsiniz.

Not

Bu örnek kod, Avustralya'daki KPMG Quantum ekibinin üyeleri tarafından yazılmıştır ve MIT Lisansı kapsamındadır. Adaptive RI targets işlevlerinin genişletilmiş yeteneklerini gösterir ve sınırlı döngüleri, çalışma zamanında klasik işlev çağrılarını, iç içe geçmiş if deyimlerini, orta devre ölçümlerini ve kubit yeniden kullanımını kullanır.

Oturumlarla başlamaya başla

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-12