견적서 예시

이 페이지의 코드는 다음 요구 사항을 바탕으로 개발되었습니다. 이 버전 이상을 사용하시기를 권장합니다.
```
qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0
```

이 섹션의 예제들은 Estimator를 사용하는 몇 가지 일반적인 방법을 보여줍니다. 이 예제를 실행하기 전에 ‘Qiskit 설치’에 있는 지침을 따르십시오.

Note

이 예제들은 모두 IBM Quantum 기본 함수를 사용하지만, 대신 기본 함수를 사용할 수도 있습니다.

Estimator를 사용하여 다양한 알고리즘에 필요한 양자 연산자의 기대값을 효율적으로 계산하고 해석할 수 있습니다. 분자 모델링, 기계 학습 및 복잡한 최적화 문제에서의 활용 사례를 살펴보세요.

단일 실험 실행

Estimator를 사용하여 단일 회로-관측값 쌍의 기대값을 구하십시오.

import numpy as np
from qiskit.circuit.library import iqp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp, random_hermitian
from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator

n_qubits = 50

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=n_qubits
)

mat = np.real(random_hermitian(n_qubits, seed=1234))
circuit = iqp(mat)
observable = SparsePauliOp("Z" * 50)

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_circuit = pm.run(circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)

estimator = Estimator(mode=backend)
job = estimator.run([(isa_circuit, isa_observable)])
result = job.result()

print(f" > Expectation value: {result[0].data.evs}")
print(f" > Metadata: {result[0].metadata}")

Output:

 > Expectation value: 0.012658227848101266
 > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

단일 작업에서 여러 실험을 실행합니다

Estimator를 사용하여 여러 회로-관측값 쌍의 기대값을 구하십시오.

import numpy as np
from qiskit.circuit.library import iqp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp, random_hermitian
from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator

n_qubits = 50

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=n_qubits
)

rng = np.random.default_rng()
mats = [np.real(random_hermitian(n_qubits, seed=rng)) for _ in range(3)]

pubs = []
circuits = [iqp(mat) for mat in mats]
observables = [
    SparsePauliOp("X" * 50),
    SparsePauliOp("Y" * 50),
    SparsePauliOp("Z" * 50),
]

# Get ISA circuits
pm = generate_preset_pass_manager(optimization_level=1, backend=backend)

for qc, obs in zip(circuits, observables):
    isa_circuit = pm.run(qc)
    isa_obs = obs.apply_layout(isa_circuit.layout)
    pubs.append((isa_circuit, isa_obs))

estimator = Estimator(backend)
job = estimator.run(pubs)
job_result = job.result()

for idx in range(len(pubs)):
    pub_result = job_result[idx]
    print(f">>> Expectation values for PUB {idx}: {pub_result.data.evs}")
    print(f">>> Standard errors for PUB {idx}: {pub_result.data.stds}")

Output:

>>> Expectation values for PUB 0: -0.2650103519668737
>>> Standard errors for PUB 0: 0.49439861538856356
>>> Expectation values for PUB 1: -0.02099609375
>>> Standard errors for PUB 1: 0.013489459956524228
>>> Expectation values for PUB 2: 0.2788671023965142
>>> Standard errors for PUB 2: 0.4836236522960098

매개변수화된 회로 실행

Estimator를 사용하여 단일 작업 내에서 세 가지 실험을 수행하고, 매개변수 값을 활용하여 회로의 재사용성을 높입니다.

import numpy as np

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Step 1: Map classical inputs to a quantum problem
theta = Parameter("θ")

chsh_circuit = QuantumCircuit(2)
chsh_circuit.h(0)
chsh_circuit.cx(0, 1)
chsh_circuit.ry(theta, 0)

number_of_phases = 21
phases = np.linspace(0, 2 * np.pi, number_of_phases)
individual_phases = [[ph] for ph in phases]

ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])
ops = [ZZ, ZX, XZ, XX]

# Step 2: Optimize problem for quantum execution.

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
chsh_isa_circuit = pm.run(chsh_circuit)
isa_observables = [
    operator.apply_layout(chsh_isa_circuit.layout) for operator in ops
]

# Step 3: Execute using IBM Quantum primitives.

# Reshape observable array for broadcasting
reshaped_ops = np.fromiter(isa_observables, dtype=object)
reshaped_ops = reshaped_ops.reshape((4, 1))

estimator = Estimator(backend, options={"default_shots": int(1e4)})
job = estimator.run([(chsh_isa_circuit, reshaped_ops, individual_phases)])
# Get results for the first (and only) PUB
pub_result = job.result()[0]
print(f">>> Expectation values: {pub_result.data.evs}")
print(f">>> Standard errors: {pub_result.data.stds}")
print(f">>> Metadata: {pub_result.metadata}")

Output:

