Sdílet prostřednictvím


Jak odesílat programy v Q# pomocí editoru Visual Studio Code

Naučte se používat Visual Studio Code k vytváření a odesílání programů Q# do skutečného kvantového hardwaru. Úlohy kvantového computingu můžete do Azure Quantum odesílat jako samostatný program Q#, kombinovat jazyk Q# s Pythonem v projektu Q# a spustit poznámkový blok Jupyter.

Odesílání úloh Q# do Azure Quantum

Naučte se používat VS Code ke spouštění, ladění a odesílání programu V# do Azure Quantum.

Požadavky

Podrobnosti o instalaci najdete v tématu Instalace sady QDK ve VS Code.

Načtení ukázkového programu v Q#

  1. Ve VS Code vyberte Soubor > nový textový soubor a uložte ho jako RandomNum.qs.

  2. Otevřete RandomNum.qs a zadejte sample, pak vyberte náhodný bit vzorek ze seznamu možností a uložte soubor.

    Snímek obrazovky se souborem Q# v editoru Visual Studio Code zobrazující seznam ukázek kódu při psaní ukázky slova v souboru

Poznámka:

Můžete také otevřít vlastní soubor q#. Pokud spustíte starší program Q# a narazíte na chyby, přečtěte si téma Testování a ladění.

Spuštění programu q#

  1. Pokud chcete program otestovat místně na integrovaném simulátoru, klikněte na Spustit ze seznamu níže uvedených @EntryPoint()příkazů nebo stiskněte Kombinaci kláves Ctrl+F5. Výstup se zobrazí v konzole ladění.

  2. Pokud chcete program před odesláním do Azure Quantum ladit, klikněte v seznamu níže uvedených příkazů na Ladit nebo stiskněte klávesu F5.@EntryPoint() Pomocí ovládacích prvků ladění v horní části můžete přejít k kódu a z tohoto kódu. Další informace o ladění programů v Q# naleznete v tématu Testování a ladění.

    Snímek obrazovky se souborem Q# v editoru Visual Studio Code zobrazující, kde najít objektiv kódu s příkazy pro spuštění a ladění

Vizualizace histogramu četnosti

Histogram frekvence představuje distribuci výsledků získaných z vícenásobného spuštění kvantového programu nebo "záběrů". Každý pruh v histogramu odpovídá možnému výsledku a jeho výška představuje počet pozorovaných výsledků. Histogram četnosti pomáhá vizualizovat rozdělení pravděpodobnosti těchto výsledků.

  1. Vyberte Zobrazit –> Paleta příkazů a zadejte histogram, který by měl zobrazit soubor Q#: Spustit soubor a zobrazit možnost histogramu . Můžete také kliknout na Histogram ze seznamu příkazů níže @EntryPoint(). Tuto možnost vyberte, pokud chcete otevřít okno histogramu Q#.

    Snímek obrazovky se souborem Q# v editoru Visual Studio Code zobrazující, kde najít objektiv kódu pomocí příkazu histogramu

  2. Zadejte počet snímků pro spuštění programu, například 100 snímků, a stiskněte Enter. Histogram se zobrazí v okně histogramu Q#.

  3. Kliknutím na ikonu nastavení vlevo nahoře zobrazíte možnosti.

    Snímek obrazovky s oknem histogramu Q# v editoru Visual Studio Code znázorňující, jak zobrazit nastavení

  4. Kliknutím na pruh zobrazíte procento tohoto výsledku. V tomto případě existují dva možné výsledky, 0 a 1 a procento každého výsledku se blíží 50 %.

    Snímek obrazovky s oknem histogramu Q# v editoru Visual Studio Code

Tip

Histogram můžete přiblížit pomocí kolečka myši nebo gesta trackpadu. Při přiblížení můžete graf posunout stisknutím klávesy Alt při posouvání.

Vizualizace kvantového okruhu

