Lumaktaw sa pangunahing nilalaman

Estimator gamit ang REST API

Package versions

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na requirement. Inirerekomenda naming gamitin ang mga bersyong ito o mas bago.

qiskit[all]~=2.3.0

Inilalarawan ng mga hakbang sa topic na ito kung paano patakbuhin at i-configure ang mga workload gamit ang REST API, at ipinapakita kung paano tawagin ang mga ito sa kahit anong program na gusto mo.

tala

Ginagamit ng dokumentasyong ito ang Python requests module para ipakita ang Qiskit Runtime REST API. Gayunpaman, maaaring isagawa ang workflow na ito gamit ang kahit anong wika o framework na sumusuporta sa REST APIs. Tingnan ang API reference documentation para sa mga detalye.

1. I-initialize ang account​

Dahil ang Qiskit Runtime Estimator ay isang managed service, kailangan mo munang i-initialize ang iyong account. Pagkatapos ay maaari kang pumili ng device na gagamitin para kalkulahin ang expectation value.

Makita ang mga detalye kung paano i-initialize ang iyong account, tingnan ang mga available na Backend, at i-invalidate ang mga token sa topic na ito.

2. Gumawa ng QASM circuit​

Kailangan mo ng kahit isang circuit bilang input sa Estimator primitive.

Mag-define ng QASM quantum circuit. Halimbawa:

qasm_string='''
OPENQASM 3;
include "stdgates.inc";
qreg q[2];
creg c[2];
x q[0];
cx q[0], q[1];
c[0] = measure q[0];
c[1] = measure q[1];
'''

Ipinapalagay ng mga sumusunod na code snippet na ang qasm_string ay na-transpile na sa bagong string na resulting_qasm.

3. Patakbuhin ang quantum circuit gamit ang Estimator V2 API​

tala

Ginagamit ng mga sumusunod na job ang Qiskit Runtime V2 primitives. Ang parehong SamplerV2 at EstimatorV2 ay tumatanggap ng isa o higit pang primitive unified blocs (PUBs) bilang input. Ang bawat PUB ay isang tuple na naglalaman ng isang circuit at ng data na ibino-broadcast sa circuit na iyon, na maaaring maraming observable at parameter. Ang bawat PUB ay nagbabalik ng resulta.

import requests

url = 'https://quantum.cloud.ibm.com/api/v1/jobs'
auth_id = "Bearer <YOUR_BEARER_TOKEN>"
crn = "<SERVICE-CRN>"
backend = "<BACKEND_NAME>"

headers = {
    'Content-Type': 'application/json',
    'Authorization':auth_id,
    'Service-CRN': crn
    }

job_input = {
    'program_id': 'estimator',
    "backend": backend,
    "params": {
        "pubs": [ #primitive unified blocs (PUBs) containing one circuit each.
            [resulting_qasm, # QASM circuit
             {"IIZII": 1, "XIZZZ": 2.3}, # Observable
             None # parameter values
             ]]
}}

response = requests.post(url, headers=headers, json=job_input)

if response.status_code == 200:
    job_id = response.json().get('id')
    print("Job created:",response.text)
else:
    print(f"Error: {response.status_code}")

4. Suriin ang status ng job at kunin ang mga resulta​

Susunod, ipasa ang job_id sa API:

response_status_singlejob= requests.get(url+'/'+job_id, headers=headers)
response_status_singlejob.json().get('state')

Output

>>> Job ID: 58223448-5100-4dec-a47a-942fb30edcad
>>> Job Status: JobStatus.RUNNING

Kunin ang mga resulta ng job:

response_result= requests.get(url+'/'+job_id+'/results', headers=headers)

res_dict=response_result.json()

estimator_result=res_dict['results']
print(estimator_result)

Output

[{'data': {'evs': 0.7428980350102542, 'stds': 0.029884014518789213, 'ensemble_standard_error': 0.03261147170624149}, 'metadata': {'shots': 10016, 'target_precision': 0.01, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}}]

5. Magtrabaho gamit ang mga Runtime option​

