使用 QDKPython 套件將工作提交到 Azure Quantum

使用 Q#（OpenQASM）Qiskit 套件，將 Cirq、PennyLane、Azure Quantum、Python 及 QDK 程式提交至 Microsoft Quantum Development Kit。

本文提供每種支援量子語言或框架的工作提交範例。 若要使用不需要Python程式碼的互動式Q#或OpenQASM工作流程，請參閱使用適用於QDK的VS Code擴充功能提交作業。

先決條件

• 一個有有效訂閱的 Azure 帳號。

• 工作區 Azure Quantum 要建立工作區，請參見 建立 Azure Quantum 工作區。

• Python 3.10 或更新版本。

• 如果你使用 Jupyter Notebook，可使用 Jupyter 環境，例如 VS Code 的 Jupyter 擴充功能和 ipykernel 套件。

• 安裝 Azure CLI 和 quantum 擴充功能。

  az extension add --upgrade --name quantum
  

• 安裝包含 jupyter 和 azure extras 的最新版本 qdkPython 套件。

  pip install --upgrade "qdk[azure,jupyter]"
  

  如果你想提交 Qiskit 或 Cirq 程式，請安裝 cirq 和 qiskit 額外套件。

  pip install --upgrade "qdk[qiskit,cirq]"
  

連線至你的 Azure Quantum 工作區

在提交工作之前，你需要先連接一個 Azure Quantum 工作區。 此 qdk.azure 模組提供 Workspace 物件，用於連線到 Azure Quantum 工作區。 要連接你的工作空間，請遵循以下步驟。

使用 Azure CLI 登入

如果你還沒登入，建議在開啟 Jupyter 筆記本前，先從終端機登入 Azure。

az login

如果你沒有從終端機登入，每次透過 Quantum 工作區 Python連線時都必須進行驗證。 如果你的帳號有多個訂閱，請設定包含你 Azure Quantum 工作區的訂閱。

az account set --subscription <subscription-id>

當會話結束或想使用其他 Azure 帳號時，再重新執行az login。

取得你工作空間的資源 ID

1. 登入 Azure 入口網站。
2. 前往您要提交作業的 Quantum 工作區。
3. 在 概覽 頁面，找到並複製 資源 ID。

連線到工作區

1. 若要連線到您的 Quantum 工作區，請使用您複製的資源 ID 建立一個 Workspace 物件。

   from qdk.azure import Workspace
   
   workspace = Workspace(resource_id="") # Add your resource ID
   

   Note

   是

2. 確認連線，並查看工作區中可用的 targets。

   for target in workspace.get_targets():
       print(target.name)
   

關於其他連線與認證選項，請參見 「連接至您的 Azure Quantum 工作區」。

Note

以下範例將工作提交至 模擬器 targets。 你工作空間中可用的 targets 取決於你已設定的提供者。

準備並提交你的程式

選擇適用於你的量子語言或架構的索引標籤。

Q#

使用 qdk.qsharp 模組來定義或載入 Q# 程式碼，編譯一個入口點到 QIR，並將 提交 QIR 給 Azure Quantumtarget。

定義並編譯程式Q#

1. 使用 Azure Quantumtarget 支援的 QIRtarget 設定檔初始化 Q#。

   from qdk import qsharp, TargetProfile
   
   qsharp.init(target_profile=TargetProfile.Base)
   

   如需更多關於 QIRtarget 設定檔的資訊，請參閱 Azure QuantumQIRtarget 設定檔（位於 QDK 中）。

2. 定義一個 Q# 操作。 例如，使用以下 RandomBit 運算。

   qsharp.eval("""
       operation RandomBit() : Result {
           use q = Qubit();
           H(q);
           return MResetZ(q);
       }
   """)
   

3. 在本地模擬器上測試操作。

   print(qsharp.run("RandomBit()", shots=10))
   

4. 將操作編譯為 QIR。

   from qdk.qsharp import compile
   
   program = compile("RandomBit()")
   

提交 Q# 作業

1. 從你的工作區選取相容的 target。

   target = workspace.get_targets("rigetti.sim.qvm")
   

2. 提交已編譯的程式。

   job = target.submit(program, "qsharp-job", shots=100)
   print("Job ID:", job.id)
   

3. 等待作業完成，並擷取其結果。

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

OpenQASM

使用模組 qdk.openqasm 編譯 OpenQASM 3 段原始碼至 QIR，然後提交 QIR 給 Azure Quantumtarget。

定義並編譯程式OpenQASM