Diagramy kvantových obvodů představují vizuální znázornění kvantových operací. Zobrazují tok qubitů prostřednictvím kvantového programu, včetně bran a měření použitých na ně. Další informace najdete v tématu Diagramy kvantových obvodů v editoru Visual Studio Code.

  1. Vyberte Zobrazit –> Paleta příkazů a zadejte "okruh", který by měl vyvolat možnost Q#: Zobrazit okruh . Můžete také kliknout na Okruh ze seznamu příkazů níže @EntryPoint().

    Snímek obrazovky se souborem Q# v editoru Visual Studio Code zobrazující, kde najít příkaz okruhu Lens kódu

  2. Okruh se zobrazí v okně okruhu Q#. Diagram okruhu znázorňuje jeden qubitový registr, který je inicializován do stavu |0⟩. Pak se na qubit použije brána Hadamard H, následovaná měrnou operací, která je reprezentována symbolem měřiče. Další informace najdete v tématu Konvence kvantových obvodů.

    Snímek obrazovky s oknem okruhu Q# zobrazující výsledný diagram okruhu pro náhodnou bitovou operaci

Připojení k Azure Quantum a odeslání úlohy

Úlohy můžete připojit a odeslat přímo z editoru VS Code. V tomto příkladu odešlete úlohu do simulátoru Rigetti.

  1. Vyberte Zobrazit –> Paleta příkazů a zadejte Q#: Připojte se k pracovnímu prostoru Azure Quantum. Stiskněte klávesu Enter.

  2. Vyberte účet Azure a podle pokynů se připojte k preferovanému adresáři, předplatnému a pracovnímu prostoru.

    Poznámka:

    Pokud máte připojovací řetězec, můžete vybrat Připojovací řetězec a vložit připojovací řetězec odpovídající pracovnímu prostoru Azure Quantum. Další informace najdete v tématu Připojení k pracovnímu prostoru Quantum pomocí připojovací řetězec.

  3. Po připojení rozbalte v podokně Průzkumníka pracovní prostory Quantum.

  4. Rozbalte pracovní prostor a rozbalte poskytovatele Rigetti .

    Poznámka:

    Pokud dojde k problému s připojením k Azure Quantum, zobrazí se vedle názvu pracovního prostoru ikona upozornění. Najeďte myší na název pracovního prostoru, aby se zobrazily informace o chybě.

  5. Vyberte jako svůj targetsoubor rigetti.sim.qvm .

    Snímek obrazovky editoru Visual Studio Code znázorňující, jak vybrat simulátor Rigetti jako target.

  6. Výběrem ikony přehrávání napravo od target názvu zahájíte odesílání aktuálního programu Q#. Pokud se zobrazí místní nabídka, vyberte Změnit profil QIR target a pokračujte.

    Snímek obrazovky editoru Visual Studio Code znázorňující, jak spustit simulátor Rigetti jako target.

  7. Přidejte název pro identifikaci úlohy.

  8. Přidejte počet snímků nebo počet spuštění programu.

  9. Stisknutím klávesy Enter odešlete úlohu. Stav úlohy se zobrazí v dolní části obrazovky.

  10. Rozbalte úlohy a najeďte myší na úlohu, která zobrazuje časy a stav vaší úlohy.

  11. Pokud chcete zobrazit výsledky, vyberte ikonu cloudu vedle názvu úlohy, abyste si stáhli výsledky z úložiště pracovního prostoru a zobrazili ho ve VS Code.

    Snímek obrazovky editoru Visual Studio Code znázorňující, jak stáhnout a zobrazit výsledky kvantové úlohy

Odesílání úloh Jupyter Notebooks do Azure Quantum

Naučte se používat VS Code ke spouštění, ladění a odesílání poznámkového bloku Jupyter v Q# do Azure Quantum. Postup v tomto článku platí také pro poznámkové bloky Jupyter na místním serveru Nebo poznámkových blocích Jupyter na portálu Azure Quantum.