Ang mga teknik ng error mitigation ay nagpapahintulot sa mga user na mabawasan ang mga error sa circuit sa pamamagitan ng pag-model ng device noise sa oras ng pagpapatupad. Karaniwang nagdudulot ito ng quantum pre-processing overhead na may kaugnayan sa pagsasanay ng modelo, at classical post-processing overhead para mabawasan ang mga error sa mga raw na resulta gamit ang nabuong modelo.

Ang mga teknik ng error mitigation na built in sa mga primitive ay mga advanced resilience option. Para tukuyin ang mga opsyong ito, gamitin ang resilience_level na opsyon kapag nagsusumite ng iyong job.

Ipinapakita ng mga sumusunod na halimbawa ang mga default na opsyon para sa dynamical decoupling, twirling, at TREX + ZNE. Makakahanap ng higit pang mga opsyon at karagdagang detalye sa topic na Error mitigation and suppression techniques.

TREX + ZNE​

import requests

url = 'https://quantum.cloud.ibm.com/api/v1/jobs'
auth_id = "Bearer <YOUR_BEARER_TOKEN>"
crn = "<SERVICE-CRN>"
backend = "BACKEND_NAME"

headers = {
    'Content-Type': 'application/json',
    'Authorization':auth_id,
    'Service-CRN': crn
    }
job_input = {
    'program_id': 'estimator',
    "backend": backend,
    "params": {
        "pubs": [ #primitive unified blocs (PUBs) containing one circuit each
            [resulting_qasm, # QASM circuit
             {"IIZII": 1, "XIZZZ": 2.3}, # Observable
             None # parameter values
             ]]
        "options": {
            "resilience": {
              "measure_mitigation": True,
              "zne_mitigation": True,
              "zne": {
                  "extrapolator":["exponential", "linear"],
                  "noise_factors":[1, 3, 5],
              },
          },
        },
    }
}

response = requests.post(url, headers=headers, json=job_input)

if response.status_code == 200:
    job_id = response.json().get('id')
    print("Job created:",response.text)
else:
    print(f"Error: {response.status_code}")

Dynamical Decoupling​

import requests

url = 'https://quantum.cloud.ibm.com/api/v1/jobs'
auth_id = "Bearer <YOUR_BEARER_TOKEN>"
crn = "<SERVICE-CRN>"
backend = "BACKEND_NAME"

headers = {
    'Content-Type': 'application/json',
    'Authorization':auth_id,
    'Service-CRN': crn
    }
job_input = {
    'program_id': 'estimator',
    "backend": backend,
    "params": {
        "pubs": [ #primitive unified blocs (PUBs) containing one circuit each
            [resulting_qasm, # QASM circuit
             {"IIZII": 1, "XIZZZ": 2.3}, # Observable
             None # parameter values
             ]]
        "options": {
            "dynamical_decoupling": {
                "enable": True,
                "sequence_type": 'XpXm',
                "extra_slack_distribution": 'middle',
                "scheduling_method": 'alap',
            },
        },
    }
}

response = requests.post(url, headers=headers, json=job_input)

if response.status_code == 200:
    job_id = response.json().get('id')
    print("Job created:",response.text)
else:
    print(f"Error: {response.status_code}")

Twirling​

import requests

url = 'https://quantum.cloud.ibm.com/api/v1/jobs'
auth_id = "Bearer <YOUR_BEARER_TOKEN>"
crn = "<SERVICE-CRN>"
backend = "BACKEND_NAME"

headers = {
    'Content-Type': 'application/json',
    'Authorization':auth_id,
    'Service-CRN': crn
    }
job_input = {
    'program_id': 'estimator',
    "backend": backend,
    "params": {
        "pubs": [ #primitive unified blocs (PUBs) containing one circuit each
            [resulting_qasm, # QASM circuit
             {"IIZII": 1, "XIZZZ": 2.3}, # Observable
             None # parameter values
             ]]
        "options": {
            "twirling": {
                "enable_gates": True,
                "enable_measure": True,
                "num_randomizations": "auto",
                "shots_per_randomization": "auto",
                "strategy": "active-accum",
                },
        },
    }
}

response = requests.post(url, headers=headers, json=job_input)

if response.status_code == 200:
    job_id = response.json().get('id')
    print("Job created:",response.text)
else:
    print(f"Error: {response.status_code}")

