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

快速入门：将 Qiskit 线路提交到 Azure Quantum

了解如何使用 azure-quantumPython 包通过 Azure Quantum 服务将 Qiskit 量子线路提交到 IonQ、Quantinuum 或 Rigetti 量子计算 target 。 有关详细信息，请参阅量子线路。

先决条件

• 具有活动订阅的 Azure 帐户。 免费创建帐户。

• 创建 Azure Quantum 工作区。 有关详细信息，请参阅创建 Azure Quantum 工作区。

• 使用 [qiskit] 标记安装最新的 azure-quantumPython 包。

  注意

  在安装或更新 azure-quantum 包之前，请卸载计算机上的所有 pyqir、pyqir-*和 qiskit-qir 版本，以避免依赖项冲突。

  提示

  如果使用 Miniconda 或 Anaconda，可以选择性地通过下载 environment.yml 并运行以下命令来创建新环境：

  conda env create -f environment.yml
  

  这将创建一个新的 conda 环境，你可以使用以下命令来激活该环境：

  conda activate azurequantum
  

• 启动你最喜欢的代码编辑器或交互式 Python 工具，例如 VS Code、Jupyter 或 iPython。

注意

本快速入门中的示例使用 Jupyter Notebook 环境。 在 conda 环境中，运行 Jupyter Notebook。

加载所需的导入项

在 Jupyter Notebooks 中，创建使用 Python 3 内核的新笔记本。 在第一个单元格中，运行以下代码以加载所需的导入：

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from azure.quantum.qiskit import AzureQuantumProvider

连接到 Azure Quantum 服务

若要连接到 Azure Quantum 服务，程序将需要资源 ID 和 Azure Quantum 工作区的位置。 登录 Azure 帐户，https://portal.azure.com导航到 Azure Quantum 工作区，然后复制标头中的值。

将值粘贴到以下 AzureQuantumProvider 构造函数，创建连接到 Azure Quantum 工作区的 provider 对象。

provider = AzureQuantumProvider(
  resource_id="",
  location=""
)

列出所有后端

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

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.qpu.h1-2
- quantinuum.sim.h1-2sc
- quantinuum.sim.h1-1e
- quantinuum.sim.h1-2e
- rigetti.sim.qvm
- rigetti.qpu.aspen-11
- rigetti.qpu.aspen-m-2
- rigetti.qpu.aspen-m-3

运行简单的线路

首先，创建要运行的简单 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 

若要快速获得结果，请使用 provider.get_backend 创建 Backend 对象以连接到 IonQ 模拟器后端：

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

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

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

这会返回一个新的线路对象，其中的门分解为指定的后端支持的门。

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

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

Job id 00000000-0000-0000-0000-000000000000

若要监视作业进度，可以使用之前导入的 Qiskit job_monitor 来跟踪作业的状态。 此调用将阻塞到作业完成为止：

job_monitor(job)

Job Status: job has successfully run

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

result = job.result()

这会返回一个 qiskit.Result 对象。

type(result)

qiskit.result.result.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=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 50, '111': 50}, probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

由于结果是 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': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

估算作业成本

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

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

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

这会输出以美元为单位的估算成本。

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

在 IonQ QPU 上运行

若要连接到实际硬件 (量子处理器单元 (QPU) ) ，只需向 方法提供 的名称target"ionq.qpu"provider.get_backend：

qpu_backend = provider.get_backend("ionq.qpu")

提交要在 Azure Quantum 上运行的线路。

注意

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

与之前一样，使用 job_monitor 跟踪作业的状态，并使用 plot_histogram 来绘制结果。

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

# Monitor job progress and wait until complete:
job_monitor(qpu_job)

# Get the job results (this method also waits for the Job to complete):
result = qpu_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.simulator', 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}

加载所需的导入项

在 Jupyter Notebooks 中，创建使用 Python 3 内核的新笔记本。 在第一个单元格中，运行以下代码以加载所需的导入：

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from azure.quantum.qiskit import AzureQuantumProvider

连接到 Azure Quantum 服务

若要连接到 Azure Quantum 服务，程序将需要资源 ID 和 Azure Quantum 工作区的位置。 登录 Azure 帐户，https://portal.azure.com导航到 Azure Quantum 工作区，然后复制标头中的值。

将值粘贴到以下 AzureQuantumProvider 构造函数，创建连接到 Azure Quantum 工作区的 provider 对象。

provider = AzureQuantumProvider(
  resource_id="",
  location=""
)

列出所有后端

注意

target Quantinuum 语法检查器、模拟器和 QCPU 的名称最近已更改。 本主题使用更新后的名称。 有关详细信息，请参阅 Quantinuum 提供程序 主题。

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

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.qpu.h1-2
- quantinuum.sim.h1-2sc
- quantinuum.sim.h1-1e
- quantinuum.sim.h1-2e
- rigetti.sim.qvm
- rigetti.qpu.aspen-11
- rigetti.qpu.aspen-m-2
- rigetti.qpu.aspen-m-3

在语法检查器上运行

若要在硬件上运行程序之前对其进行测试，请先在 Quantinuum 语法检查器上运行它。

注意

Quantinuum 语法检查器后端在测量时始终返回 0。

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

# 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 

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

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

# Monitor job progress and wait until complete:
job_monitor(job)

# Get the job results (this method also 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='quantinuum.qpu.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=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

注意

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

估算作业成本

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

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

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=1024)
job_id = job.id()
print("Job id", job_id)

# Monitor job progress and wait until complete:
job_monitor(job)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run

# Get the job results (this method also 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}

加载所需的导入项

在 Jupyter Notebooks 中，创建使用 Python 3 内核的新笔记本。 在第一个单元格中，运行以下代码以加载所需的导入：

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from azure.quantum.qiskit import AzureQuantumProvider

连接到 Azure Quantum 服务

若要连接到 Azure Quantum 服务，程序将需要资源 ID 和 Azure Quantum 工作区的位置。 登录 Azure 帐户，https://portal.azure.com导航到 Azure Quantum 工作区，然后复制标头中的值。

将值粘贴到以下 AzureQuantumProvider 构造函数，创建连接到 Azure Quantum 工作区的 provider 对象。

provider = AzureQuantumProvider(
  resource_id="",
  location=""
)

列出所有后端

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

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.qpu.h1-2
- quantinuum.sim.h1-2sc
- quantinuum.sim.h1-1e
- quantinuum.sim.h1-2e
- rigetti.sim.qvm
- rigetti.qpu.aspen-11
- rigetti.qpu.aspen-m-2
- rigetti.qpu.aspen-m-3

在 QVM 模拟器上运行

若要在硬件上运行程序之前对其进行测试，请先在 Rigetti QVM 模拟器上运行它。

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

# 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 

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

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

# Monitor job progress and wait until complete:
job_monitor(job)

# Get the job results (this method also 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='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=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 1024}, probabilities={'000': 1.0}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 1024, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

在 Rigetti QPU 上运行

在 QVM 模拟器上成功运行后，可以在 Rigetti 的某个硬件处理器上运行作业， (量子处理器单元 (QPU) ) 。

注意

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

# Get Rigetti's QPU backend:
qpu_backend = provider.get_backend("rigetti.qpu.aspen-m-3")

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

# Monitor job progress and wait until complete:
job_monitor(job)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run

# Get the job results (this method also 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.qpu.aspen-m-3', 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}

重要

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

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

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