Inizia a utilizzare Qiskit Functions

Gli utenti dei piani Premium, Flex e " On-Prem " (tramite l'API IBM Quantum Platform ) possono iniziare a utilizzare " IBM " Qiskit Functions gratuitamente oppure possono acquistare una licenza da uno dei partner che hanno contribuito con una funzione al catalogo.

Richiedi una prova gratuita di " Qiskit Functions " di terze parti

Per richiedere una prova gratuita, vai alla pagina Qiskit Functions Catalog ed esplora il pannello dei dettagli. AccessGroupIdClicca qui Request a free trial e inserisci le informazioni richieste dal partner Functions, tra cui l' IBM Cloud :

1. Accedere a IBM Cloud IAM.
2. Verifica i requisiti di idoneità.
   • Nella barra dei menu nell'intestazione, seleziona un account con il seguente formato: XXXXXXX - [Organization Name]
   • Assicurati che l'organizzazione sia la stessa di quella associata al tuo account Premium.
   • Se vedi la dicitura "Account [di] [il tuo nome]", significa che stai utilizzando il tuo account personale, che non dà diritto all'accesso premium.
3. Trova l'ID del tuo gruppo di accesso.
   • Fai clic sul nome di un gruppo.
   • Fai clic su "Dettagli".
   • Copia l'ID del gruppo di accesso. Dovrebbe iniziare con AccessGroup-.

Installa il client Qiskit Functions Catalog

1. Per iniziare a utilizzare Qiskit Functions, installa il client IBM Qiskit Functions Catalog :

   pip install qiskit-ibm-catalog

2. Recupera la tua chiave API dalla dashboard IBM Quantum Platform e attiva il tuo ambiente virtuale Python. Se non hai ancora configurato un ambiente virtuale, consulta le istruzioni di installazione.

   Se stai lavorando in un ambiente Python affidabile (ad esempio su un laptop personale o su una workstation aziendale), utilizza il save_account() metodo per salvare le tue credenziali in locale. ( Passa al passaggio successivo se non stai utilizzando un ambiente affidabile, come un computer condiviso o pubblico, per effettuare l'autenticazione su IBM Quantum Platform.)

   save_account()Per utilizzarlo, esegui python nella tua shell, quindi digita quanto segue:

   from qiskit_ibm_catalog import QiskitFunctionsCatalog
   
   QiskitFunctionsCatalog.save_account(channel="ibm_quantum_platform", token="<your-token>", instance="<instance-crn>")

   Digita exit(). D'ora in poi, ogni volta che dovrai effettuare l'autenticazione al servizio, potrai caricare le tue credenziali nel modo seguente:

   from qiskit_ibm_catalog import QiskitFunctionsCatalog
   catalog = QiskitFunctionsCatalog()

   Ad esempio:

# Load saved credentials
from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

Evitare di eseguire codice su un computer non attendibile o su un ambiente cloud esterno Python per ridurre al minimo i rischi per la sicurezza. Se devi utilizzare un ambiente non attendibile (ad esempio, su un computer pubblico), modifica la tua chiave API dopo ogni utilizzo eliminandola dalla pagina delle chiavi API IBM Cloud per ridurre i rischi. Per ulteriori informazioni, consulta l'argomento " Gestione delle chiavi API degli utenti ". Per inizializzare il servizio in questa situazione, utilizzare il seguente codice:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

# After using the following code, delete your API key on the
# IBM Quantum Platform home dashboard
catalog = QiskitFunctionsCatalog(token="<YOUR_API_KEY>") # Use the 44-character
# API_KEY you created and saved from the IBM Quantum Platform Home dashboard

Elenca le funzioni a cui puoi accedere

Una volta effettuato l'accesso, è possibile visualizzare l'elenco delle funzioni dell' Qiskit Functions Catalog a cui si ha accesso:

catalog.list()

Output:

[QiskitFunction(qunova/hivqe-chemistry),
 QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),
 QiskitFunction(algorithmiq/tem),
 QiskitFunction(qedma/qesem),
 QiskitFunction(multiverse/singularity),
 QiskitFunction(ibm/circuit-function),
 QiskitFunction(q-ctrl/optimization-solver),
 QiskitFunction(colibritd/quick-pde),
 QiskitFunction(q-ctrl/performance-management),
 QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]

Esegui le funzioni abilitate

catalog.load("<provider/function-name>")Dopo aver istanziato un oggetto del catalogo, è possibile selezionare una funzione utilizzando:

qesem_function = catalog.load("qedma/qesem")

Ogni funzione di Qiskit presenta input, opzioni e output personalizzati. Per ulteriori informazioni, consulta le pagine della documentazione relative alla funzione che desideri eseguire. Per impostazione predefinita, tutti gli utenti possono eseguire solo un processo di funzione alla volta:

from qiskit.quantum_info import SparsePauliOp

avg_magnetization = SparsePauliOp.from_sparse_list(
    [("Z", [q], 1 / 5) for q in range(5)], num_qubits=5
)

job = qesem_function.run(
    pubs=[(circuit, [avg_magnetization, observable])],
    backend_name=backend_name,  # example: "ibm_fez"
    # options = {
    #     "estimate_time_only": "empirical",
    #     "default_precision": 0.2,  # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details
    #     "max_execution_time": 3600,  # You can specify a maximum QPU time in seconds, see API reference for more details
    #     "transpilation_level": "standard",  # "minimal_with_layout_opt" for minimal transpilation, see API reference for more details
    #     "parallel_execution": True,  # True for parallel execution, see API reference for more details
    # },
)
job.job_id

Output:

'7f08c9d5-471b-4da2-92e7-4f2cb94c23a8'

job = qesem_function.run(
    pubs=[(circuit, [avg_magnetization, observable])],
    backend_name=backend_name,  # example: "ibm_fez"
    suppress_low_usage_warning=True,
    # options = {
    #     "estimate_time_only": "empirical",
    #     "default_precision": 0.2,  # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details
    #     "max_execution_time": 3600,  # You can specify a maximum QPU time in seconds, see API reference for more details
    #     "transpilation_level": "standard",  # "minimal_with_layout_opt" for minimal transpilation, see API reference for more details
    #     "parallel_execution": True,  # True for parallel execution, see API reference for more details
    # },
)

Verifica lo stato del lavoro

job_idCon la funzione Qiskit è possibile verificare lo stato dei lavori in esecuzione. Ciò comprende i seguenti stati:

• QUEUED: Il programma remoto si trova nella coda delle funzioni di Qiskit. La priorità nella coda dipende dall'utilizzo che hai fatto di Qiskit Functions.
• INITIALIZING: Il programma remoto si sta avviando; ciò comprende la configurazione dell'ambiente remoto e l'installazione delle dipendenze.
• RUNNING: Il programma è in esecuzione. Ciò include anche diversi stati più dettagliati, qualora siano supportati da funzioni specifiche.
  • RUNNING: MAPPING: La funzione sta attualmente mappando i tuoi input classici sugli input quantistici.
  • RUNNING: OPTIMIZING_FOR_HARDWARE: La funzione sta ottimizzando il funzionamento per la QPU selezionata. Ciò potrebbe includere la transpilazione dei circuiti, la caratterizzazione della QPU, la retropropagazione degli osservabili e così via.
  • RUNNING: WAITING_FOR_QPU: La funzione ha inviato un processo al servizio di elaborazione di IBM Quantum ed è in attesa nella coda.
  • RUNNING: EXECUTING_QPU: La funzione ha un processo di calcolo quantistico attivo.
  • RUNNING: POST_PROCESSING: La funzione consiste nell'elaborazione successiva dei risultati, che può includere la correzione degli errori, la mappatura dei risultati quantistici in quelli classici e così via.
• DONE: Il programma è terminato ed è possibile recuperare i dati dei risultati con job.result().
• ERROR: Il programma ha smesso di funzionare a causa di un problema. Utilizza job.result() per visualizzare il messaggio di errore.
• CANCELED: Il programma è stato annullato da un utente, dal servizio o dal server.

job.status()

Output:

'QUEUED'

Recupera i risultati

Una volta che il programma è stato eseguito DONE, puoi usare job.result() per recuperare il risultato. Questo formato di output varia a seconda della funzione, quindi assicurati di seguire le indicazioni riportate nella documentazione specifica:

result = job.result()
print(result)

Output:

PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(), dtype=float64>), stds=np.ndarray(<shape=(), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(), dtype=float64>)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': True, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})

