Spouštění hybridních úloh kvantových výpočtů s adaptivním target profilem

Hybridní computing kombinuje klasické a kvantové výpočetní procesy k řešení složitých problémů.

V hybridním computingu klasický kód řídí provádění kvantových operací na základě měření středního okruhu, zatímco fyzické qubity zůstávají aktivní. Pro řešení složitých problémů můžete v jednom kvantovém programu použít běžné programovací techniky, jako jsou vnořené podmínky, smyčky a volání funkcí, a tím snížit počet potřebných měření. Díky technikám opětovného použití qubitu můžou větší programy běžet na počítačích s menším počtem qubitů.

Tento článek vysvětluje, jak odesílat hybridní úlohy do Azure Quantum pomocí Adaptive RItarget profilu. Profil Adaptive RItarget nabízí podporu měření středního okruhu, toku řízení založeného na měření, resetování qubitu a klasického celočíselného výpočtu.

Požadavky

Pokud chcete odesílat Q# samostatné programy, potřebujete také následující požadavky:

Pokud chcete odeslat Python a Q# programy, potřebujete také následující požadavky:

  • Prostředí Pythonu s nainstalovaným Pythonem a Pipem

  • Nejnovější qdk balíček Python s volitelným azure doplňkem.

    pip install --upgrade "qdk[azure]"

Podporovaný targets

Pokud chcete spouštět hybridní úlohy kvantových výpočtů, musíte vybrat kvantového poskytovatele, který podporuje profil Adaptive RItarget.

V současné době je adaptivní target profil ve službě Azure Quantum podporován na Quantinuutargets.

Odesílání adaptivních úloh RI

Pokud chcete odesílat hybridní úlohy kvantových výpočtů, musíte profiltarget jako Adaptive RI, kde ri představuje "qubit Reset a Integer computations".

Profil Adaptive RItarget nabízí podporu měření středního okruhu, toku řízení založeného na měření, resetování qubitu a klasického celočíselného výpočtu.

Hybridní kvantové úlohy můžete do Azure Quantum odesílat jako Q# samostatné programy nebo programy v Pythonu + Q#. Pokud chcete nakonfigurovat target profil pro hybridní kvantové úlohy, prohlédnout si části následující.

Pokud chcete nakonfigurovat profil pro hybridní úlohy v editoru target Visual Studio Code, zvolte jednu z následujících možností:

  • Pokud soubor Q# není součástí Q# projektu, otevřete ho a zadejte @EntryPoint(Adaptive_RI) před operací vstupního bodu programu.

  • Q# Pokud je soubor součástí Q# projektu, přidejte do souboru projektu qsharp.json následující:

    {
  "targetProfile": "adaptive_ri"
}

Když nastavíte profil target na Adaptive RI, můžete svůj Q# program odeslat jako hybridní kvantovou úlohu do Quantinuum. Postupujte takto:

  1. Otevřete nabídku Zobrazení a zvolte Paleta příkazů, zadejte QDK: Připojit se k pracovnímu prostoru Azure Quantum a stiskněte Enter.
  2. Vyberte účet Azure a podle pokynů se připojte k preferovanému adresáři, předplatnému a pracovnímu prostoru.
  3. Po připojení vyberte ikonu Azure Quantum panelu Microsoft Quantum (vlevo dole).
  4. Rozšiřte svůj pracovní prostor a rozšiřte poskytovatele Quantinuum.
  5. Vyberte libovolné dostupné target Quantinuum, například quantinuum.sim.h2-1e.
  6. Výběrem ikony přehrávání napravo od target názvu zahájíte odesílání aktuálního Q# programu.
  7. Zadejte název pro identifikaci úlohy a počet snímků.
  8. Stisknutím klávesy Enter odešlete úlohu. Stav úlohy se zobrazí v dolní části obrazovky.
  9. Rozbalte úlohy a najeďte myší na úlohu, která zobrazuje časy a stav vaší úlohy.

Podporované funkce

Následující tabulka uvádí podporované funkce pro hybridní kvantové výpočty s Quantinuum v Azure Quantum.

Podporovaná funkce Poznámky
Hodnoty dynamiky Booleovské hodnoty a celá čísla, jejichž hodnota závisí na výsledku měření
Smyčky Pouze smyčky klasicky ohraničené
Libovolný tok řízení Použití větvení if/else
Měření středního obvodu Využívá klasické prostředky registru.
Opakované použití qubitu Podporováno
Klasické výpočty v reálném čase 64bitová zapsaná celočíselná aritmetika využívá klasické registrační prostředky.