1. 將 OpenQASM 電路定義為 Python 字串。

   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;
   """
   

2. 將程式編譯為 QIR。

   from qdk.openqasm import compile
   
   program = compile(qasm_source)
   

提交 OpenQASM 作業

1. 選擇可接受已編譯程式的 target。

   target = workspace.get_targets("ionq.simulator")
   

2. 提交已編譯的程式。

   job = target.submit(program, "openqasm-job", shots=100)
   print("Job ID:", job.id)
   

3. 等待工作完成後，再取得其結果。

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

對於參數化 OpenQASM 程式，請在提交作業前綁定輸入值。 如需更多有關 QDK 中 OpenQASM 的資訊，請參閱在 QDK 中開發 OpenQASM 程式。

Qiskit

使用 qdk.azure 模組中的 AzureQuantumProvider，將 Qiskit 作業提交給 Azure Quantum 提供者。 提供者物件會列出相容的 Azure Quantumtargets，並傳回 Qiskit 作業和結果。

建立電路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])

提交Qiskit作業

1. 從工作區建立一個 Azure Quantum 提供者物件。

   from qdk.azure.qiskit import AzureQuantumProvider
   
   provider = AzureQuantumProvider(workspace)
   

2. 列出接受 Qiskit 電路的後端。

   for backend in provider.backends():
       print(backend.name)
   

3. 選擇一個後端並提交電路。

   backend = provider.get_backend("rigetti.sim.qvm")
   job = backend.run(circuit, shots=100)
   
   print("Job ID:", job.job_id())
   print("Status:", job.status())
   

4. 等待工作完成後再取得 Qiskit 結果。

   result = job.result()
   counts = result.get_counts(circuit)
   print(counts)
   

Qiskit轉接器會處理Azure Quantum的輸入格式，並將提供者回應轉換為Qiskit的結果。

Qiskit 具有量子位元損失的程式作業結果

有些量子硬體在程式執行時可能會出現量子位元遺失。 如果對於 Qiskit 程式，在一次 shot 的任何時間點發生量子位元遺失，則該次 shot 會從 Azure Quantum 工作結果中移除。 例如，如果量子位元遺失發生在200次射擊中有10次，則工作結果總計量為190次。

所有測試的原始結果，包括發生量子位元遺失的測試，仍可在 results 物件中取得。 以下程式碼同時取得這兩組結果。

# 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)

對於沒有 targets 量子位元損失的工作，預設結果和原始結果是一樣的。

Note

memory Qiskit工作結果屬性是每次射擊的測量結果清單。

Cirq

使用來自qdk.azure模組的AzureQuantumService，將Cirq作業提交至Azure Quantum提供者。 服務物件會列出相容 Azure Quantumtargets 的結果，並回傳 Cirq-native 或 provider-native 的結果。

建立電路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"),
)

送出Cirq作業

1. 建立 Azure Quantum 服務物件。

   from qdk.azure.cirq import AzureQuantumService
   
   service = AzureQuantumService(workspace)
   

2. 列出接受 targets 電路的 Cirq。

   for target in service.targets():
       print(target.name)
   

3. 建立非同步作業。

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

4. 等待作業完成，然後擷取其結果。

   result = job.results()
   print(result)
   

結果格式取決於提供者和 target。 有些提供者結果物件可以轉換成物件 cirq.Result 。

PennyLane

將一個 PennyLane 量子節點轉換為 OpenQASM，編譯 OpenQASM 到 QIR，並將 提交 QIR 給一個 Azure Quantumtarget。

建立電路PennyLane

以下電路為參數化電路。 閘的效應 RY 取決於角度 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))

將電路轉換為 QIR

1. 針對特定的參數值，將參數化電路轉換為 OpenQASM。

   theta = 0.3
   qasm_source = qml.to_openqasm(circuit)(theta)
   

2. 使用相容的 QIR 設定檔將 target 編譯為 OpenQASM。

   from qdk import TargetProfile
   from qdk.openqasm import compile
   
   program = compile(qasm_source, TargetProfile.Base)
   

提交 PennyLane 作業

1. 選擇相容的 target 並提交 QIR。

   target = workspace.get_targets("rigetti.sim.qvm")
   job = target.submit(program, "pennylane-job", shots=100)
   
   print("Job ID:", job.id)
   

2. 等待作業完成，並擷取其結果。

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

結果格式取決於提供者和 target。 Azure Quantum不會從已提交的PennyLane中傳回QIR量子節點結果。

相關內容

• 如何提交工作到 Azure Quantum
• 使用 QDK 副檔名提交 VS Code 的作業
• 使用 Azure CLI 將作業提交至 Azure Quantum
• 與 Azure Quantum 工作協作
• QDK中的量子程式語言支援
• Azure Quantum 運算提供者 targets