È inoltre possibile annullare un lavoro in qualsiasi momento:

job.cancel()

Output:

'Job has been stopped.'

Accedi ai lavori Quantum Compute associati

Una funzione Qiskit può inviare uno o più lavori di calcolo quantistico a una QPU mentre questa è in esecuzione. Per recuperare gli ID di tali processi in esecuzione, utilizzare job.runtime_jobs(). È possibile utilizzare questi ID per recuperare gli oggetti dei lavori in esecuzione da un’istanza QiskitRuntimeService oppure per individuare i carichi di lavoro sulla dashboard di IBM Quantum® Platform.

runtime_job_ids = job.runtime_jobs()
runtime_job_ids

Se una funzione raggruppa i propri processi in esecuzione in sessioni o batch, utilizzare job.runtime_sessions() per elencare gli ID delle sessioni. Passare un ID di sessione a job.runtime_jobs() per restituire solo i lavori in esecuzione in quella sessione:

sessions = job.runtime_sessions()
if sessions:
    session_runtime_jobs = job.runtime_jobs(runtime_session=sessions[0])
    print(session_runtime_jobs)
else:
    print("No runtime sessions for this job.")

Visualizza i log del lavoro

Utilizzare job.logs() per recuperare l'output di log generato da una funzione durante la sua esecuzione. I log sono utili per monitorare lo stato di avanzamento e per eseguire il debug di un processo che termina in uno stato ERROR .

