你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

如何使用 Qiskit 将线路提交到 Azure Quantum

了解如何使用 azure-quantumPython 包提交 Qiskit 量子线路。 可以使用具有内置 azure-quantumPython 包的 Azure Quantum 笔记本或本地计算机将 Qiskit 线路提交到 Azure Quantum。

有关详细信息，请参阅量子线路。

先决条件

有关安装详细信息，请参阅 在 VS Code 上安装 QDK。

• Azure 订阅中的 Azure Quantum 工作区。 若要创建工作区，请参阅创建 Azure Quantum 工作区。

• Python安装了 Python Pip 的环境。

• 安装了 Azure Quantum 开发工具包Python和 Jupyter 扩展的 VS Code。

• 带有 [qiskit] 标记的 Azure Quantum azure-quantumPython 包。

  python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernel 
  

  重要

  确保你拥有最新版本的 Qiskit。 有关详细信息，请参阅 更新 azure-quantum Python 包。

  注意

  如果未检测到 Jupyter Python 内核 ipykernel ，VS Code 将提示你安装它。

创建新的 Jupyter Notebook

1. 在 VS Code 中，选择“视图 > 命令面板”，然后选择“创建：新 Jupyter Notebook”。
2. 在右上角，VS Code 将检测并显示为笔记本选择的版本 Python 和虚拟 Python 环境。 如果有多个 Python 环境，可能需要使用右上角的内核选取器选择内核。 如果未检测到任何环境，请参阅 VS Code 中的 Jupyter Notebook 以获取设置信息。

加载所需的导入项

在笔记本的第一个单元中，运行以下代码以加载所需的导入：

import azure.quantum
from azure.quantum import Workspace 
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

连接到 Azure Quantum 服务

若要连接到 Azure Quantum 服务，你需要使用 Azure Quantum 工作区的资源 ID 和位置。

1. 登录到 Azure 帐户， https://portal.azure.com

2. 选择 Azure Quantum 工作区，然后导航到 “概述”。

3. 复制字段中的参数。

   

在笔记本中添加一个新单元格，并使用帐户信息创建 Workspace 和 AzureQuantumProvider 对象以连接到 Azure Quantum 工作区。

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

provider = AzureQuantumProvider(workspace)

列出所有后端

现在可以打印工作区上可用的所有量子计算后端：

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm

运行简单的线路

首先，创建要运行的简单 Qiskit 线路。

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2 

选择一个 target 运行程序

IonQ

在 IonQ 模拟器上运行

在实际硬件上运行之前，让我们在模拟器中测试线路。 用于 get_backend 创建连接到 Backend IonQ 模拟器后端的对象：

simulator_backend = provider.get_backend("ionq.simulator")

IonQ 后端支持定义的门集中的门，这些门经过编译，可在硬件上以最佳方式运行。 如果线路包含不在此列表中的入口，则需要使用 transpile Qiskit 提供的函数转译到支持的gateset函数中：

from qiskit import transpile
circuit = transpile(circuit, simulator_backend)

Transpile 函数返回一个新的线路对象，其中入口分解为指定后端支持的入口。

现在，可以通过 Azure Quantum 服务运行程序并获取结果。 以下单元格提交一个作业，该作业会运行 100 次线路：

job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

Job id 00000000-0000-0000-0000-000000000000

若要等待作业完成并返回结果，请运行：

result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)

由于结果是 Qiskit 包的原生对象，你可以使用 Qiskit 的 result.get_counts 和 plot_histogram 来可视化结果。 若要确保表示所有可能的位字符串标签，请将它们添加到 counts。

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

还可以使用该 get_memory() 函数显示作业中的单个镜头数据

result.get_memory(circuit)

['000', '000', '000', '000', '111', '111', '111', '111']

注意

在 IonQ targets上，如果你提交一份具有奇数的镜头的工作，结果将向下舍入到下一个偶数。 例如，如果指定 9 次拍摄，则结果将显示 8 次拍摄的数据。

估算作业成本

在 QPU 上运行作业之前，可以估算运行的成本。 若要估算在 QPU 上运行作业的成本，可以使用 estimate_cost 方法：

