Exemple d'utilisation de l'API REST

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 du service IBM Quantum Compute. 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

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

Pour savoir comment configurer votre compte, consulter les backends disponibles et utiliser les jetons, consultez la section « Configuration pour utiliser l' IBM Quantum Platform avec l'API REST ».

2. Créer un circuit QASM

Il faut au moins un circuit comme entrée pour la primitive Sampler.

Définir un circuit quantique QASM :

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 ci-dessous partent du principe que a qasm_string été transpilé en une nouvelle chaîne resulting_qasm.

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

Note

Les tâches ci-dessous utilisent les primitives IBM Quantum V2. SamplerV2 prend 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 correspondre à plusieurs paramètres); il renvoie un résultat par PUB.

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': 'sampler',
    "backend": backend,
    "params": {
        # primitive unified blocs (PUBs) containing one circuit each:
        "pubs": [[resulting_qasm],[resulting_qasm,None,500]] 
}}

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-942fb30edced
>>> 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()

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

print(counts[:20])

Sortie

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

5. Utilisation des options du service de calcul d' IBM Quantum

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. L' V2 de l'échantillonneur ne prend pas en charge la définition de niveaux de résilience. Vous pouvez toutefois activer ou désactiver certaines méthodes de limitation ou de suppression des erreurs.

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

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': 'sampler',
    "backend": backend,
    "params": {
        # primitive unified blocs (PUBs) containing one circuit each:
        "pubs": [[resulting_qasm]], 
        "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': 'sampler',
    "backend": backend,
    "params": {
        # primitive unified blocs (PUBs) containing one circuit each:
        "pubs": [[resulting_qasm]], 
        "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')
# In case we want to pass a dictionary:
parameter_values = {'theta': 1.57, 'phi': 3.14}

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 Sampler 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': 'sampler',
    "backend": backend,
    "params": {
        # Choose one option: direct parameter transfer or through a dictionary
        # # primitive unified blocs (PUBs) containing one circuit each:
        #"pubs": [[qasm_str,[1,2],500]], 

        # primitive unified blocs (PUBs) containing one circuit each:
        "pubs": [[qasm_str,parameter_values,500]], 
}}

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.