Kapcsolatcsoport beküldése a Cirq használatával az Azure Quantumba

Cikk
10/23/2024

Megtudhatja, hogyan küldhet be Cirq kvantumköröket a azure-quantumPython csomag használatával. A Cirq-kapcsolatcsoportokat elküldheti az Azure Quantumnak a beépített csomagokkal rendelkező Azure Quantum notebook azure-quantumPython használatával vagy a helyi gépről.

További információ: Kvantum-kapcsolatcsoportok.

Előfeltételek

A telepítés részleteiért lásd: QDK-bővítmény beállítása.

Azure Quantum-munkaterület az Azure-előfizetésben. Munkaterület létrehozásához lásd : Azure Quantum-munkaterület létrehozása.
A Python környezet és a Python Pip telepítve.
VS Code az Azure Quantum Development Kittel és Python a Telepített Jupyter-bővítményekkel.
Az Azure Quantum-csomag azure-quantum a [cirq] címkével, valamint a qsharp csomagokkal.ipykernel
```
python -m pip install --upgrade azure-quantum[cirq] qsharp ipykernel 
```
Feljegyzés

Ha a Jupyter Python kernel ipykernel nem észlelhető, a VS Code kérni fogja a telepítést.

Új Jupyter Notebook létrehozása

A VS Code-ban válassza a > megtekintése lehetőséget, majd a Létrehozás: Új Jupyter-jegyzetfüzet lehetőséget.
A jobb felső sarokban a VS Code észleli és megjeleníti a jegyzetfüzethez kiválasztott virtuális Python környezet verzióját és verziójátPython. Ha több Python környezettel rendelkezik, előfordulhat, hogy ki kell választania egy kernelt a jobb felső sarokban található kernelválasztóval. Ha nem észlelt környezetet, a beállítási információkért tekintse meg a VS Code Jupyter-jegyzetfüzeteit.

A szükséges importálás betöltése

A jegyzetfüzet első cellájában futtassa a következő kódot a szükséges importálások betöltéséhez:

import azure.quantum
from azure.quantum.cirq import AzureQuantumService

Csatlakozás az Azure Quantum szolgáltatáshoz

Az Azure Quantum szolgáltatáshoz való csatlakozáshoz a programnak szüksége lesz az erőforrás-azonosítóra és az Azure Quantum-munkaterület helyére.

Jelentkezzen be az Azure-fiókjába, https://portal.azure.com
Válassza ki az Azure Quantum-munkaterületet, és lépjen az Áttekintés elemre.
Másolja ki a mezők paramétereit.

Adjon hozzá egy új cellát, és használja a fiókadatait az Azure Quantum-munkaterülethez való csatlakozáshoz és objektumok létrehozásához WorkspaceAzureQuantumService .

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

service = AzureQuantumService(workspace)

Az összes listázása targets

Ezzel a targets()módszerrel listázhatja a targets munkaterület összes olyan elemét, amely futtathatja a kapcsolatcsoportot, beleértve az aktuális üzenetsor-időt és rendelkezésre állást.

Feljegyzés

Előfordulhat, hogy a targets munkaterületen lévő összes elem nem szerepel a listában – csak a targets Cirq- vagy OpenQASM-kapcsolatcsoportot elfogadó elemek lesznek itt felsorolva.

print(service.targets())

