Portování kódu do Qiskit Serverless

Následující příklad ukazuje, jak portovat existující kód tak, aby využíval Qiskit Serverless.

poznámka

Následující kód předpokládá, že máš uložené přihlašovací údaje. Pokud ne, postupuj podle pokynů v části Nastavení účtu IBM Cloud a ověř se pomocí svého API klíče.

Aktualizace experimentu

Lokální 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())

Nahrání do Qiskit Serverless

Postupuj podle pokynů na stránce Úvod do Qiskit Functions a ověř se pomocí svého API klíče.

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)

Výstup

'transpile_remote_serverless'

Vzdálené spuštění v 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

Výstup

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

Další kroky

Doporučení

• Přečti si článek, ve kterém výzkumníci využili Qiskit Serverless a kvantové superpočítání zaměřené na kvantové systémy k prozkoumání kvantové chemie.