backend = provider.get_backend("ionq.qpu")
cost = backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

这将打印估计成本（以美元为单位）。

有关最新定价详细信息，请参阅 IonQ 定价，或通过以下网页找到你的工作区并查看该工作区的“提供商”选项卡中的定价选项：aka.ms/aq/myworkspaces。

在 IonQ QPU 上运行

若要连接到实际硬件（量子处理器单元（QPU），只需提供方法的名称"ionq.qpu.aria-1"targetget_backend：

qpu_backend = provider.get_backend("ionq.qpu.aria-1")

提交线路以在 Azure Quantum 上运行，获取结果，然后运行 plot_histogram 以绘制结果。

注意

在 QPU 上运行线路所需的时间可能因当前队列时间而异。

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.qpu.aria-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Quantinuum

在语法检查器上运行

若要在硬件上运行程序之前对其进行测试，请先在 Quantinuum 语法检查器上运行它。 get_backend使用该方法创建对象Backend以连接到 Quantinuum 语法检查器后端：

# Get Quantinuum's syntax checker backend:
syntax_backend = provider.get_backend("quantinuum.sim.h1-1sc")

现在，可以通过 Azure Quantum 服务运行程序并获取结果。 以下单元格提交一个作业，该作业以 8 次镜头运行线路：

# Submit the circuit to run on Azure Quantum
job = syntax_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='quantinuum.sim.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 8}, memory=['000', '000', '000', '000', '000', '000', '000', '000'], probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

注意

虽然 Quantinuum 语法检查器可确保代码在 Quantinuum 硬件上成功运行，但它还为每个量子度量返回 0。 若要进行真正的量子测量，需要在量子硬件上运行线路。

还可以使用该 get_memory() 函数显示作业中的单个镜头数据

result.get_memory(circuit)

['000', '000', '000', '000', '000', '000', '000', '000']

估算作业成本

在 QPU 上运行作业之前，可以估算运行成本。 若要估算在 QPU 上运行作业的成本，可以使用 estimate_cost 方法：

qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")
cost = qpu_backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

这将打印 H-System Quantum 额度 (HQC) 中的估算成本。

有关最新的定价详细信息，请参阅 Azure Quantum 定价，或通过：aka.ms/aq/myworkspaces 在工作区的“提供程序”选项卡中查找工作区并查看定价选项。

在 Quantinuum QPU 上运行

在 API 验证程序上成功运行后，可在 Quantinuum 的某个硬件处理器（Quantum 处理器单元 (QPU)）上运行作业。

注意

在 QPU 上运行线路所需的时间可能因当前队列时间而异。

# Get Quantinuum's QPU backend:
qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}

里盖蒂

注意

目前，Rigetti 仅通过 Azure Quantum 服务提供其量子模拟器 rigetti.sim.qvm。

在 QVM 模拟器上运行

使用该方法 provider.get_backend 创建对象 Backend 以连接到 Rigetti QVM 模拟器后端：

# Get Rigetti's QVM simulator backend:
qvm_backend = provider.get_backend("rigetti.sim.qvm")

现在，可以通过 Azure Quantum 服务运行程序并获取结果。 以下单元格提交一个作业，该作业以 8 次镜头运行线路：