[<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h1-1e", avg. queue time=40 s, Available>,
<Target name="ionq.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Egyszerű kapcsolatcsoport létrehozása

Ezután hozzon létre egy egyszerű Cirq-kapcsolatcsoportot a futtatáshoz. Ez a kapcsolatcsoport az X kapu négyzetgyökét használja, amely natív az IonQ hardverrendszerben.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Válasszon egy target lehetőséget a program futtatásához

IonQ
Quantinuum

Futtatás IonQ-szimulátoron

Most már futtathatja a programot az Azure Quantum szolgáltatáson keresztül, és lekérheti az eredményt. Az alábbi cella beküld egy feladatot (az alapértelmezett IonQ-szimulátorba), amely 100 felvétellel futtatja a áramkört, megvárja, amíg a feladat befejeződik, és visszaadja az eredményeket.

result = service.run(program=circuit, repetitions=100, target="ionq.simulator")

Ez egy objektumot cirq.Result ad vissza.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Feladat költségének becslése

Mielőtt futtatna egy feladatot a QPU-n, meg kell becsülnie, hogy mennyibe fog kerülni a futtatás.

A legfrissebb díjszabási részletekért tekintse meg az IonQ díjszabását, vagy keresse meg a munkaterületet, és tekintse meg a díjszabási beállításokat a munkaterület "Szolgáltató" lapján a következő aka.ms/aq/myworkspaces keresztül.

Futtatás IonQ QPU-n

Az előző feladat az alapértelmezett szimulátoron futott. "ionq.simulator" Futtathatja azonban az IonQ hardverprocesszorán (kvantumprocesszor-egységen (QPU)) is. Az IonQ QPU-n való futtatáshoz adja meg argumentumként a következőt "ionq.qpu.aria-1"target :

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu.aria-1",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Ez ismét egy objektumot cirq.Result ad vissza.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Aszinkron modell feladatok használatával

Hosszú ideig futó áramkörök esetén hasznos lehet aszinkron módon futtatni őket. A service.create_job metódus egy Job objektumot ad vissza, amellyel lekérheti az eredményeket a feladat sikeres futtatása után.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

A feladat állapotának ellenőrzéséhez használja a következőt job.status():

print(job.status())

'completed'

Ha meg szeretné várni a feladat befejezését, majd lekérni az eredményeket, használja a blokkoló hívást job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Vegye figyelembe, hogy ez nem ad vissza objektumot cirq.Result . Ehelyett egy olyan eredményobjektumot ad vissza, amely az IonQ-szimulátorra jellemző, és a lövési adatok helyett állapot-valószínűségeket használ.

type(result)

cirq_ionq.results.SimulatorResult

Ha ezt objektummá cirq.Result szeretné alakítani, használja a következőt result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Futtatás Quantinuum-szimulátoron

Most már futtathatja a programot az Azure Quantum szolgáltatáson keresztül, és lekérheti az eredményt. Az alábbi cella elküld egy feladatot, amely 100 lövéssel futtatja a áramkört, megvárja a feladat befejezését, és visszaadja az eredményeket.

result = service.run(program=circuit, repetitions=100, target="quantinuum.sim.h1-1sc")

Ez egy objektumot cirq.Result ad vissza.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Az eredményeket hisztogramban ábrázolhatja:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

A hisztogramot vizsgálva észreveheti, hogy a véletlenszerű számgenerátor minden alkalommal 0-t ad vissza, ami nem túl véletlenszerű. Ennek az az oka, hogy bár az API Validator biztosítja, hogy a kód sikeresen fusson a Quantinuum hardveren, a 0 értéket is visszaadja minden kvantumméréshez. Egy valódi véletlenszám-generátorhoz kvantumhardveren kell futtatnia a kapcsolatcsoportot.

Feladat költségének becslése

Mielőtt futtatna egy feladatot a QPU-n, meg kell becsülnie, hogy mennyibe fog kerülni a futtatás.

A legfrissebb díjszabási részletekért tekintse meg az Azure Quantum díjszabását, vagy keresse meg a munkaterületet, és tekintse meg a díjszabási lehetőségeket a munkaterület "Szolgáltató" lapján a következő aka.ms/aq/myworkspaces keresztül.

Aszinkron munkafolyamat feladatok használatával

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-1sc"
)

A feladat állapotának ellenőrzéséhez használja a következőt job.status():

print(job.status())

'Waiting'

Ha meg szeretné várni a feladat befejezését, majd lekérni az eredményeket, használja a blokkoló hívást job.results():

result = job.results()
print(result)

    {'m_b': ['00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00']}

Vegye figyelembe, hogy ez nem ad vissza objektumot cirq.Result . Ehelyett a bitsztring mérési eredményeinek szótárát adja vissza, amelyet a mérési kulcs indexel.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Ha nem rendelkezik Azure-fiókkal, regisztráljon ingyenesen, és regisztráljon használatalapú fizetéses előfizetésre.
Egy Azure Quantum-munkaterület. További információ: Azure Quantum-munkaterület létrehozása.

Új jegyzetfüzet létrehozása a munkaterületen

Jelentkezzen be az Azure Portalra , és válassza ki a munkaterületet az előző lépésből.
A bal oldali panelen válassza a Jegyzetfüzetek lehetőséget.
Kattintson a Saját jegyzetfüzetek elemre, majd az Új hozzáadása parancsra.
Írja be a fájl nevét (például Cirq.ipynb), majd kattintson a Fájl létrehozása parancsra.

Amikor megnyílik az új jegyzetfüzet, automatikusan létrehozza az első cellához tartozó kódot az előfizetés és a munkaterület adatai alapján.

from azure.quantum import Workspace
workspace = Workspace ( 
  resource_id = "", # Add your resource_id 
  location = ""  # Add your workspace location (for example, "westus") 
)

Feljegyzés

Ha másként nem jelezzük, minden cellát úgy kell futtatnia, hogy a létrehozás során ne okozhasson fordítási problémákat.

A kód futtatásához kattintson a cella bal oldalán található háromszög "lejátszás" ikonra.

A szükséges importálás betöltése

Először egy további modult kell importálnia.

Kattintson a + Kód gombra egy új cella hozzáadásához, majd adja hozzá és futtassa a következő kódot:

from azure.quantum.cirq import AzureQuantumService

Csatlakozás az Azure Quantum szolgáltatáshoz