>>> Expectation values: [[ 0.9665404   0.90476418  0.77027221  0.53367788  0.27327396 -0.04118414
  -0.32496864 -0.5686415  -0.78657426 -0.91870673 -0.95667336 -0.91656172
  -0.78249875 -0.55877446 -0.2855005   0.0278851   0.31638861  0.58322755
   0.78829027  0.92428375  0.96267938]
 [ 0.01930507  0.31831912  0.5969556   0.80630833  0.92535625  0.96525339
   0.91312971  0.7689852   0.55062343  0.27992348 -0.01158304 -0.30287506
  -0.57679253 -0.80158932 -0.90562218 -0.96246488 -0.90669469 -0.77606373
  -0.55641496 -0.29193553  0.01630206]
 [-0.04719017 -0.35950326 -0.63599473 -0.84427497 -0.9669694  -1.00193302
  -0.93565229 -0.77992474 -0.53861139 -0.25782991  0.05898771  0.34834922
   0.62998871  0.83655294  0.95817487  1.00021701  0.93307828  0.77606373
   0.54547542  0.26662444 -0.06670973]
 [ 0.9969995   0.93543779  0.76426619  0.55963247  0.24967888 -0.06241972
  -0.35221024 -0.63620924 -0.83440793 -0.96568239 -1.00536503 -0.93415078
  -0.77949574 -0.56284998 -0.26855494  0.05362519  0.35070873  0.61797667
   0.84212996  0.97104491  0.99850101]]
>>> Standard errors: [[0.00518482 0.00616652 0.00723301 0.01064988 0.01139583 0.01174119
  0.01301757 0.01155567 0.00848267 0.00690879 0.00492396 0.00613768
  0.00678488 0.00840832 0.01404782 0.01184222 0.00982484 0.00854968
  0.00764619 0.00774419 0.00621175]
 [0.01590044 0.01095813 0.01205478 0.00872719 0.00609088 0.0043678
  0.00579195 0.00857024 0.01184119 0.01191681 0.01262258 0.01090978
  0.01346398 0.00940893 0.00709353 0.00454548 0.00795003 0.00900232
  0.00768466 0.01225787 0.01271092]
 [0.01265687 0.01230849 0.00961079 0.00725756 0.00469446 0.00444008
  0.00683132 0.00804195 0.01140408 0.01165563 0.01001761 0.01300941
  0.01014068 0.00822676 0.00511424 0.00465829 0.00659315 0.00633185
  0.00865837 0.0101667  0.01090357]
 [0.00399857 0.0064308  0.0071202  0.00974728 0.01066452 0.01082351
  0.01311009 0.01053503 0.00801145 0.00501261 0.00499458 0.00673144
  0.00871285 0.00998373 0.01241673 0.01345925 0.00835253 0.00686725
  0.00814337 0.00466632 0.00432618]]
>>> Metadata: {'shots': 10016, 'target_precision': 0.01, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

일괄 처리 및 고급 옵션 사용

QPU에서 회로 성능을 최적화하기 위해 일괄 실행 모드와 고급 옵션을 살펴보세요.

import numpy as np
from qiskit.circuit.library import iqp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.quantum_info import SparsePauliOp, random_hermitian
from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Batch,
    EstimatorV2 as Estimator,
)

n_qubits = 15

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=n_qubits
)

rng = np.random.default_rng(1234)
mat = np.real(random_hermitian(n_qubits, seed=rng))
circuit = iqp(mat)
mat = np.real(random_hermitian(n_qubits, seed=rng))
another_circuit = iqp(mat)
observable = SparsePauliOp("X" * n_qubits)
another_observable = SparsePauliOp("Y" * n_qubits)

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pm.run(circuit)
another_isa_circuit = pm.run(another_circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)
another_isa_observable = another_observable.apply_layout(
    another_isa_circuit.layout
)

# The context manager automatically closes the batch.
with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)

    estimator.options.resilience_level = 1

    job = estimator.run([(isa_circuit, isa_observable)])
    another_job = estimator.run(
        [(another_isa_circuit, another_isa_observable)]
    )
    result = job.result()
    another_result = another_job.result()

    # first job
    print(f" > Expectation value: {result[0].data.evs}")
    print(f" > Metadata: {result[0].metadata}")

    # second job
    print(f" > Another Expectation value: {another_result[0].data.evs}")
    print(f" > More Metadata: {another_result[0].metadata}")

Output:

 > Expectation value: 0.026385707741639945
 > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}
 > Another Expectation value: 0.0134052163776774
 > More Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

다음 단계

권장사항

고급 런타임 옵션을 지정합니다.
IBM Quantum® Learning 의 ‘Cost’ 함수 강의를 따라가며 기본형(primitives)을 연습해 보세요.
‘트랜스파일’ 섹션에서 로컬 환경에서 트랜스파일하는 방법을 알아보세요.
‘트랜스파일러 설정 비교’ 가이드를 확인해 보세요.
IBM® QPU로 작업을 전송할 때 작업 제한 사항을 숙지하십시오.

이 페이지가 도움이 되었습니까?

GitHub에서 버그, 오타를 보고하거나 컨텐츠를 요청하십시오.