Porta il codice su Qiskit Serverless

Il seguente esempio mostra come portare il codice esistente per sfruttare Qiskit Serverless.

nota

Il codice seguente presuppone che tu abbia salvato le tue credenziali. Se non l'hai ancora fatto, segui le istruzioni in Configura il tuo account IBM Cloud per autenticarti con la tua chiave API.

Aggiorna l'esperimento

Local Experiment

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
from qiskit_ibm_runtime import QiskitRuntimeService

# Get program arguments
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
)

# Distribute task across workers
@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 = QiskitRuntimeService()
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())

Carica su Qiskit Serverless

Segui le istruzioni nella pagina Introduzione alle funzioni Qiskit per autenticarti con la tua chiave API.

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)

Output

'transpile_remote_serverless'

Esecuzione remota in 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

Output

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

Passi successivi

Raccomandazioni

• Leggi un articolo in cui i ricercatori hanno usato Qiskit Serverless e il supercalcolo quantistico-centrico per esplorare la chimica quantistica.