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
Warning
Od 11 stycznia 2027 r. Azure Quantum wymaga, aby użytkownicy w obszarze roboczym Quantum mieli rolę Czytelnik danych obszaru roboczego Quantum lub Współautor danych obszaru roboczego Quantum, aby wyświetlać wyniki zadań. Do przesyłania zadań będzie wymagana rola Współautor danych obszaru roboczego Quantum. Aby uniknąć przerw w przepływach Azure Quantum pracy, przypisz te role do odpowiednich użytkowników przed upływem terminu. Aby uzyskać więcej informacji, zobacz Przypisywanie ról dostępu do danych dla użytkowników w obszarze 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 OpenQASM zadanie
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 Qiskit zadanie
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 polecenia AzureQuantumService z modułu qdk.azure, aby przesyłać 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 Cirq zadanie
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 PennyLane zadanie
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 oraz target.
Azure Quantum nie zwraca PennyLane wyników z węzła kwantowego z przesłanego QIR.
Treści powiązane