Escribe tu primer programa « Qiskit Serverless »

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o versiones más recientes.

  qiskit[all]~=1.3.1
  qiskit-ibm-runtime~=0.34.0
  qiskit-aer~=0.15.1
  qiskit-serverless~=0.18.1
  qiskit-ibm-catalog~=0.2
  qiskit-addon-sqd~=0.8.1
  qiskit-addon-utils~=0.1.0
  qiskit-addon-mpf~=0.2.0
  qiskit-addon-aqc-tensor~=0.1.2
  qiskit-addon-obp~=0.1.0
  scipy~=1.15.0
  pyscf~=2.8.0
  

Este ejemplo muestra cómo utilizar qiskit-serverless herramientas para crear un programa de transpilación en paralelo y, a continuación, implementar el programa qiskit-ibm-catalog para subirlo a IBM Quantum Platform y utilizarlo como un servicio remoto reutilizable.

Resumen del flujo de trabajo

1. Crea un directorio local y un archivo de programa vacío (./source_files/transpile_remote.py)
2. Añade código a tu programa que, al subirlo a Qiskit Serverless, compile un circuito
3. Utilice qiskit-ibm-catalog para autenticarse en Qiskit Serverless
4. Sube el programa a Qiskit Serverless

Una vez que hayas subido tu programa, puedes ejecutarlo para transpilar el circuito siguiendo la guía «Ejecuta tu primera carga de trabajo de Qiskit Serverless de forma remota».

Ejemplo: Transpilación remota con Qiskit Serverless

Este ejemplo te guía paso a paso en la creación y ampliación de un archivo de programa que, al subirlo a Qiskit Serverless, compilará un circuit en función de un determinado backend y una de destino optimization_level.

serverless_program
├── program_uploader.ipynb
└── source_files
    ├── transpile_remote.py
    └── *.py

Serverless carga el contenido de un directorio específico (en este ejemplo, el source_files directorio) para ejecutarlo de forma remota. Una vez configurados, puedes ajustarlos transpile_remote.py para que recojan los datos de entrada y devuelvan los de salida.

Crea el directorio y un archivo de programa vacío

En primer lugar, crea un directorio llamado source_files, y luego crea un archivo de programa en ese directorio, de modo que su ruta sea ./source_files/transpile_remote.py. Este es el archivo que debes subir a Qiskit Serverless.

Añade código a tu archivo de programa

Introduce el siguiente código en tu archivo de programa y, a continuación, guárdalo.

# This cell is hidden from users, it creates a new folder
from pathlib import Path

Path("./source_files").mkdir(exist_ok=True)

# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit.transpiler import generate_preset_pass_manager

def transpile_remote(circuit, optimization_level, backend):
    """Transpiles an abstract circuit into an ISA circuit for a given backend."""
    pass_manager = generate_preset_pass_manager(
        optimization_level=optimization_level,
		backend=backend
    )
    isa_circuit = pass_manager.run(circuit)
    return isa_circuit

Añade código para obtener los argumentos del programa

Ahora añade el siguiente código a tu archivo de programa, que configura los argumentos del programa.

Su transpile_remote.py inicial tiene tres entradas: circuits, backend_name, y optimization_level. Serverless está actualmente limitado a aceptar sólo entradas y salidas serializables. Por esta razón, no puede introducir backend directamente, así que utilice backend_name como cadena.

# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit_serverless import get_arguments, save_result, distribute_task, get

# Get program arguments
arguments = get_arguments()
circuits = arguments.get("circuits")
backend_name = arguments.get("backend_name")
optimization_level = arguments.get("optimization_level")

Añade el código que llama al backend

Añade el siguiente código a tu archivo de programa, que llama a tu backend con QiskitRuntimeService.

El siguiente código asume que ya ha seguido el proceso para guardar sus credenciales utilizando QiskitRuntimeService.save_account, y cargará su cuenta guardada por defecto a menos que especifique lo contrario. Consulte Guardar sus credenciales de inicio de sesión e Inicializar su cuenta de servicio Qiskit Runtime para obtener más información.

# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend(backend_name)

Añadir código para transpilar

Por último, añade el siguiente código a tu archivo de programa. Este código se ejecuta transpile_remote() sobre todos los valores circuits pasados y devuelve el transpiled_circuits resultado:

# If you include the preceding `%%writefile` command (visible only when you read this
# locally in a notebook), running this cell saves to disk rather than executing the code.

# Each circuit is being transpiled and will populate the array
results = [
    transpile_remote(circuit, 1, backend)
    for circuit in circuits
]

save_result({
    "transpiled_circuits": results
})

Inicia sesión en Qiskit Serverless

Utiliza qiskit-ibm-catalog para autenticarte en QiskitServerless con tu clave API (puedes usar tu clave QiskitRuntimeService API o crear una nueva en el panel de control de IBM Quantum Platform ).

from qiskit_ibm_catalog import QiskitServerless, QiskitFunction

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

Ejecuta el código para subir el archivo

Ejecuta el siguiente código para cargar el programa. Qiskit Serverless comprime el contenido de working_dir (en este caso, source_files) en un archivo tar, que se sube y, a continuación, se elimina. El entrypoint identifica el archivo ejecutable principal del programa para que se ejecute « Qiskit Serverless ».

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

serverless.upload(transpile_remote_demo)

Output:

QiskitFunction(transpile_remote_serverless)

Verificar la subida

Para comprobar si se ha subido correctamente, utiliza serverless.list(), tal y como se muestra en el siguiente código:

# Get program from serverless.list() that matches the title of the one we uploaded
next(
    program
    for program in serverless.list()
    if program.title == "transpile_remote_serverless"
)

Output:

QiskitFunction(transpile_remote_serverless)

Próximos pasos