Požadavky

Podrobnosti o instalaci najdete v tématu Instalace sady QDK ve VS Code.

  • Pracovní prostor Azure Quantum ve vašem předplatném Azure Pokud chcete vytvořit pracovní prostor, přečtěte si téma Vytvoření pracovního prostoru Azure Quantum.

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

  • VS Code s nainstalovanými rozšířeními Azure Quantum Development Kit, Python a Jupyter

  • Azure Quantum qsharp, qsharp-widgetsa azure-quantum balíčky a ipykernel balíček.

    python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
    

Spuštění a otestování programu v místním simulátoru

  1. Ve VS Code vyberte paletu Zobrazit > příkaz a vyberte Vytvořit: Nový poznámkový blok Jupyter.

  2. V pravém horním rohu nástroj VS Code rozpozná a zobrazí verzi Pythonu a virtuálního prostředí Pythonu, které bylo vybráno pro poznámkový blok. Pokud máte více prostředí Pythonu, možná budete muset vybrat jádro pomocí nástroje pro výběr jádra v pravém horním rohu. Pokud nebylo zjištěno žádné prostředí, informace o nastavení najdete v poznámkových blocích Jupyter v editoru VS Code .

  3. V první buňce poznámkového bloku spusťte následující kód Pythonu a naimportujte potřebné moduly:

    import qsharp
    import azure.quantum
    
    • Modul qsharp aktivuje %%qsharp příkaz magic, který umožňuje zadat kód Q# přímo do buňky.
    • Tento azure-quantum modul poskytuje připojení k pracovnímu prostoru Azure Quantum.

    Poznámka:

    Pokud se nerozpozná jádro ipykernel Jupyter Pythonu, VS Code vás vyzve k jeho instalaci.

  4. Přidejte další buňku a zadejte tento kód Q#, který vrací počet náhodných bitů zadaný uživatelem:

    Poznámka:

    Všimněte si, že jakmile zadáte příkaz %%qsharpmagic, buňka poznámkového bloku se změní z Pythonu na Q#.

    %%qsharp
    
    operation Random() : Result {
        use q = Qubit();
        H(q);
        let result = M(q);
        Reset(q);
        return result
    }
    
    operation RandomNBits(N: Int): Result[] {
        mutable results = [];
        for i in 0 .. N - 1 {
            let r = Random();
            set results += [r];
        }
        return results
    }
    
  5. K otestování operace můžete použít metodu eval , která může volat libovolnou operaci Q#, která byla dříve definovaná v poznámkovém bloku:

    qsharp.eval("RandomNBits(4)")
    
    [Zero, One, One, Zero]
    
  6. Ke spuštění programu do místního simulátoru použijte metodu run . shotsZadejte , nebo kolikrát se má program spustit, a simulátor vrátí výsledky jako seznam Pythonu.

    qsharp.run("RandomNBits(4)", shots=10)
    
    [[One, One, One, One],
    [Zero, Zero, One, Zero],
    [One, Zero, Zero, One],
    [Zero, One, Zero, Zero],
    [One, Zero, One, One],
    [One, Zero, One, Zero],
    [One, One, One, Zero],
    [One, One, One, One],
    [Zero, Zero, Zero, One],
    [One, Zero, Zero, One]]
    

Vizualizace kvantového okruhu

Kvantové okruhy můžete vizualizovat qsharp-widgets pomocí balíčku. Tento balíček poskytuje widget, který vykresluje diagram kvantového obvodu jako obrázek SVG. Další informace najdete v tématu Diagramy kvantových obvodů s poznámkovými bloky Jupyter.

Přidejte do nové buňky následující kód pro vizualizaci okruhu:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Snímek obrazovky s poznámkovým blokem Jupyter, který ukazuje, jak vizualizovat okruh pro operaci Q#.

Další informace najdete v tématu Konvence kvantových obvodů.

Kompilace úlohy pomocí základního profilu