Mga parameterized circuit​

1. I-initialize ang account​

Dahil ang Qiskit Runtime ay isang managed service, kailangan mo munang i-initialize ang iyong account. Pagkatapos, maaari kang pumili ng device na gagamitin para patakbuhin ang iyong mga kalkulasyon.

Makita ang mga detalye kung paano i-initialize ang iyong account, tingnan ang mga available na Backend, at i-invalidate ang mga token sa topic na ito.

2. I-define ang mga parameter​

import requests
import qiskit_ibm_runtime
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.qasm3 import dumps
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit import transpile

service = QiskitRuntimeService(channel='ibm_quantum')
backend = service.backend("<SPECIFY BACKEND>")

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)

theta = Parameter('theta')
phi = Parameter('phi')
parameter_values = {'theta': 1.57, 'phi': 3.14}   # In case we want to pass a dictionary

3. Gumawa ng quantum circuit at magdagdag ng mga parameterized gate​

qc = QuantumCircuit(2)

# Add parameterized gates
qc.rx(theta, 0)
qc.ry(phi, 1)
qc.cx(0, 1)
qc.measure_all()

# Draw the original circuit
qc.draw('mpl')

# Get an ISA circuit
isa_circuit = pm.run(qc)

4. Gumawa ng QASM 3 code​

qasm_str = dumps(isa_circuit)
print("Generated QASM 3 code:")
print(qasm_str)

5. Patakbuhin ang quantum circuit gamit ang Estimator V2 API​

import requests

url = 'https://quantum.cloud.ibm.com/api/v1/jobs'
auth_id = "Bearer <YOUR_BEARER_TOKEN>"
crn = "<SERVICE-CRN>"
backend = "<BACKEND_NAME>"

headers = {
    'Content-Type': 'application/json',
    'Authorization':auth_id,
    'Service-CRN': crn
    }

job_input = {
    'program_id': 'estimator',
    "backend": backend,
    "params": {
        # Choose one option: direct parameter transfer or through a dictionary
        #"pubs": [[qasm_str,[1,2],500]], # primitive unified blocs (PUBs) containing one circuit each.
        "pubs": [[qasm_str,parameter_values,500]], # primitive unified blocs (PUBs) containing one circuit each.
}}

response = requests.post(url, headers=headers, json=job_input)

if response.status_code == 200:
    job_id = response.json().get('id')
    print(f"Job created: {response.text}")
else:
    print(f"Error: {response.status_code}")
print(response.text)

6. Suriin ang status ng job at kunin ang mga resulta​

Susunod, ipasa ang job_id sa API:

response_status_singlejob = requests.get(f"{url}/{job_id}", headers=headers)
response_status_singlejob.json().get('state')

Output

{'status': 'Completed'}

Kunin ang mga resulta ng job:

response_result = requests.get(f"{url}/{job_id}/results", headers=headers)

res_dict=response_result.json()

# Get results for the first PUB
counts=res_dict['results'][0]['data']['c']['samples']

print(counts[:20])

Output

['0x1', '0x2', '0x1', '0x2', '0x1', '0x2', '0x0', '0x2', '0x1', '0x1', '0x2', '0x2', '0x1', '0x1', '0x1', '0x1', '0x1', '0x1', '0x1', '0x1']

Mga susunod na hakbang​

Mga Rekomendasyon
  • Mayroong ilang paraan para patakbuhin ang mga workload, depende sa iyong pangangailangan: job mode, session mode, at batch mode. Alamin kung paano gamitin ang session mode at batch mode sa execution modes topic. Tandaan na ang mga user ng Open Plan ay hindi makakapagsumite ng mga session job.
  • Alamin kung paano i-initialize ang iyong account gamit ang REST API.
  • Magsanay gamit ang mga primitive sa pamamagitan ng paggawa ng Cost function lesson sa IBM Quantum® Learning.
  • Alamin kung paano mag-transpile nang lokal sa seksyong Transpile.
Pinagmulan: IBM Quantum docs — na-update noong Abr 27, 2026
Bersyong Ingles sa doQumentation — na-update noong Abr 27, 2026
Isyu sa site o pagsasalin?Isyu sa nilalaman? I-edit sa IBM Quantum docs