print(job.logs().splitlines())

Per un’elaborazione di lunga durata che genera molte righe di log, usa job.filtered_logs() per restituire solo le righe desiderate. Passare un'espressione regolare a include per mantenere le righe corrispondenti, oppure a exclude per eliminare le righe corrispondenti:

print(job.filtered_logs(include="iteration"))

Elenca i lavori Qiskit Functions eseguiti in precedenza

È possibile utilizzare jobs() per visualizzare l'elenco di tutti i lavori inviati a Qiskit Functions :

old_jobs = catalog.jobs()
old_jobs

Output:

[<Job | f6c29f49-4d5f-4fff-aca6-2e9a115b9763>,
 <Job | 7f08c9d5-471b-4da2-92e7-4f2cb94c23a8>,
 <Job | 62fe9176-d1e5-467e-b2bd-7a3f3c7be4e5>,
 <Job | af525b2e-16b1-45a1-80bb-dbd94ce30258>,
 <Job | b95a7a57-c1ad-4958-b7ac-953e4e1ee824>,
 <Job | 7bfa33da-0f17-4e67-84b6-f556f7eeb436>,
 <Job | ca46c191-9eb9-4de6-bfa7-b60d7eb29b5e>,
 <Job | 6ac0ba93-3831-43fb-9fb9-760da2225e06>,
 <Job | f0e38071-060d-47e8-988d-9cc1f69358e3>,
 <Job | 629cf110-e490-4675-8a07-f6d298d166b0>]

Per restringere i risultati, applica dei filtri. Filtra per funzione con function, per stato con statuse per data di invio con created_after. Sfoglia i risultati con e limit offset:

recent_errors = catalog.jobs(
    function=qesem_function,
    status="ERROR",
    created_after="2024-01-01T00:00:00Z",
    limit=5,
)
recent_errors

Se disponi già dell'ID di un determinato lavoro, puoi recuperarlo con catalog.job():

# First, get the most recent job that has been executed.
latest_job = old_jobs[0]

# We can also get that same job with `catalog.job`
job_by_id = catalog.job(latest_job.job_id)

# Verify that the job is the same using both retrieval methods.
assert job_by_id.job_id == latest_job.job_id

# Print the job_id for this job.
print(job_by_id.job_id)

Output:

f6c29f49-4d5f-4fff-aca6-2e9a115b9763

Recupera i messaggi di errore

Se lo stato di un programma è ERROR, utilizzare job.error_message() per recuperare il messaggio di errore come segue:

job.error_message()

Output:

qiskit.exceptions.QiskitError: 'Workflow execution failed -- https://docs.quantum.ibm.com/errors#9999'

Passi successivi