Při spouštění programů v místním kvantovém simulátoru můžete odeslat libovolný typ programu Q#. Hardware targets Azure Quantum ale zatím nepodporuje všechny funkce potřebné ke spuštění všech programů q#. Abyste mohli kompilovat a odesílat programy Q# do Azure Quantum, musíte nastavit profil target tak, aby q# řekl, jaké funkce target váš hardware podporuje. V současné době se jedná o základní profil. Další informace najdete v tématu Typy profilů v Azure Quantum.

Opětovné inicializace interpreta Q# a kompilace programu pomocí základního profilu:

  1. init K nastavení profilu použijte metodu:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)
    
  2. Vzhledem k tomu, že jste interpret znovu inicializovali, musíte znovu spustit kód s novým profilem:

    %%qsharp
    
    operation Random() : Result {
        use q = Qubit();
        H(q);
        let result = M(q);
        Reset(q);
        return result
    }
    
    operation RandomNBits(N: Int): Result[] {
        mutable results = [];
        for i in 0 .. N - 1 {
            let r = Random();
            set results += [r];
        }
        return results
    }
    
  3. Dále použijte metodu compile k určení operace nebo funkce, která je vstupním bodem programu. Tento kód se zkompiluje do formátu QIR, který se pak dá odeslat do libovolného kvantového hardwaru:

    MyProgram = qsharp.compile("RandomNBits(4)")
    

Připojení k Azure Quantum a odeslání úlohy