Ezután hozzon létre egy AzureQuantumService objektumot az workspace előző cella objektumával az Azure Quantum-munkaterülethez való csatlakozáshoz. Adjon hozzá egy új cellát a következő kóddal:

provider = AzureQuantumService(workspace)

Egyszerű kapcsolatcsoport definiálása

Ezután hozzon létre egy egyszerű Cirq-kapcsolatcsoportot a futtatáshoz. Ez a kapcsolatcsoport az X kapu négyzetgyökét használja, amely natív az IonQ hardverrendszerben.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Az összes listázása targets

Ezzel a targets()módszerrel listázhatja a targets munkaterület összes olyan elemét, amely futtathatja a kapcsolatcsoportot, beleértve az aktuális üzenetsor-időt és rendelkezésre állást.

Feljegyzés

Előfordulhat, hogy a targets munkaterületen lévő összes elem nem szerepel a listában – csak a targets Cirq- vagy OpenQASM-kapcsolatcsoportot elfogadó elemek lesznek itt felsorolva.

print("This workspace's targets:")
for target in service.targets():
     print(target)

This workspace's targets:
<Target name="quantinuum.qpu.h1-1", avg. queue time=0 s, Degraded>
<Target name="quantinuum.sim.h1-1sc", avg. queue time=1 s, Available>
<Target name="quantinuum.sim.h1-1e", avg. queue time=40 s, Available>
<Target name="ionq.simulator", avg. queue time=3 s, Available>
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>

Feljegyzés

A munkaterület teljes listája target eltérő lehet.

Válasszon egy target lehetőséget a program futtatásához

IonQ
Quantinuum

Futtatás az IonQ-szimulátoron

Ha ellenőrizni szeretné a kapcsolatcsoportot, mielőtt tényleges kvantumhardveren futtatja, használhatja az IonQ-szimulátort. ionq.simulator

Az alábbi cella elküld egy feladatot, amely 100 lövéssel futtatja a áramkört, megvárja a feladat befejezését, és visszaadja az eredményeket.

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

Ez egy objektumot cirq.Result ad vissza.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Az eredményeket hisztogramban ábrázolhatja:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Feladat költségének becslése

Mielőtt tényleges kvantumhardveren vagy kvantumfeldolgozó egységen (QPU) futtatna egy feladatot, meg kell becsülnie, hogy mennyibe fog kerülni a futtatás.

A legfrissebb díjszabási részletekért tekintse meg az IonQ díjszabását, vagy tekintse meg a díjszabási beállításokat a munkaterület Szolgáltatók paneljén. Az aktuális kreditállapot és -használat megtekintéséhez válassza a Kreditek és kvóták lehetőséget.

Futtatás IonQ QPU-n

Az előző feladat az alapértelmezett szimulátoron futott. ionq.simulator Futtathatja azonban az IonQ hardverprocesszorán vagy a Kvantumprocesszor-egységen (QPU) is. Az IonQ QPU-n való futtatáshoz adja meg argumentumként a következőt ionq.qpu.aria-1target :

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu.aria-1",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Feljegyzés

A kapcsolatcsoportok QPU-n való futtatásához szükséges idő az aktuális üzenetsor-időktől függ. Az átlagos üzenetsor-időt target a munkaterület Szolgáltatók paneljének kiválasztásával tekintheti meg.

Ez ismét egy objektumot cirq.Result ad vissza.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Aszinkron modell feladatok használatával

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

A feladat állapotának ellenőrzéséhez használja a következőt job.status():

print(job.status())

'completed'

Ha meg szeretné várni a feladat befejezését, majd lekérni az eredményeket, használja a blokkoló hívást job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Feljegyzés

A job.results() függvény nem ad vissza objektumot cirq.Result . Ehelyett egy olyan eredményobjektumot ad vissza, amely az IonQ-szimulátorra jellemző, és a lövési adatok helyett állapot-valószínűségeket használ.

type(result)

cirq_ionq.results.SimulatorResult

Ha ezt objektummá cirq.Result szeretné alakítani, használja a következőt result.to_cirq_result():

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Futtatás az API Validatoron

A kapcsolatcsoport tényleges kvantumhardveren való futtatása előtt a Quantinuum API Validatort használhatja. quantinuum.sim.h1-1sc

Adja hozzá a következő cellát, amely elküld egy feladatot a kapcsolatcsoport 100 lövéssel vagy ismétléssel való futtatásához, megvárja, amíg a feladat befejeződik, és visszaadja az eredményeket:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h1-1sc"
)

Ez egy objektumot cirq.Result ad vissza.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Az eredményeket hisztogramban ábrázolhatja:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Feladat költségének becslése

Mielőtt tényleges kvantumhardveren vagy kvantumfeldolgozó egységen (QPU) futtatna egy feladatot, meg kell becsülnie, hogy mennyibe fog kerülni a futtatás.

