Skip to main content
IBM Quantum Platform

Estimateur avec l'API REST

Versions de package

Le code présenté sur cette page a été développé en tenant compte des exigences suivantes. Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.

qiskit[all]~=2.3.0

Les étapes décrites dans cette rubrique expliquent comment exécuter et configurer des charges de travail à l'aide de l'API REST, et montrent comment les appeler depuis n'importe quel programme de votre choix.

Note

Cette documentation utilise le requests module Python pour présenter l'API REST. Toutefois, ce workflow peut être exécuté à l'aide de n'importe quel langage ou framework prenant en charge l'utilisation des API REST. Pour plus de détails, consultez la documentation de référence de l'API.

1. Créer le compte

Estimator étant un service géré, vous devez d'abord configurer votre compte. Vous pouvez ensuite sélectionner l'appareil que vous souhaitez utiliser pour calculer la valeur attendue.

Vous trouverez dans cette rubrique des informations détaillées sur la manière d'initialiser votre compte, de consulter les backends disponibles et d'invalider des jetons.

2. Créer un circuit QASM

Vous devez fournir au moins un circuit en entrée à la primitive Estimator.

Définissez un circuit quantique QASM. Par exemple :

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];
'''

Les extraits de code suivants partent du principe que qasm_string a été transcompilé en une nouvelle chaîne resulting_qasm.

3. Exécuter le circuit quantique à l'aide de l'API Estimator d' V2

Note

Les tâches suivantes utilisent les primitives IBM Quantum V2. Les deux, et SamplerV2 , prennent EstimatorV2 en entrée un ou plusieurs blocs unifiés primitifs (PUB). Chaque « PUB » est un tuple contenant un circuit et les données diffusées sur ce circuit, qui peuvent être plusieurs observables et paramètres. Chaque PUB renvoie un résultat.

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. Vérifier l'état d'avancement de la tâche et obtenir les résultats

Ensuite, transmettez le job_id à l'API :

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

Sortie

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

Obtenir les résultats de la recherche d'emploi :

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

res_dict=response_result.json()

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

Sortie

[{'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. Utiliser les options

Les techniques d'atténuation des erreurs permettent aux utilisateurs d'atténuer les erreurs de circuit en modélisant le bruit du dispositif au moment de l'exécution. Cela entraîne généralement une charge de travail de prétraitement quantique liée à l'entraînement du modèle, ainsi qu'une charge de travail de post-traitement classique visant à corriger les erreurs présentes dans les résultats bruts à l'aide du modèle généré.

Les techniques d'atténuation des erreurs intégrées aux primitives constituent des options avancées de résilience. Pour définir ces options, utilisez resilience_level l'option lors de l'envoi de votre tâche.

Les exemples suivants illustrent les options par défaut pour le découplage dynamique, le twirling et TREX + ZNE. Vous trouverez d'autres options et des informations complémentaires dans la rubrique « Techniques d'atténuation et de suppression des erreurs ».

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}")

Découplage dynamique

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}")

Tourbillon

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}")

Circuits paramétrés

1. Créer le compte

Vous devez d'abord configurer votre compte. Vous pouvez ensuite sélectionner l'appareil sur lequel vous souhaitez effectuer vos calculs.

Vous trouverez dans cette rubrique des informations détaillées sur la manière d'initialiser votre compte, de consulter les backends disponibles et d'invalider des jetons.

2. Définir les paramètres

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. Créer un circuit quantique et ajouter des portes paramétrées

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. Générer du code QASM 3

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

5. Exécuter le circuit quantique à l'aide de l'API Estimator d' V2

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. Vérifier l'état de la tâche et obtenir les résultats

Ensuite, transmettez le job_id à l'API :

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

Sortie

{'status': 'Completed'}

Obtenir les résultats de la recherche d'emploi :

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])

Sortie

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

Etapes suivantes

Recommandations
  • Il existe plusieurs façons d'exécuter des charges de travail, en fonction de vos besoins : le mode tâche, le mode session et le mode batch. Découvrez comment utiliser le mode session et le mode batch dans la rubrique consacrée aux modes d'exécution. Veuillez noter que les utilisateurs d'Open Plan ne peuvent pas soumettre de tâches de session.
  • Découvrez comment configurer votre compte à l'aide de l'API REST.
  • Entraînez-vous avec les primitives en suivant la leçon sur la fonction « Cost » dans « IBM Quantum® Learning ».
  • Découvrez comment effectuer une transpilation en local dans la section « Transpilation ».
Cette page a-t-elle été utile ?
Signaler un bogue, une coquille ou proposer du contenu sur GitHub.