Sada QDK poskytuje konkrétní zpětnou vazbu target, pokud vybraný Q# nepodporuje jazykové prvky target. Pokud program Q# při spouštění hybridních kvantových úloh obsahuje nepodporované funkce, zobrazí se vám chybová zpráva v době návrhu. Další informace najdete na stránce wikiwebuQIR.

Poznámka:

Pokud používáte Adaptive RI funkce, které target nepodporují, musíte vybrat příslušný Q#target profil, abyste získali odpovídající zpětnou vazbu.

Pokud chcete zobrazit podporované funkce v akci, zkopírujte následující kód do Q# souboru a přidejte další fragmenty kódu.

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 podporuje dynamické logické hodnoty a celá čísla, což znamená ty hodnoty a čísla, která závisí na výsledcích měření. Všimněte si, že r0 je typ Result, který lze použít ke generování dynamických logických a celočíselných hodnot.

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

Quantinuum podporuje dynamické logické hodnoty a celá čísla, ale nepodporuje dynamické hodnoty pro jiné datové typy, například double. Zkopírujte následující kód, abyste viděli zpětnou vazbu týkající se omezení dynamických hodnot.

    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

I když nejsou u některých datových typů podporovány dynamické hodnoty, je možné tyto datové typy stále používat se statickými hodnotami.

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

V určitých situacích se nedají použít ani dynamické hodnoty podporovaných typů. Například Quantinuum nepodporuje dynamická pole, tj. matice, jejichž velikost závisí na výsledku měření. Quantinuum nepodporuje ani dynamicky vázané smyčky. Zkopírujte následující kód, abyste viděli omezení dynamických hodnot.

    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 podporuje řídicí tok, včetně if/else větvení, pomocí statických i dynamických podmínek. Větvení dynamických podmínek se také označuje jako větvení na základě výsledků měření.

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

Quantinuum podporuje smyčky s klasickými podmínkami a včetně if výrazů.

    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 podporuje měření středního okruhu, tj. větvení na základě výsledků měření.

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

Odhad nákladů na hybridní úlohu kvantového computingu

Náklady na spuštění hybridní úlohy kvantového computingu na hardwaru Quantinuum můžete odhadnout spuštěním úlohy v emulátoru.

Po úspěšném spuštění v emulátoru:

  1. V pracovním prostoru Azure Quantum vyberte Správa úloh.
  2. Vyberte úlohu, kterou jste odeslali.
  3. V okně Podrobnosti úlohy vyberte možnost Odhad nákladů, abyste zjistili, kolik kreditů emulátoru Quantinuum bylo použito. Toto číslo přímo odpovídá počtu kvantových kreditů Quantinuum (HQC), které jsou potřeba ke spuštění úlohy na hardwaru Quantinuum.

Odhadované náklady

Poznámka:

Quantinuum rozbalí celý obvod a vypočítá náklady na všechny cesty kódu, ať už jsou podmíněně spuštěné nebo ne.

Ukázky hybridních kvantových výpočtů

Následující ukázky najdete v Q# úložišti ukázek kódu. Předvádějí aktuální sadu funkcí pro hybridní kvantové výpočty.

Tří qubitový kód opakování

Tato ukázka ukazuje, jak vytvořit tříkvantový opakovací kód, který lze použít k detekci a opravě chyb záměny bitů.

Využívá integrované funkce hybridního výpočetního prostředí ke zjištění počtu provedení opravy chyb, zatímco stav logického registru qubitu je koherentní.

Kód najdete v této ukázce.

Iterativní odhad fáze

Tento ukázkový program ukazuje odhad iterativní fáze v rámci Q#. Pomocí odhadu iterativní fáze vypočítá vnitřní součin mezi dvěma dvojrozměrnými vektory kódovanými na target qubitu a qubitem ancilla. Další řídicí qubit je také inicializován, což je jediný qubit používaný k měření.

Okruh začíná kódováním dvojice vektorů na qubitu target a qubitu ancilla. Potom použije operátor Oracle na celý registr, který je řízen řídicím qubitem, který je nastavený ve stavu $\ket +$. Řízený operátor Oracle generuje fázi ve stavu $\ket 1$ řídicího qubitu. To pak lze přečíst použitím brány H na řídicí qubit, aby fáze byla při měření pozorovatelná.

Kód najdete v této ukázce.

Poznámka:

Tento ukázkový kód napsali členové týmu KPMG Quantum v Austrálii a spadají pod licenci MIT. Ukazuje rozšířené možnosti Adaptive RItargets a využívá omezené smyčky, volání klasických funkcí za běhu, vnořené podmíněné příkazy if, měření uprostřed okruhu a opětovné použití qubitu.

Související obsah

  • Last updated on