Portar código a Qiskit Serverless

consejo

Qiskit Serverless está recibiendo una actualización y sus funciones están cambiando rápidamente. Durante esta fase de desarrollo, encuentra las notas de versión y la documentación más reciente en la página de GitHub de Qiskit Serverless.

El siguiente ejemplo muestra cómo portar código existente para aprovechar Qiskit Serverless.

nota

El siguiente código asume que ya guardaste tus credenciales. Si no lo has hecho, sigue las instrucciones en Configura tu cuenta de IBM Cloud para autenticarte con tu clave de API.

Actualizar el experimento

nota

En la versión de Serverless, crea el servicio de runtime con get_runtime_service() (desde qiskit_serverless) en lugar de QiskitRuntimeService(), para que los trabajos y sesiones del IBM Quantum® Compute Service que lance se rastreen frente al trabajo padre de Qiskit Serverless. Consulta Escribe tu primer programa de Qiskit Serverless para más detalles.

Experimento local

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.circuit.random import random_circuit

qc_random = [(random_circuit(20, 20, measure=True)) for _ in range(30)]
optimization_level = 3

service = QiskitRuntimeService(channel="ibm_quantum_platform")
backend = service.get_backend(backend_name)

pass_manager = generate_preset_pass_manager(
    optimization_level=optimization_level, backend=backend
)

# @distribute_task(target={"cpu": 1})
def transpile_parallel(circuit, pass_manager):
    """Distributed transpilation for an abstract circuit into an ISA circuit for a given backend."""

    isa_circuit = pass_manager.run(circuit)

    return isa_circuit

transpiled_circuits = [
    transpile_parallel(circuit, pass_manager)
    for circuit in circuits
]

print(transpiled_circuits)

Serverless

# transpile_remote.py

from qiskit.transpiler import generate_preset_pass_manager
from qiskit_serverless import get_arguments, save_result, distribute_task, get, get_runtime_service

# Obtener los argumentos del programa
arguments = get_arguments()
circuits = arguments.get("circuits")
backend_name = arguments.get("backend_name")
optimization_level = arguments.get("optimization_level")
pass_manager = generate_preset_pass_manager(
optimization_level=optimization_level, backend=backend_name
)

# Distribuir la tarea entre los trabajadores
@distribute_task(target={"cpu": 1})
def transpile_parallel(circuit, pass_manager):
"""Distributed transpilation for an abstract circuit into an ISA circuit for a given backend."""

isa_circuit = pass_manager.run(circuit)

return isa_circuit

try:
# Get backend
service = get_runtime_service()
backend = service.get_backend(backend_name)

# run distributed tasks as async function
# we get task references as a return type
sample_task_references = [
    transpile_parallel(circuit, pass_manager)
    for circuit in circuits
]

# now we need to collect results from task references
results = get(sample_task_references)

# Return results
save_result({
    "transpiled_circuits": results
})

except Exception as e:
# Exception handling
import traceback
print(traceback.format_exc())

Upload to Qiskit Serverless

Follow the instructions on the Introduction to Qiskit Functions page to authenticate with your API key.

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

# Authenticate to the remote cluster and submit the pattern for remote execution.
serverless = QiskitServerless()

transpile_remote_demo = QiskitFunction(
    title="transpile_remote_serverless",
    entrypoint="transpile_remote.py",
    working_dir="./source_files/",
)

serverless.upload(transpile_remote_demo)

Salida

'transpile_remote_serverless'

Ejecutar remotamente en Qiskit Serverless

from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService

# Setup inputs
qc_random = [(random_circuit(20, 20, measure=True)) for _ in range(30)]
backend = "ibm_brisbane"
optimization_level = 3

# Running program
transpile_remote_serverless = serverless.load('transpile_remote_serverless')
job = transpile_remote_serverless.run(
    circuits=qc_random,
    backend=backend,
    optimization_level=optimization_level
)

job.job_id

Salida

'727e921d-512d-4b7d-af97-fe29e93ce7ea'

Próximos pasos

Recomendaciones

• Lee un artículo en el que investigadores usaron Qiskit Serverless y la supercomputación centrada en lo cuántico para explorar la química cuántica.