Teď, když máte program zkompilovaný do správného formátu, vytvořte azure.quantum.Workspace objekt pro připojení k Azure Quantum. K připojení použijete ID prostředku pracovního prostoru Azure Quantum. ID prostředku a umístění je možné zkopírovat ze stránky přehledu pracovního prostoru na webu Azure Portal.

  1. V nové buňce vyplňte ID prostředku a umístění z pracovního prostoru Azure Quantum:

    MyWorkspace = azure.quantum.Workspace(
        resource_id = "MyResourceID",
        location = "MyLocation"
    )
    
  2. get_targets Pomocí této metody můžete zobrazit dostupný hardware targets v pracovním prostoru:

    MyTargets = MyWorkspace.get_targets()
    print("This workspace's targets:")
    MyTargets
    
  3. Vyberte :rigetti.sim.qvmtarget

    MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")
    
  4. Nakonec pomocí submit metody odešlete program s jeho parametry a zobrazte výsledky:

    job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
    job.get_results()
    
    {'[0, 1, 1, 1]': 0.08,
     '[1, 1, 0, 0]': 0.1,
     '[0, 0, 1, 0]': 0.04,
     '[0, 1, 0, 0]': 0.05,
     '[1, 0, 1, 0]': 0.05,
     '[1, 0, 0, 0]': 0.07,
     '[0, 1, 0, 1]': 0.07,
     '[1, 0, 1, 1]': 0.07,
     '[0, 0, 0, 0]': 0.08,
     '[1, 1, 1, 0]': 0.05,
     '[0, 0, 0, 1]': 0.1,
     '[0, 0, 1, 1]': 0.04,
     '[0, 1, 1, 0]': 0.09,
     '[1, 0, 0, 1]': 0.04,
     '[1, 1, 1, 1]': 0.05,
     '[1, 1, 0, 1]': 0.02}
    
  5. Všechny vlastnosti úlohy jsou přístupné například:job.details

    print(job.details)
    print("\nJob name:", job.details.name)
    print("Job status:", job.details.status)
    print("Job ID:", job.details.id)
    
    {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
    Job name: MyQuantumJob
    Job status: Succeeded
    Job ID: 0150202e-9638-11ee-be2f-b16153380354
    

Další podrobnosti o úloze

Balíček azure.quantum Pythonu obsahuje další metody pro zobrazení podrobnějších dat úlohy.

  • job.get_results_histogram(): Tato metoda vrátí slovník výsledků a počet snímků pro každé jedinečné měření. Například výsledky pro předchozí úlohu by měly být

    print(job.get_results_histogram()) 
    
    {   
        '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
        '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
        '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
        '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
        '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
        '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
        '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
        '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
        '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
        '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
        '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
        '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
        '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
        '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
        '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
        '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
    }
    
  • job.get_results_shots() : Tato metoda vrátí seznam každého snímku výsledku. Například výsledky pro předchozí úlohu by měly být

    print(job.get_results_shots()) 
    
    [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]
    

Odesílání Pythonu s úlohami Q# do Azure Quantum

Zjistěte, jak pomocí VS Code napsat program Pythonu, který volá operace Q#, připojit se k Azure pomocí příkazů Pythonu nebo Azure CLI a odeslat úlohu.

Požadavky

Podrobnosti o instalaci najdete v tématu Instalace sady QDK ve VS Code.

Vytvoření a import operací Q#

qsharp Pomocí balíčku můžete ukládat funkce a operace v souborech Q# a vytvářet projekty Q#, které umožňují volání libovolného z nich z kódu Pythonu. To je užitečné hlavně v případě, že potřebujete spustit program, který přebírá vstupní parametry.

  1. Podle pokynů vytvořte projekt V jazyce Q#.

  2. Otevřete nový textový soubor, přidejte následující kód Q#, který vrátí uživatelem zadaný počet náhodných bitů, a uložte soubor do adresáře /src v projektu jako source.qs.

    Poznámka:

    Všimněte si, že tento kód Q# nemá @EntryPoint funkci jako program V# (viz Odesílání úloh Q# do Azure Quantum), ale vyžaduje obor názvů, na rozdíl od poznámkového bloku Jupyter (viz Odesílání úloh Poznámkového bloku Jupyter do Azure Quantum).

    namespace Sample {
    
      operation Random() : Result {
            use q = Qubit();
            H(q);
            let result = M(q);
            Reset(q);
            return result
      }
    
      operation RandomNBits(N: Int): Result[] {
            mutable results = [];
            for i in 0 .. N - 1 {
               let r = Random();
               set results += [r];
            }
            return results
      }
    }
    
  3. V kořenové složce projektu (se souborem qsharp.json ) otevřete jiný soubor a uložte ho jako randomNum.py.

  4. Přidejte následující kód pro import modulů qsharp a azure.quantum modulů.

    import qsharp
    import azure.quantum
    
  5. Dále přidejte kód, který definuje kořenovou složku projektu Q# a otestuje target operaci v místním simulátoru. Operace je volána oborem <názvů>.<operation_name( )> a v tomto případě předáváte počet náhodných bitů, které se mají vrátit.

    qsharp.init(project_root = '../MyProjectRootFolder')
    print(qsharp.eval("Sample.RandomNBits(4)"))
    
    [Zero, One, One, Zero]
    
  6. Můžete také otestovat operaci pomocí run metody, která předá další shots parametr, a vrátí výsledky v seznamu Pythonu. Nahraďte randomNum.pypředchozí příkaz print následujícím kódem:

    result = qsharp.run("Sample.RandomNBits(4)", shots=10)
    for x in result:
        print(x)
    
    [[One, One, One, One],
    [Zero, Zero, One, Zero],
    [One, Zero, Zero, One],
    [Zero, One, Zero, Zero],
    [One, Zero, One, One],
    [One, Zero, One, Zero],
    [One, One, One, Zero],
    [One, One, One, One],
    [Zero, Zero, Zero, One],
    [One, Zero, Zero, One]]
    

Kompilace úlohy pomocí základního profilu

Při spouštění programů v místním kvantovém simulátoru můžete odeslat libovolný typ programu Q#. Hardware targets Azure Quantum ale zatím nepodporuje všechny funkce potřebné ke spuštění všech programů q#. Abyste mohli kompilovat a odesílat programy V# do Azure Quantum, musíte nastavit svůj target profil tak, aby q# řekl, jaké funkce target váš hardware podporuje. V současné době se jedná o Base profil nebo Adpative_RI profil. Další informace najdete v tématu Typy profilů v Azure Quantum.

Poznámka:

V případě programů v Q# v editoru VS Code nastaví Base VS Code profil automaticky.

  1. init K nastavení profilu použijte metodu:

    qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
    

    Poznámka:

    Vzhledem k tomu, že znovu inicializujete stav qsharp, musíte parametr znovu nastavit project_root , aby kompilátor věděl, kde operaci najít RandomNBits . To bylo možné provést také v kroku 5 předchozího postupu.

  2. Pak použijte metodu compile k určení operace nebo funkce, která je vstupním bodem programu. Kompilovaný program je pak možné odeslat do libovolného kvantového hardwaru:

    MyProgram = qsharp.compile("Sample.RandomNBits(4)")
    

Připojení k Azure Quantum a odeslání úlohy

Ke službě Azure Quantum se můžete připojit a odeslat úlohu pomocí objektu vytvořeného Workspace v Pythonu nebo připojit a odeslat úlohu pomocí Azure CLI. Použití Azure CLI vyžaduje, abyste kompilovaný program uložili jako textový soubor a tento soubor odeslali pomocí příkazu rozhraní příkazového řádku.

Teď, když máte program zkompilovaný do správného formátu, vytvořte azure.quantum.Workspace objekt pro připojení k Azure Quantum. K připojení použijete ID prostředku pracovního prostoru Azure Quantum. ID prostředku a umístění je možné zkopírovat ze stránky přehledu pracovního prostoru na webu Azure Portal.

  1. Do pole , vyplňte ID prostředku a umístění z pracovního prostoru Azure Quantum následujícím kódem randomNum.py:

    workspace = azure.quantum.Workspace(
        resource_id = "MyResourceID",
        location = "MyLocation"
    )
    
  2. Použijte metodu get_targets k zobrazení dostupného hardwaru targets v pracovním prostoru:

    MyTargets = workspace.get_targets()
    print("This workspace's targets:")
    for x in MyTargets:
        print(x)
    
  3. Vyberte :rigetti.sim.qvmtarget

    MyTarget = workspace.get_targets("rigetti.sim.qvm")
    
  4. Nakonec použijte metodu submit k odeslání programu s jeho parametry. Výsledky úlohy se vrátí jako slovník Pythonu.

    job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
    results = job.get_results()
    print("\nResults: ", results)
    
  5. Pokud chcete extrahovat jenom hodnoty a zobrazit je:

    for x in results:
        print(x)
    
    [0, 0, 0, 0]
    0.3
    [1, 0, 0, 0]
    0.1
    [1, 1, 1, 1]
    0.3
    [0, 1, 1, 1]
    0.3
    
  6. Všechny vlastnosti úlohy jsou přístupné například:job.details

    print(job.details)
    print("\nJob name:", job.details.name)
    print("Job status:", job.details.status)
    print("Job ID:", job.details.id)
    
    {'additional_properties': {'isCancelling': False}, 'id': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
    Job name: MyPythonJob
    Job status: Succeeded
    Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f
    

Další podrobnosti o úloze

Balíček azure.quantum Pythonu obsahuje další metody pro zobrazení podrobnějších dat úlohy.

  • job.get_results_histogram(): Tato metoda vrátí slovník výsledků a počet snímků pro každé jedinečné měření. Například výsledky pro předchozí úlohu by měly být

    results = job.get_results_histogram()
    for x in results.items():
        print(x)
    
    {   
        '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30},  
        '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10},
        '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30},
        '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30}
    }
    
  • job.get_results_shots() : Tato metoda vrátí seznam každého snímku výsledku. Například výsledky pro předchozí úlohu by měly být

    print(job.get_results_shots()) 
    
    [ [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]