Crear una instancia de servicio

Si ya ha creado una instancia de servicio de Qiskit Runtime o si un administrador le ha invitado a una, vaya al paso siguiente. Para determinar si ya tiene acceso a una instancia, consulte la página de instancias deIBM Cloud. Si tiene una o más instancias mostradas, puede pasar a Instalar paquetes de Qiskit.

1. En la página de suministro deQiskit Runtime, elija el plan de servicio adecuado, en función de a qué necesite acceder. Para obtener más información sobre estos planes, consulte el tema Planes deQiskit Runtime.

   • Lite (obsoleto ): Plan gratuito solo para simuladores para ayudarte a empezar con Qiskit Runtime. Aprenda a utilizar Qiskit Runtime siguiendo nuestros ejemplos y guías de aprendizaje para uno de los programas precompilados disponibles para ejecutar circuitos de forma eficiente.
   • Estándar: Un modelo de pago por uso para accederIBM QPU y simuladores. Cree sus propios programas y aproveche todas las ventajas de Qiskit Runtime ejecutándose en hardware cuántico real, manteniendo al mismo tiempo el acceso a todos los simuladores disponibles para el plan Lite.

2. Complete la información requerida y haga clic en Crear.

Instalar o actualizar paquetes de Qiskit

Instale o actualice los paquetes siguientes en el entorno de desarrollo. Le permiten crear circuitos y trabajar con programas primitivos con Qiskit Runtime. Para obtener instrucciones detalladas, consulte el tema de instalación y configuración de Qiskit. Compruebe periódicamente las notas del release de Qiskit (o vuelva a ejecutar estos mandatos) para que siempre tenga la versión más reciente.

No puedes usar ' pip install -U qiskit ' para actualizar desde cualquier versión de Qiskit 0.x a 1.0 o posterior. Consulte la guía de migración a Qiskit 1.0 0 para obtener más detalles e instrucciones.

Asegúrese de ejecutar estos mandatos incluso si ya ha instalado los paquetes, para asegurarse de que tiene las versiones más recientes.

# Installs the latest version of the Qiskit meta-package for circuit creation.
pip install qiskit -U

# Installs the latest version of the Qiskit Runtime package, which is needed to interact with the Qiskit Runtime primitives on IBM Cloud.
pip install qiskit-ibm-runtime -U

Autenticar en el servicio

Para autenticarse en el servicio, llame a QiskitRuntimeService con la clave de API de IBM Cloud y el CRN:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel="ibm_cloud", token="<IBM Cloud API key>", instance="<IBM Cloud CRN>")

Opcionalmente, guarde las credenciales en el disco

Opcionalmente, guarde las credenciales en el disco (en el archivo $HOME/.qiskit/qiskit-ibm.json ). Si no guarda las credenciales en el disco, debe especificar las credenciales cada vez que inicie una nueva sesión.

Si guarda las credenciales en el disco, puede utilizar QiskitRuntimeService() en el futuro para inicializar la cuenta.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save account to disk and save it as the default.
QiskitRuntimeService.save_account(channel="ibm_cloud", token="<IBM Cloud API key>", instance="<IBM Cloud CRN>", name="account-name", set_as_default=True)

# Load the saved credentials
service = QiskitRuntimeService(name="account-name")

Si necesita actualizar las credenciales guardadas, vuelva a ejecutar save_account, pasando overwrite=True y las credenciales actualizadas.

Para obtener instrucciones sobre cómo utilizar la API Quantum Qiskit de nube, consulte la sección authentication en la documentación de la API.

Probar la configuración

Ejecute un circuito simple utilizando Sampler para asegurarse de que el entorno se ha configurado correctamente:

from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

# Create empty circuit
example_circuit = QuantumCircuit(2)
example_circuit.measure_all()

# You'll need to specify the credentials when initializing QiskitRuntimeService, if they were not previously saved.
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

sampler = Sampler(backend)
job = sampler.run([example_circuit])
print(f"job id: {job.job_id()}")
result = job.result()
print(result)

Ejecutar un programa

Qiskit Runtime utiliza programas primitivos para interactuar con sistemas cuánticos. Los siguientes programas están disponibles públicamente. Para obtener más información sobre los cambios en las primitivas V2, consulte Migrar a las primitivas V2

• Muestra: Permite al usuario especificar un circuito como entrada y luego devolver las salidas (cadenas de bits) de cada disparo (V2 ), o cuasiprobabilidades (V1 ). Esto permite a los usuarios evaluar de manera más eficiente la posibilidad de múltiples puntos de datos relevantes en el contexto de interferencia destructiva.
• Estimador: Permite a un usuario especificar una lista de circuitos y observables y agrupar selectivamente entre las listas para evaluar eficientemente los valores de expectativa y las varianzas para una entrada de parámetro determinada. Está diseñado para permitir a los usuarios calcular e interpretar eficientemente los valores de expectativa de los operadores cuánticos que son necesarios para muchos algoritmos.

Este ejemplo utiliza la primitiva Sampler:

# Prepare the input circuit.
from qiskit import QuantumCircuit

bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()

# Execute the circuit
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Run the sampler job locally using FakeManilaV2
backend = FakeManilaV2()

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_bell = pm.run(bell)

sampler = Sampler(backend)

job = sampler.run([(isa_bell,)])
result = job.result()

pub_result = result[0]
# Get counts from the classical register "meas".
print(f" >> Counts for the meas output register: {pub_result.data.meas.get_counts()}")

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Create a new circuit with two qubits (first argument) and two classical
# bits (second argument)
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

# Set up six different observables.
observables_labels = ["ZZ", "ZI", "IZ", "XX", "XI"]

from qiskit.quantum_info import SparsePauliOp
observables = [SparsePauliOp(label) for label in observables_labels]

# Convert to an ISA circuit and layout-mapped observables.
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_circuit = pm.run(qc)
observables = [
    observable.apply_layout(isa_circuit.layout) for observable in observables
]

Próximos pasos

• Vea la referencia de API.
• Obtenga más información sobre IBM Quantum Computing.