A legfrissebb díjszabási részletekért tekintse meg az Azure Quantum díjszabását, vagy tekintse meg a díjszabási beállításokat a munkaterület Szolgáltatók paneljén. Az aktuális kreditállapot és -használat megtekintéséhez válassza a Kreditek és kvóták lehetőséget.

Futtatás Quantinuum QPU-n

Miután sikeresen futtatta az API-érvényesítőt, és megbecsülte a QPU költségeit, ideje futtatni a kapcsolatcsoportot a hardveren.

Feljegyzés

Ugyanazt a run módszert és műveletet használja, mint korábban az API Validatorban a feladat elküldéséhez és az eredmények megjelenítéséhez:

result = service.run(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Láthatja, hogy az eredmények nagyjából 0 és 1 között vannak elosztva.

Cirq-kapcsolatcsoport eredménye a Quantinuum QPU-n

Aszinkron munkafolyamat feladatok használatával

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.qpu.h1-1"
)

A feladat állapotának ellenőrzéséhez használja a következőt job.status():

print(job.status())

'Waiting'

Ha meg szeretné várni a feladat befejezését, majd lekérni az eredményeket, használja a blokkoló hívást job.results():

result = job.results()
print(result)

{'m_b': ['11', '11', '00', '11', '00', '00', '00', '00', '11', '00', '00', '11', '00', '00', '00', '00', '11', '11', '11', '00', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '00', '00', '00', '11', '11', '00', '11', '00', '11', '11', '00', '00', '00', '11', '11', '00', '00', '11', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '11', '11', '00', '11', '11', '00', '00', '00', '11', '11', '11', '11', '11', '00', '00', '11', '00', '11', '11', '11', '11', '00', '11', '00', '00', '00', '01', '11', '11', '00', '00', '11', '11', '11', '11', '00', '00', '00', '11', '00', '11', '00']}

Feljegyzés

A job.results() függvény nem ad vissza objektumot cirq.Result . Ehelyett egy szótárt ad vissza a mérési kulcs által indexelt bitstring mérési eredményekről.

Fontos

Több kapcsolatcsoport elküldése egy feladaton jelenleg nem támogatott. Áthidaló megoldásként meghívhatja a metódust az backend.run egyes áramkörök aszinkron elküldéséhez, majd lekérheti az egyes feladatok eredményeit. Példa:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Megosztás a következőn keresztül:

Kapcsolatcsoport beküldése a Cirq használatával az Azure Quantumba

Előfeltételek

Új Jupyter Notebook létrehozása

A szükséges importálás betöltése

Csatlakozás az Azure Quantum szolgáltatáshoz

Az összes listázása targets

Egyszerű kapcsolatcsoport létrehozása

Válasszon egy target lehetőséget a program futtatásához

Futtatás IonQ-szimulátoron

Feladat költségének becslése

Futtatás IonQ QPU-n

Aszinkron modell feladatok használatával

Futtatás Quantinuum-szimulátoron

Feladat költségének becslése

Aszinkron munkafolyamat feladatok használatával

Előfeltételek

Új jegyzetfüzet létrehozása a munkaterületen

A szükséges importálás betöltése

Csatlakozás az Azure Quantum szolgáltatáshoz

Egyszerű kapcsolatcsoport definiálása

Az összes listázása targets

Válasszon egy target lehetőséget a program futtatásához

Futtatás az IonQ-szimulátoron

Feladat költségének becslése

Futtatás IonQ QPU-n

Aszinkron modell feladatok használatával

Futtatás az API Validatoron

Feladat költségének becslése

Futtatás Quantinuum QPU-n

Aszinkron munkafolyamat feladatok használatával

Visszajelzés

További források

Megosztás a következőn keresztül:

Kapcsolatcsoport beküldése a Cirq használatával az Azure Quantumba

Előfeltételek

Új Jupyter Notebook létrehozása

A szükséges importálás betöltése

Csatlakozás az Azure Quantum szolgáltatáshoz

Az összes listázása targets

Egyszerű kapcsolatcsoport létrehozása

Válasszon egy target lehetőséget a program futtatásához

Futtatás IonQ-szimulátoron

Feladat költségének becslése

Futtatás IonQ QPU-n

Aszinkron modell feladatok használatával

Előfeltételek

Új jegyzetfüzet létrehozása a munkaterületen

A szükséges importálás betöltése

Csatlakozás az Azure Quantum szolgáltatáshoz

Egyszerű kapcsolatcsoport definiálása

Az összes listázása targets

Válasszon egy target lehetőséget a program futtatásához

Futtatás az IonQ-szimulátoron

Feladat költségének becslése

Futtatás IonQ QPU-n

Aszinkron modell feladatok használatával

Kapcsolódó tartalom

Visszajelzés

További források