Użyj pakietu Microsoft Quantum Development Kit (QDK) Python, aby przesłać programy Q#, OpenQASM, Cirq, Qiskit i PennyLane do Azure Quantum.
Ten artykuł zawiera przykłady przesyłania zadań dla każdego obsługiwanego języka kwantowego lub struktury. Informacje o interaktywnym Q# lub OpenQASM przepływie pracy, który nie wymaga kodu Python, znajdziesz tutaj: Przesyłanie zadań za pomocą rozszerzenia QDK dla VS Code.
Wymagania wstępne
Konto platformy Azure z aktywną subskrypcją.
Obszar Azure Quantum roboczy. Aby go utworzyć, zobacz Tworzenie obszaru roboczegoAzure Quantum.
Python 3.10 lub nowszy.
Jeśli używasz notatnika Jupyter, środowiska Jupyter, takiego jak rozszerzenie Jupyter dla , oraz pakietu .
Zainstaluj Azure CLI przy użyciu quantum rozszerzenia .
az extension add --upgrade --name quantum
Zainstaluj najnowszą wersję qdkPython pakietu za pomocą dodatków azure i jupyter .
pip install --upgrade "qdk[azure,jupyter]"
Jeśli chcesz przesłać program Qiskit lub cirq, zainstaluj dodatki qiskit i Cirq.
pip install --upgrade "qdk[qiskit,cirq]"
Połącz z Azure Quantum obszarem roboczym
Przed przesłaniem zadania należy nawiązać połączenie z obszarem roboczym Azure Quantum . Moduł qdk.azure udostępnia obiekt Workspace do łączenia z obszarami roboczymi Azure Quantum. Aby nawiązać połączenie z obszarem roboczym, wykonaj następujące kroki.
Zaloguj się przy użyciu Azure CLI
Jeśli jeszcze tego nie zrobiono, zaloguj się do Azure z terminalu przed otwarciem notesu Jupyter.
az login
Jeśli nie zalogujesz się z terminalu, musisz uwierzytelnić się za każdym razem, gdy łączysz się z obszarem roboczym usługi Quantum za pośrednictwem usługi Python. Jeśli Twoje konto ma dostęp do wielu subskrypcji, ustaw subskrypcję, która zawiera Twój obszar roboczy Azure Quantum.
az account set --subscription <subscription-id>
Uruchom az login ponownie, gdy sesja wygaśnie lub gdy chcesz użyć innego konta Azure.
Pobierz identyfikator zasobu swojego obszaru roboczego
- Zaloguj się do portalu Azure.
- Przejdź do obszaru roboczego Quantum, w którym chcesz przesłać zadanie.
- Na stronie Przegląd znajdź i skopiuj identyfikator zasobu.
Połącz się z przestrzenią roboczą
Aby nawiązać połączenie z obszarem roboczym usługi Quantum, utwórz Workspace obiekt z skopiowanym identyfikatorem zasobu.
from qdk.azure import Workspace
workspace = Workspace(resource_id="") # Add your resource ID
Sprawdź połączenie i wyświetl targets dostępne w obszarze roboczym.
for target in workspace.get_targets():
print(target.name)
Aby uzyskać informacje o innych opcjach połączenia i uwierzytelniania, zobacz Nawiązywanie połączenia z Azure Quantum obszarem roboczym.
Note
Poniższe przykłady przesyłają zadania do symulatora targets. Dostępne targets w przestrzeni roboczej zależą od skonfigurowanych dostawców.
Przygotowywanie i przesyłanie programu
Wybierz kartę odpowiadającą językowi programowania kwantowego lub platformie.
Użyj modułu qdk.qsharp, aby zdefiniować lub załadować kod Q#, skompilować punkt wejścia do QIR i przesłać QIR do Azure Quantumtarget.
Definiowanie i kompilowanie Q# programu
Zainicjuj Q# z profilem targetQIR, który obsługuje Azure Quantumtarget.
from qdk import qsharp, TargetProfile
qsharp.init(target_profile=TargetProfile.Base)
Aby uzyskać więcej informacji na temat QIRtarget profilów, zobacz Azure QuantumQIRtarget profile w pliku QDK.
Zdefiniuj operację Q# . Na przykład użyj następującej RandomBit operacji.
qsharp.eval("""
operation RandomBit() : Result {
use q = Qubit();
H(q);
return MResetZ(q);
}
""")
Przetestuj operację na symulatorze lokalnym.
print(qsharp.run("RandomBit()", shots=10))
Skompiluj operację do QIR.
from qdk.qsharp import compile
program = compile("RandomBit()")
Prześlij Q# zadanie
Wybierz zgodny target z obszaru roboczego.
target = workspace.get_targets("rigetti.sim.qvm")
Prześlij skompilowany program.
job = target.submit(program, "qsharp-job", shots=100)
print("Job ID:", job.id)
Poczekaj na ukończenie zadania i pobierz jego wyniki.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Użyj modułu qdk.openqasm, aby skompilować kod źródłowy OpenQASM 3 do QIR, a następnie przesłać QIR do Azure Quantumtarget.
Definiowanie i kompilowanie OpenQASM programu
Zdefiniuj OpenQASMPython obwód jako ciąg.
qasm_source = """
OPENQASM 3.0;
include "stdgates.inc";
bit[2] c;
qubit[2] q;
h q[0];
cx q[0], q[1];
c = measure q;
"""
Skompiluj program na QIR.
from qdk.openqasm import compile
program = compile(qasm_source)
Prześlij zadanie OpenQASM
Wybierz element target , który akceptuje skompilowany program.
target = workspace.get_targets("ionq.simulator")
Prześlij skompilowany program.
job = target.submit(program, "openqasm-job", shots=100)
print("Job ID:", job.id)
Poczekaj na ukończenie zadania i pobierz jego wyniki.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
W przypadku programów sparametryzowanych OpenQASM powiąż wartości wejściowe przed przesłaniem zadania. Aby uzyskać więcej informacji na temat OpenQASM w QDK, zobacz Tworzenie programów OpenQASM w QDK.
Użyj polecenia AzureQuantumProvider z modułu qdk.azure, aby przesyłać zadania Qiskit do dostawcy Azure Quantum. Obiekt dostawcy wyświetla listę zgodnych Azure Quantumtargets i zwraca Qiskit zadania i wyniki.
Tworzenie obwodu Qiskit
from qiskit import QuantumCircuit
circuit = QuantumCircuit(3, 3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])
Prześlij zadanie Qiskit
Utwórz obiekt Azure Quantum provider z obszaru roboczego.
from qdk.azure.qiskit import AzureQuantumProvider
provider = AzureQuantumProvider(workspace)
Wypisz backendy, które akceptują obwody Qiskit.
for backend in provider.backends():
print(backend.name)
Wybierz backend i prześlij obwód.
backend = provider.get_backend("rigetti.sim.qvm")
job = backend.run(circuit, shots=100)
print("Job ID:", job.job_id())
print("Status:", job.status())
Poczekaj na ukończenie zadania i pobierz Qiskit wyniki.
result = job.result()
counts = result.get_counts(circuit)
print(counts)
Adapter Qiskit obsługuje format wejściowy Azure Quantum i przekształca odpowiedź dostawcy do wyniku Qiskit.
Qiskit wyniki zadania dla programów ze stratą kubitu
W przypadku uruchomienia programu niektóre sprzęty kwantowe mogą doświadczać utraty kubitów. Jeśli utrata kubitu występuje w dowolnym momencie podczas strzału Qiskit dla programu, to strzał zostanie usunięty z Azure Quantum wyników zadania. Jeśli na przykład utrata kubitu przypada w 10 na 200 strzałów, wyniki zadania mają 190 łącznych liczb pomiarów.
Nieprzetworzone wyniki dla wszystkich strzałów, w tym strzałów, w których wystąpiła utrata kubitu, są nadal dostępne w obiekcie results. Poniższy kod pobiera oba zestawy wyników.
# Get results only for shots without qubit loss
print('Counts:', result.results[0].data.counts)
print('Probabilities:', result.results[0].data.probabilities)
print('Memory:', result.results[0].data.memory)
# Get the raw total shot results
print('Raw counts:', result.results[0].data.raw_counts)
print('Raw probabilities:', result.results[0].data.raw_probabilities)
print('Raw memory:', result.results[0].data.raw_memory)
W przypadku zadań lub targets, które nie wiążą się z utratą kubitu, domyślne wyniki i nieprzetworzone wyniki są identyczne.
Note
Atrybut Qiskit wyników zadania memory to lista wyników pomiarów dla każdego strzału.
Użyj AzureQuantumService z modułu qdk.azure, aby przekazywać zadania Cirq do dostawcy Azure Quantum. Obiekt usługi wymienia zgodne Azure Quantumtargets i zwraca wyniki natywne dla Cirq lub dostawcy.
Tworzenie obwodu Cirq
import cirq
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.H(q0),
cirq.CX(q0, q1),
cirq.measure(q0, q1, key="result"),
)
Prześlij zadanie Cirq
Azure Quantum Utwórz obiekt usługi.
from qdk.azure.cirq import AzureQuantumService
service = AzureQuantumService(workspace)
targets Wyświetl listę obwodów, które akceptująCirq.
for target in service.targets():
print(target.name)
Utwórz zadanie asynchroniczne.
job = service.create_job(
program=circuit,
repetitions=100,
target="ionq.simulator",
)
print("Status:", job.status())
Poczekaj na ukończenie zadania i pobierz jego wyniki.
result = job.results()
print(result)
Format wyników zależy od dostawcy oraz target. Niektóre obiekty wynikowe dostawcy można przekonwertować na cirq.Result obiekt.
Przekonwertuj węzeł kwantowy PennyLane na OpenQASM, skompiluj QIR do QIR i prześlij target do Azure QuantumOpenQASM.
Tworzenie obwodu PennyLane
Poniższy obwód jest obwodem sparametryzowanym. Wpływ bramy RY zależy od kąta theta.
import pennylane as qml
device = qml.device("default.qubit", wires=2)
@qml.qnode(device)
def circuit(theta):
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
qml.RY(theta, wires=1)
return qml.expval(qml.PauliZ(1))
Konwertowanie obwodu na QIR
Przekonwertuj sparametryzowany obwód na OpenQASM dla określonej wartości parametru.
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
Skompiluj OpenQASM do QIR przy użyciu zgodnego profilu target.
from qdk import TargetProfile
from qdk.openqasm import compile
program = compile(qasm_source, TargetProfile.Base)
Prześlij zadanie PennyLane
Wybierz zgodny target element i prześlij element QIR.
target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)
print("Job ID:", job.id)
Poczekaj na ukończenie zadania i pobierz jego wyniki.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Format wyników zależy od dostawcy i target.
Azure Quantum nie zwraca PennyLane wyników z węzła kwantowego z przesłanego QIR.
Treści powiązane