# Submit the circuit to run on Azure Quantum
job = qvm_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Result(backend_name='rigetti.sim.qvm', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '111', '111', '000', '000', '000', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

还可以使用该 get_memory() 函数显示作业中的单个镜头数据

result.get_memory(circuit)

['000', '111', '111', '000', '000', '000', '111', '111']

重要

当前不支持在单个作业中提交多个线路。 作为一种变通方法，可以调用 backend.run 方法来异步提交每个线路，然后提取每个作业的结果。 例如：

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

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

先决条件

• 具有活动订阅的 Azure 帐户。 如果没有 Azure 帐户，请免费注册并注册 即用即付订阅。
• Azure Quantum 工作区。 有关详细信息，请参阅创建 Azure Quantum 工作区。

在工作区中创建新的笔记本

1. 登录到 Azure 门户，并选择在上一步中创建的工作区。
2. 在左侧边栏选项卡中，选择“笔记本”。
3. 单击“我的笔记本”，然后单击“新增”。
4. 键入文件的名称（例如 Qiskit.ipynb），然后单击“创建文件”。

当你的新笔记本打开时，它会根据订阅和工作区信息自动为第一个单元格创建代码。

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

注意

除非另有说明，否则应按照单元的创建顺序运行每个单元，以避免任何编译问题。

单击单元左侧的三角形“播放”图标以运行代码。

加载所需的导入项

首先需要导入一些附加模块。

单击“+ 代码”添加一个新的单元，然后添加并运行以下代码：

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

连接到 Azure Quantum 服务

接下来，使用Workspace上一单元格中的对象创建一个AzureQuantumProvider对象，以连接到 Azure Quantum 工作区。 使用以下代码添加新单元格：

provider = AzureQuantumProvider(workspace)

定义简单线路

在新的单元中创建一个 circuit 对象。 此示例是一个简单的量子随机比特生成器。 添加以下代码以定义并显示线路：

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2 

全部列出 targets

现在可以显示工作区中提供的所有量子计算 targets或后端。 添加一个新单元并运行以下行：

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm

选择一个 target 运行程序

IonQ

若要在实际的量子硬件上运行代码之前检查该代码，可以使用 IonQ 量子模拟器 ionq.simulator。

添加新单元格并创建一个对象来表示 IonQ 量子模拟器 target：

# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")

在 IonQ 模拟器上运行

若要在模拟器上运行线路，请添加以下代码。 此示例使用作业 run 的方法 target 提交作业，然后监视作业状态。

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

作业成功运行时，获取作业结果并显示它们：

# Get the job results:
result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)

由于此 result 类型是 Qiskit 包的原生对象，你可以使用 Qiskit 的 result.get_counts 和 plot_histogram 来可视化结果。 若要确保表示所有可能的位字符串标签，请将它们添加到 counts。

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

还可以使用该 get_memory() 函数显示作业中的单个镜头数据

result.get_memory(circuit)

['000', '000', '000', '000', '111', '111', '111', '111']

注意

在 IonQ targets上，如果你提交一份具有奇数的镜头的工作，结果将向下舍入到下一个偶数。 例如，如果指定 9 次拍摄，则结果将显示 8 次拍摄的数据。

估算作业成本

在实际量子硬件或 量子处理单元 （QPU）上运行作业之前，可以估算运行的成本。

首先，再次获取可用提供商的列表：

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm

接下来，创建一个对象来表示 IonQ 量子计算机：

qpu_backend = provider.get_backend("ionq.qpu.aria-1")

若要估算在 QPU 上运行作业的成本，请使用 estimate_cost 以下 target方法添加并运行新单元格：

cost = qpu_backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

这将显示估计成本（以美元为单位）。

有关最新定价详细信息，请参阅 IonQ 定价，或找到你的工作区并查看该工作区的“提供商”边栏选项卡中的定价选项。

在 IonQ QPU 上运行

在 IonQ 模拟器上成功运行作业并估算 QPU 成本后，就可以在硬件上运行线路了。

注意

在 QPU 上运行线路所需的时间因当前队列时间而异。 可以通过选择工作区的“提供程序”边栏选项卡来查看其target的平均队列时间。

使用前面在 API 验证程序中使用的相同 run 方法和运算来提交并监视作业：

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

作业完成后，像以前一样获取作业结果，并在图表中显示它们：

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Quantinuum

若要在实际量子硬件上运行代码之前检查代码，可以使用 Quantinuum 语法检查器 quantinuum.sim.h1-1sc之一。

添加新单元格并创建一个对象来表示 Quantinuum 语法检查器 target：

# Get Quantinuum's Syntax Checker target:
apival_backend = provider.get_backend("quantinuum.sim.h1-1sc")

在语法检查器上运行

若要在语法检查器上运行线路，请添加以下代码，该代码使用 run 提交作业的方法 target ，然后监视作业状态。

