IBM Quantum Compute (antes « Qiskit Runtime ») Cliente

qiskit_ibm_runtime

Módulos relacionados con el cliente de IBM Quantum Compute (antes Qiskit Runtime ).

IBM Quantum Compute (antes « Qiskit Runtime ») es una nueva arquitectura que agiliza los cálculos que requieren muchas iteraciones. Estos experimentos se ejecutarán mucho más rápido gracias a su proceso híbrido cuántico-clásico mejorado.

Primitivas y sesiones

IBM Quantum Compute tiene dos primitivas predefinidas: Sampler y Estimator. Estas primitivas ofrecen una interfaz simplificada para realizar tareas básicas de computación cuántica, al tiempo que tienen en cuenta los últimos avances en hardware y software cuánticos.

IBM Quantum Compute también cuenta con el concepto de «sesión». El programador establece el orden de prioridad de los trabajos enviados durante una sesión. Una sesión te permite realizar llamadas iterativas al ordenador cuántico de forma más eficiente.

A continuación se muestra un ejemplo de uso de primitivas dentro de una sesión:

from qiskit_ibm_runtime import QiskitRuntimeService, Session
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit.circuit.library import real_amplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Initialize account.
service = QiskitRuntimeService()

# Prepare inputs.
psi = real_amplitudes(num_qubits=2, reps=2)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
theta = [0, 1, 1, 2, 3, 5]
# Bell Circuit
qr = QuantumRegister(2, name="qr")
cr = ClassicalRegister(2, name="cr")
qc = QuantumCircuit(qr, cr, name="bell")
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.measure(qr, cr)

backend = service.least_busy(operational=True, simulator=False)
pm = generate_preset_pass_manager(target=backend.target, optimization_level=1)

bell_isa_circuit = pm.run(qc)
psi_isa_circuit = pm.run(psi)
isa_observables = H1.apply_layout(psi_isa_circuit.layout)

with Session(backend=backend) as session:
    # Submit a request to the Sampler primitive within the session.
    sampler = Sampler(mode=session)
    job = sampler.run([bell_isa_circuit])
    pub_result = job.result()[0]
    print(f"Counts: {pub_result.data.cr.get_counts()}")

    # Submit a request to the Estimator primitive within the session.
    estimator = Estimator(mode=session)
    estimator.options.resilience_level = 1  # Set options.
    job = estimator.run(
        [(psi_isa_circuit, isa_observables, theta)]
    )
    pub_result = job.result()[0]
    print(f"Expectation values: {pub_result.data.evs}")

Modo de prueba local

Puede validar sus programas cuánticos antes de enviarlos a un sistema físico utilizando el modo de prueba local. El modo de prueba local se activa si se utiliza uno de los backends falsos de qiskit_ibm_runtime.fake_provider o una instancia de backend Qiskit Aer al instanciar una primitiva o una sesión. Por ejemplo:

from qiskit_aer import AerSimulator
from qiskit.circuit.library import real_amplitudes
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

from qiskit_ibm_runtime import Session
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Bell Circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Run the sampler job locally using FakeManilaV2
fake_manila = FakeManilaV2()
pm = generate_preset_pass_manager(backend=fake_manila, optimization_level=1)
isa_qc = pm.run(qc)
sampler = Sampler(backend=fake_manila)
result = sampler.run([isa_qc]).result()

# Run the sampler job locally using AerSimulator.
# Session syntax is supported but ignored.
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=1)
isa_qc = pm.run(qc)
with Session(backend=aer_sim) as session:
    sampler = Sampler(mode=session)
    result = sampler.run([isa_qc]).result()

Datos del backend

QiskitRuntimeService También dispone de métodos, como backend(), backends(), y least_busy(), que te permiten buscar un backend de destino que se vaya a utilizar. Estos métodos devuelven una o varias IBMBackend instancias que contienen métodos y atributos que describen el backend.

Información complementaria

Inicialización de la cuenta

Debes inicializar tu cuenta antes de poder empezar a utilizar el servicio IBM Quantum Compute. Para ello, hay que inicializar una instancia QiskitRuntimeService con las credenciales de tu cuenta. Si no quieres introducir las credenciales cada vez, puedes utilizar el método QiskitRuntimeService.save_account() para guardarlas en el disco.

IBM Quantum Compute está disponible en IBM Cloud, y puedes seleccionar el canal con o channel="ibm_cloud" channel="ibm_quantum_platform".

IBM Quantum Compute Empleos

Cuando se utiliza el run() método de o Estimator para invocar la primitiva, se devuelve una RuntimeJobV2 instancia de Sampler . Esta clase cuenta con todos los métodos básicos de trabajo, como RuntimeJobV2.status(), RuntimeJobV2.result(), y RuntimeJobV2.cancel().

Registro

qiskit-ibm-runtime utiliza el registrador qiskit_ibm_runtime .

Se pueden utilizar dos variables de entorno para controlar el registro:

• QISKIT_IBM_RUNTIME_LOG_LEVEL: Especifica el nivel de registro a utilizar.

  Si se establece un nivel no válido, el nivel de registro por defecto es WARNING. Los niveles de registro válidos son DEBUG, INFO, WARNING, ERROR y CRITICAL (sin distinción entre mayúsculas y minúsculas). Si no se establece la variable de entorno, se utiliza el nivel del registrador principal, que también es por defecto WARNING.

• QISKIT_IBM_RUNTIME_LOG_FILE: Especifica el nombre del archivo de registro a utilizar. Si se especifica,

  los mensajes sólo se registrarán en el archivo. De lo contrario, los mensajes se registrarán en el error estándar (normalmente la pantalla).

Para un uso más avanzado, puedes modificar el propio registrador. Por ejemplo, para ajustar manualmente el nivel a WARNING:

import logging
logging.getLogger('qiskit_ibm_runtime').setLevel(logging.WARNING)

Clases