使用PythonAzure Quantum包将作业提交到QDK

使用 Microsoft Quantum 开发工具包（QDK）Python 包将 Q#、OpenQASM、Qiskit、Cirq 和 PennyLane 程序提交到 Azure Quantum。

本文提供了每个受支持的量子语言或框架的作业提交示例。 有关不需要 VS Code 代码的交互式 Q# 或 OpenQASM 工作流，请参阅 Python。

先决条件

• 拥有有效订阅的 Azure 帐户。

• 一个工作区 Azure Quantum 。 若要创建工作区，请参阅 “创建 Azure Quantum 工作区”。

• Python 3.10 或更高版本。

• 如果你使用 Jupyter Notebook，则可使用 Jupyter 环境，例如适用于 VS Code 的 Jupyter 扩展和 ipykernel 包。

• 使用quantum扩展安装Azure CLI。

  az extension add --upgrade --name quantum
  

• 安装最新版本的 qdkPython 软件包，并包含 azure 和 jupyter 附加组件。

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

  如果要提交 Qiskit 或 Cirq 程序，请安装 cirq 和 qiskit 扩展组件。

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

连接到您的 Azure Quantum 工作区

在提交作业之前，需要连接到 Azure Quantum 工作区。 qdk.azure 模块提供用于连接到 Azure Quantum 工作区的 Workspace 对象。 若要连接到工作区，请执行以下步骤。

使用 Azure CLI 登录

如果尚未登录，请在打开 Jupyter 笔记本之前从终端登录到Azure。

az login

如果未从终端登录，则每次通过 Python连接到 Quantum 工作区时都需要进行身份验证。 如果帐户有权访问多个订阅，请设置包含工作区的 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
   

   注释

   Y

2. 验证连接并查看工作区中可用的 targets。

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

有关其他连接和身份验证选项，请参阅 “连接到 Azure Quantum 工作区”。

注释

以下示例将作业提交到 模拟器 targets。 您工作区中可用的 targets 取决于您已配置的提供程序。

准备并提交计划

选择量子语言或框架的选项卡。

Q#

使用qdk.qsharp模块定义或加载Q#代码，将入口点编译为QIR，并将QIR提交到Azure Quantumtarget。

定义和编译 Q# 程序

1. 使用Q#target支持的targetAzure Quantum配置文件初始化QIR。

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

   有关 配置文件的详细信息，请参阅 中的配置文件。

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

使用 QIR 模块将 QIR 3 源代码编译为 Azure Quantum，然后将 target 提交到一个 OpenQASMqdk.openqasm。

定义和编译 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 程序，请在提交作业之前绑定输入值。 有关 OpenQASM 中的 QDK 的更多信息，请参阅《在 OpenQASM 中开发 QDK 程序》。

Qiskit

使用 qdk.azure 模块中的 AzureQuantumProvider 向 Azure Quantum 提供程序提交 Qiskit 作业。 提供程序对象列出兼容的 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 期间任何时间点发生量子比特丢失，则会从作业结果中删除该 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，默认结果和原始结果是相同的。

注释

Qiskit 作业结果的 memory 属性是每一次的度量结果列表。

Cirq

使用 qdk.azure 模块中的 AzureQuantumService 将 Cirq 作业提交到 Azure Quantum 提供程序。 服务对象列出兼容的 Azure Quantumtargets，并返回 Cirq 原生或提供程序原生结果。

创建 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. 列出支持Cirq电路的targets。

   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

将OpenQASM量子节点转换为OpenQASM，将QIR编译为QIR，并将Azure Quantum提交到targetPennyLane。

创建 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. 使用兼容的 target 配置文件将 OpenQASM 编译为 QIR。

   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 不会从已提交的 QIR 中返回 PennyLane 量子节点结果。

相关内容

• 如何将作业提交到 Azure Quantum
• 使用适用于 VS Code 的 QDK 扩展提交作业
• 使用 Azure CLI 将作业提交到Azure Quantum
• 处理 Azure Quantum 作业
• 在QDK中的量子编程语言支持
• Azure Quantum 计算提供程序 targets