# Submit the circuit to run on Azure Quantum
job = apival_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

成功运行作业后，获取并显示作业结果：

# Get the job results:
result = job.result()
print(result)

Result(backend_name='quantinuum.sim.h1-1sc', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 8}, memory=['000', '000', '000', '000', '000', '000', '000', '000'], probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

由于此 result 类型是 Qiskit 包的原生对象，你可以使用 Qiskit 的 result.get_counts 和 plot_histogram 来可视化结果。 若要确保表示所有可能的位字符串标签，请将它们添加到 counts。

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

查看直方图时，你可能会注意到随机数生成器每次返回 0，这不是非常随机的。 这是因为，虽然语法检查器可确保代码在 Quantinuum 硬件上成功运行，但每个量子度量也会返回 0。 对于真正的随机数生成器，需要在量子硬件上运行线路。

还可以使用该 get_memory() 函数显示作业中的单个镜头数据

result.get_memory(circuit)

['000', '000', '000', '000', '000', '000', '000', '000']

估算作业成本

在实际的量子硬件或量子处理单元 (QPU) 上运行作业之前，可以估算其运行成本。

首先，再次获取可用提供商的列表：

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm

接下来，创建一个对象来表示 Quantinuum 系统模型 H1：

qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

若要估算在 QPU 上运行作业的成本，请使用 estimate_cost 以下 target方法添加并运行新单元格：

cost = qpu_backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

Estimated cost: 5.72

输出显示 H 系统量子点数（HQC）中的估计成本。

有关最新的定价详细信息，请参阅工作区的“提供程序”边栏选项卡中的 Azure Quantum 定价或查看定价选项。 若要查看当前额度状态和用量，请选择“额度和配额”。

在 Quantinuum QPU 上运行

在语法检查器上成功运行线路并估算 QPU 成本后，是时候在硬件上运行它了。

注意

在 QPU 上运行线路所需的时间取决于当前队列时间。 可以通过选择工作区的“提供程序”边栏选项卡来查看其target的平均队列时间。

使用之前与语法检查器一起使用的相同 run 方法和操作来提交和监视作业：

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

成功运行作业后，如前所述获取作业结果并在直方图中显示结果：

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

可以看到，结果应大致在 0 和 1 之间划分。

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='48282d18-9c15-11ec-bfbd-00155d6373ba', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'111': 53, '101': 1, '000': 46}, probabilities={'111': 0.53, '101': 0.01, '000': 0.46}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 46, '001': 0, '010': 0, '011': 0, '100': 0, '101': 1, '110': 0, '111': 53}

里盖蒂

注意

目前，Rigetti 仅通过 Azure Quantum 服务提供其量子模拟器 rigetti.sim.qvm。

添加新单元格并创建一个对象来表示 Rigetti 量子模拟器 target：

# Get Rigetti quantum simulator target:
simulator_backend = provider.get_backend("rigetti.sim.qvm")

在 Rigetti 模拟器上运行

若要在模拟器上运行线路，请添加以下代码。 此示例使用提交 run 作业的方法 target ，然后监视作业状态。

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)

作业成功运行时，获取作业结果并显示它们：

# Get the job results:
result = job.result()
print(result)

Result(backend_name='rigetti.sim.qvm', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '111', '111', '000', '000', '000', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

由于此 result 类型是 Qiskit 包的原生对象，你可以使用 Qiskit 的 result.get_counts 和 plot_histogram 来可视化结果。 若要确保表示所有可能的位字符串标签，请将它们添加到 counts。

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

还可以使用该 get_memory() 函数显示作业中的单个镜头数据

result.get_memory(circuit)

['000', '111', '111', '000', '000', '000', '111', '111']

重要

当前不支持在单个作业中提交多个线路。 作为一种变通方法，可以调用 backend.run 方法来异步提交每个线路，然后提取每个作业的结果。 例如：

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

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

后续步骤

• 快速入门：使用 Cirq 将线路提交到 Azure Quantum。
• 快速入门：将具有提供程序特定格式的线路提交到 Azure Quantum。