Vai al contenuto principale

Iskay Quantum Optimizer - Una Qiskit Function di Kipu Quantum

Nota
  • Le Qiskit Functions sono una funzionalità sperimentale disponibile solo per gli utenti dei piani IBM Quantum® Premium Plan, Flex Plan e On-Prem (tramite IBM Quantum Platform API). Sono in stato di anteprima e soggette a modifiche.

Panoramica​

Con l'Iskay Quantum Optimizer di Kipu Quantum puoi affrontare problemi di ottimizzazione complessi usando i computer quantistici IBM®. Questo solver sfrutta il all'avanguardia algoritmo bf-DCQO di Kipu, richiedendo solo la funzione obiettivo come input per fornire automaticamente le soluzioni al problema. È in grado di gestire problemi di ottimizzazione con fino a 156 qubit, consentendo l'utilizzo di tutti i qubit dei dispositivi quantistici IBM. L'Optimizer usa una mappatura 1-a-1 tra variabili classiche e qubit, il che ti permette di affrontare problemi di ottimizzazione con fino a 156 variabili binarie.

L'Optimizer consente di risolvere problemi di ottimizzazione binaria non vincolata. Oltre alla formulazione QUBO (Quadratic Unconstrained Binary Optimization) comunemente usata, supporta anche problemi di ottimizzazione di ordine superiore (HUBO). Il solver utilizza un algoritmo quantistico non variazionale, eseguendo la maggior parte del calcolo su dispositivi quantistici.

Di seguito sono forniti maggiori dettagli sull'algoritmo utilizzato, una breve guida su come usare la funzione e risultati di benchmarking su varie istanze di problemi di dimensioni e complessità diverse.

Descrizione​

L'Optimizer è un'implementazione pronta all'uso di algoritmi di ottimizzazione quantistica all'avanguardia. Risolve i problemi di ottimizzazione eseguendo circuiti quantistici altamente compressi su hardware quantistico. Questa compressione si ottiene introducendo termini controadiabatici nell'evoluzione temporale sottostante del sistema quantistico. L'algoritmo esegue diverse iterazioni di esecuzioni hardware per ottenere le soluzioni finali e le combina con un post-processing. Questi passaggi sono integrati senza soluzione di continuità nel flusso di lavoro dell'Optimizer e vengono eseguiti automaticamente.

Come funziona il Quantum Optimizer?​

Questa sezione illustra le basi dell'algoritmo bf-DCQO implementato. Un'introduzione all'algoritmo è disponibile anche sul canale YouTube di Qiskit.

L'algoritmo si basa sull'evoluzione temporale di un sistema quantistico che si trasforma nel tempo, dove la soluzione del problema è codificata nello stato fondamentale del sistema quantistico al termine dell'evoluzione. Secondo il teorema adiabatico, questa evoluzione deve essere lenta per garantire che il sistema rimanga nel suo stato fondamentale. Digitalizzare questa evoluzione è la base del calcolo adiabatico digitale quantistico (DQA) e del noto algoritmo QAOA. Tuttavia, la necessaria evoluzione lenta non è praticabile per problemi di dimensioni crescenti, poiché comporta un aumento della profondità del circuito. Usando protocolli controadiabatici, puoi sopprimere le eccitazioni indesiderate che si verificano durante brevi tempi di evoluzione, mantenendosi comunque nello stato fondamentale. Qui, digitalizzare questo tempo di evoluzione più breve produce circuiti quantistici con profondità minore e meno gate di entanglement.

I circuiti degli algoritmi bf-DCQO utilizzano tipicamente fino a dieci volte meno gate di entanglement rispetto al DQA, e da tre a quattro volte meno gate di entanglement rispetto alle implementazioni standard di QAOA. Grazie al minor numero di gate, si verificano meno errori durante l'esecuzione del circuito sull'hardware. Di conseguenza, l'optimizer non richiede l'uso di tecniche come la soppressione degli errori o la mitigazione degli errori. Implementarle in versioni future potrà migliorare ulteriormente la qualità delle soluzioni.

Sebbene l'algoritmo bf-DCQO usi iterazioni, è non variazionale. Dopo ogni iterazione dell'algoritmo, viene misurata la distribuzione degli stati. La distribuzione ottenuta viene usata per calcolare un cosiddetto bias-field. Il bias-field consente di avviare l'iterazione successiva da uno stato energetico vicino alla soluzione trovata in precedenza. In questo modo, l'algoritmo si sposta a ogni iterazione verso soluzioni a energia inferiore. Tipicamente, sono sufficienti circa dieci iterazioni per convergere a una soluzione, richiedendo in totale un numero molto inferiore di iterazioni rispetto agli algoritmi variazionali, che è dell'ordine di circa 100 iterazioni.

L'optimizer combina l'algoritmo bf-DCQO con un post-processing classico. Dopo aver misurato la distribuzione degli stati, viene eseguita una ricerca locale. Durante la ricerca locale, i bit della soluzione misurata vengono invertiti casualmente. Dopo l'inversione, viene valutata l'energia della nuova stringa di bit. Se l'energia è inferiore, la stringa di bit viene mantenuta come nuova soluzione. La ricerca locale scala solo linearmente con il numero di qubit; è quindi computazionalmente poco costosa. Poiché il post-processing corregge le inversioni di bit locali, compensa gli errori di bit-flip che spesso sono il risultato di imperfezioni hardware e errori di lettura.

Flusso di lavoro​

Di seguito è riportato uno schema del flusso di lavoro del Quantum Optimizer.

Flusso di lavoro

Usando il Quantum Optimizer, la risoluzione di un problema di ottimizzazione su hardware quantistico può essere ridotta a:

  • Formulare la funzione obiettivo del problema
  • Accedere all'Optimizer tramite Qiskit Functions
  • Eseguire l'Optimizer e raccogliere il risultato

Benchmark​

Le metriche di benchmark riportate di seguito mostrano che l'Optimizer affronta efficacemente problemi che coinvolgono fino a 156 qubit e offrono una panoramica generale dell'accuratezza e della scalabilità dell'optimizer su diversi tipi di problemi. Nota che le metriche di prestazione effettive possono variare in base alle caratteristiche specifiche del problema, come il numero di variabili, la densità e la località dei termini nella funzione obiettivo e l'ordine polinomiale.

La tabella seguente include il rapporto di approssimazione (AR), una metrica definita come segue:

AR=C∗−CmaxCmin−Cmax,AR = \frac{C^{*} - C_\textrm{max}}{C_{\textrm{min}} - C_{\textrm{max}}},

dove CC è la funzione obiettivo, CminC_{\textrm{min}}, CmaxC_{\textrm{max}} sono rispettivamente i suoi valori minimo e massimo, e C∗C^{*} è il costo della migliore soluzione trovata. Pertanto, AR=100% significa che è stato ottenuto lo stato fondamentale del problema.

EsempioNumero di qubitRapporto di approssimazioneTempo totale (s)Utilizzo runtime (s)Numero totale di shotsNumero di iterazioni
Unweighted MaxCut28100%1803030k5
Unweighted MaxCut30100%1803030k5
Unweighted MaxCut32100%1803030k5
Unweighted MaxCut80100%4806090k9
Unweighted MaxCut100100%3306060k6
Unweighted MaxCut120100%3706060k6
HUBO 1156100%60070100k10
HUBO 2156100%60070100k10
  • Le istanze MaxCut con 28, 30 e 32 qubit sono state eseguite su ibm_sherbrooke. Le istanze con 80, 100 e 120 qubit sono state eseguite su un processore Heron r2.
  • Anche le istanze HUBO sono state eseguite su un processore Heron r2.

Tutte le istanze di benchmark sono accessibili su GitHub (vedi istanze di benchmark Kipu). Un esempio per eseguire queste istanze si trova in Esempio 3: Istanze di benchmark.

Input e output​

Input​

Vedi la tabella seguente per tutti i parametri di input accettati dal Quantum Optimizer. La sezione Opzioni successiva fornisce maggiori dettagli sulle options disponibili.

NomeTipoDescrizioneObbligatorioPredefinitoEsempio
problemDict[str, float]I coefficienti del problema di ottimizzazione formulato in formato QUBO/HUBO o spin. Per maggiori informazioni sulla specifica del problema, vedi Formati di problema accettatiSìN/A{"()": -21.0, "(0, 4)": 0.5,"(0, 2)": 0.5,"(0, 1)": 0.5,"(1, 3)": 0.5}
problem_typestrSpecifica se i coefficienti del problema sono in formato binario (QUBO/HUBO) o spin. Le due possibilità sono "spin" o "binary"SìN/A"spin"
backend_namestrNome del backend su cui effettuare la querySìN/A"ibm_fez"
optionsDict[str, Any]Opzioni per gestire la sottomissione all'hardware, come il numero di shots. Per ulteriori dettagli sulla configurazione delle opzioni, vedi la sezione OpzioniNoPer vedere i valori predefiniti della configurazione delle opzioni, vedi la sezione Opzioni{"shots": 5000, "num_iterations": 3, "use_session": True, "seed_transpiler": 42}

Formati di problema accettati​

Gli argomenti problem e problem_type codificano un problema di ottimizzazione della forma

min⁡(x1,x2,…,xn)∈DC(x1,x2,…,xn)\begin{align} \min_{(x_1, x_2, \ldots, x_n) \in D} C(x_1, x_2, \ldots, x_n) \nonumber \end{align}

dove

C(x1,...,xn)=a+∑ibixi+∑i,jci,jxixj+...+∑k1,...,kmgk1,...,kmxk1...xkmC(x_1, ... , x_n) = a + \sum_{i} b_i x_i + \sum_{i, j} c_{i, j} x_i x_j + ... + \sum_{k_1, ..., k_m} g_{k_1, ..., k_m} x_{k_1} ... x_{k_m}
  • Scegliendo problem_type = "binary", specifichi che la funzione di costo è in formato binary, il che significa che D={0,1}nD = \{0, 1\}^{n}, ossia la funzione di costo è scritta in formulazione QUBO/HUBO.
  • D'altra parte, scegliendo problem_type = "spin", la funzione di costo è scritta in formulazione di Ising, dove D={−1,1}nD = \{-1, 1\}^{n}.

I coefficienti del problema devono essere codificati in un dizionario come segue:

{"()":a,"(i,)":bi,"(i, j)":ci,j,⋮"(k1,...,km)":gk1,...,km,}\begin{align} \nonumber &\texttt{\{} \\ \nonumber &\texttt{"()"}&: \quad &a, \\ \nonumber &\texttt{"(i,)"}&: \quad &b_i, \\ \nonumber &\texttt{"(i, j)"}&: \quad &c_{i, j}, \\ \nonumber &\quad \vdots \\ \nonumber &\texttt{"(} k_1, ..., k_m \texttt{)"} &: \quad &g_{k_1, ..., k_m}, \\ \nonumber &\texttt{\}} \end{align}
  • Nota che le chiavi del dizionario devono essere stringhe contenenti una tupla valida di interi non ripetuti.

Opzioni​

Iskay offre capacità di messa a punto tramite parametri opzionali. Sebbene i valori predefiniti funzionino bene per la maggior parte dei problemi, puoi personalizzare il comportamento per requisiti specifici:

ParametroTipoPredefinitoDescrizione
shotsint10000Misurazioni quantistiche per iterazione (più alto = più accurato)
num_iterationsint10Iterazioni dell'algoritmo (più iterazioni possono migliorare la qualità della soluzione)
use_sessionboolTrueUsa le sessioni IBM per tempi di coda ridotti
seed_transpilerintNoneImpostalo per una compilazione riproducibile del circuito quantistico
direct_qubit_mappingboolFalseMappa i qubit virtuali direttamente sui qubit fisici
job_tagsList[str]NoneTag personalizzati per il tracciamento dei job
preprocessing_levelint0Intensità del pre-processing del problema (0-3) - vedi dettagli di seguito
postprocessing_levelint2Livello di raffinamento della soluzione (0-2) - vedi dettagli di seguito
transpilation_levelint0Tentativi di ottimizzazione del Transpiler (0-5) - vedi dettagli di seguito
transpile_onlyboolFalseAnalizza l'ottimizzazione del circuito senza eseguire l'intera esecuzione

Livelli di pre-processing (0-3): Particolarmente importanti per i problemi più grandi che attualmente non rientrano nei tempi di coerenza dell'hardware. Livelli di pre-processing più alti ottengono profondità di circuito minori tramite approssimazioni nella transpilazione del problema:

  • Livello 0: Esatto, circuiti più lunghi
  • Livello 1: Buon bilanciamento tra accuratezza e approssimazione, eliminando solo i gate con angoli nel 10° percentile più basso
  • Livello 2: Approssimazione leggermente maggiore, eliminando i gate con angoli nel 20° percentile più basso e usando approximation_degree=0.95 nella transpilazione
  • Livello 3: Massimo livello di approssimazione, eliminando i gate nel 30° percentile più basso e usando approximation_degree=0.90 nella transpilazione

Livelli di transpilazione (0-5): Controllano i tentativi di ottimizzazione avanzati del Transpiler per la compilazione dei circuiti quantistici. Questo può comportare un aumento dell'overhead classico e, in alcuni casi, potrebbe non modificare la profondità del circuito. Il valore predefinito 2 in generale porta al circuito più piccolo ed è relativamente veloce.

  • Livello 0: Ottimizzazione del circuito DCQO decomposto (layout, routing, scheduling)
  • Livello 1: Ottimizzazione di PauliEvolutionGate e poi del circuito DCQO decomposto (max_trials=10)
  • Livello 2: Ottimizzazione di PauliEvolutionGate e poi del circuito DCQO decomposto (max_trials=15)
  • Livello 3: Ottimizzazione di PauliEvolutionGate e poi del circuito DCQO decomposto (max_trials=20)
  • Livello 4: Ottimizzazione di PauliEvolutionGate e poi del circuito DCQO decomposto (max_trials=25)
  • Livello 5: Ottimizzazione di PauliEvolutionGate e poi del circuito DCQO decomposto (max_trials=50)

Livelli di post-processing (0-2): Controllano la quantità di ottimizzazione classica, compensando gli errori di bit-flip con un numero diverso di passate greedy di ricerca locale:

  • Livello 0: 1 passata
  • Livello 1: 2 passate
  • Livello 2: 3 passate

Modalità solo transpilazione: Ora disponibile per gli utenti che desiderano analizzare l'ottimizzazione del circuito senza eseguire l'intera esecuzione dell'algoritmo quantistico.

Esempio di configurazione personalizzata: Ecco come potresti configurare Iskay con impostazioni diverse:

# Added by doQumentation — required packages for this notebook
!pip install -q PyGithub networkx qiskit-ibm-catalog
custom_options = {
    "shots": 15_000,  # Higher shot count for better statistics
    "num_iterations": 12,  # More iterations for solution refinement
    "preprocessing_level": 1,  # Light preprocessing for problem simplification
    "postprocessing_level": 2,  # Maximum postprocessing for solution quality
    "transpilation_level": 3,  # Using higher transpilation level for circuit optimization
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

Ottimizzazione del seed: Nota che seed_transpiler è impostato su None per impostazione predefinita. Questo abilita il processo di ottimizzazione automatica del Transpiler. Quando è None, il sistema avvierà un tentativo con più seed e selezionerà quello che produce la migliore profondità del circuito, sfruttando appieno il parametro max_trials per ogni livello di transpilazione.

Prestazioni del livello di transpilazione: Aumentare il numero di max_trials con valori più alti per transpilation_level aumenterà inevitabilmente il tempo di transpilazione, ma potrebbe non modificare sempre il circuito finale — questo dipende molto dalla struttura e dalla complessità specifiche del circuito. Per alcuni circuiti/problemi, tuttavia, la differenza tra 10 tentativi (livello 1) e 50 tentativi (livello 5) può essere notevole, quindi esplorare questi parametri potrebbe essere la chiave per trovare con successo una soluzione.

Output​

NomeTipoDescrizioneEsempio
resultDict[str, Any]Soluzione e metadati. La struttura varia in base all'opzione transpile_only.Vedi "Contenuto del dizionario dei risultati" di seguito

Contenuto del dizionario dei risultati​

La struttura del dizionario dei risultati dipende dalla modalità di esecuzione:

CampoTipoModalitàDescrizioneEsempio
solutionDict[str, int]StandardLa soluzione mappata e ordinata, dove le chiavi sono gli indici delle variabili (come stringhe) ordinate numericamente e i valori sono i corrispondenti valori delle variabili (1/-1 per problemi spin, 1/0 per problemi binari).{'0': -1, '1': -1, '2': -1, '3': 1, '4': 1}
solution_infoDict[str, Any]StandardInformazioni dettagliate sulla soluzione (vedi dettagli di seguito){'bitstring': '11100', 'cost': -13.8, 'seed_transpiler': 42, 'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}
prob_typestrStandardIl tipo di problema di ottimizzazione ('spin' o 'binary')'spin'
transpilation_infoDict[str, Any]Solo transpilazioneAnalisi del circuito e dettagli di transpilazione (vedi dettagli di seguito){'best_seed': 42, 'transpilation_time_seconds': 50.06, 'transpiled_circuit': {'depth': 576, 'gate_count': 4177, 'num_qubits': 156, 'width': 176, 'operations': {'sx': 1325, 'rx': 891, 'cz': 783, 'rz': 650, 'rzz': 466, 'x': 42, 'measure': 20}}}

Esecuzione standard​

Quando il parametro opzionale è transpile_only=False:

Dizionario solution_info:

  • "bitstring" (str): La rappresentazione in stringa di bit grezza della soluzione.
  • "cost" (float): Il valore di costo/energia associato alla soluzione.
  • "seed_transpiler" (int): Il seed casuale usato per il Transpiler che ha prodotto questo risultato.
  • "mapping" (Dict[int, int]): La mappatura originale qubit-variabile usata nel calcolo.
  • "qpu_time" (float, opzionale): Il tempo di esecuzione QPU in secondi.

Note sulla mappatura delle variabili:

  • Il dizionario solution è ottenuto dalla stringa di bit della soluzione, usando l'oggetto mapping per indicizzare le variabili.
  • Quando problem_type=spin si usa l'assegnazione 1→−1,0→11 \rightarrow -1, \quad 0 \rightarrow 1.
  • Le chiavi nel dizionario della soluzione sono indici di variabili ordinati numericamente come stringhe.

Analisi della transpilazione​

Quando il parametro opzionale è transpile_only=True:

Dizionario transpilation_info:

  • "best_seed" (int): Il seed ottimale trovato per la transpilazione
  • "transpilation_time_seconds" (float): Tempo impiegato per il processo di transpilazione
  • "transpiled_circuit" (Dict): Analisi del circuito contenente:
    • "depth" (int): Profondità del circuito (numero di livelli)
    • "gate_count" (int): Numero totale di gate nel circuito
    • "num_qubits" (int): Numero di qubit utilizzati
    • "width" (int): Larghezza del circuito
    • "operations" (Dict[str, int]): Conteggio di ogni tipo di gate utilizzato

Utilizzo della modalità solo transpilazione:

  • Disponibile per gli utenti che desiderano analizzare l'ottimizzazione del circuito senza eseguire l'intera esecuzione dell'algoritmo quantistico.
  • Utile per l'analisi dei circuiti, studi di ottimizzazione della profondità e comprensione degli effetti della transpilazione prima di procedere con l'esecuzione completa.

Per iniziare​

In questa documentazione, seguiremo i passaggi per utilizzare l'Iskay Quantum Optimizer. Nel processo, mostreremo rapidamente come caricare la funzione dal catalogo e come convertire il tuo problema in un input valido, mostrando al contempo come puoi sperimentare con diversi parametri opzionali.

Per un esempio più dettagliato, consulta il tutorial Risolvi il problema del Market Split con l'Iskay Quantum Optimizer di Kipu Quantum, dove lavoriamo attraverso l'intero processo di utilizzo dell'Iskay Solver per affrontare il problema del Market Split, che rappresenta una sfida reale di allocazione delle risorse in cui i mercati devono essere suddivisi in regioni di vendita bilanciate per soddisfare obiettivi di domanda esatti.

Autentica usando la tua chiave API, disponibile sulla dashboard di IBM Quantum Platform, e seleziona la Qiskit Function come segue:

# ruff: noqa: F821
nota

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    token="YOUR_API_KEY",  # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
)

# Access Function
optimizer = catalog.load("kipu-quantum/iskay-quantum-optimizer")

Esempio 1: Funzione di costo semplice​

Considera la funzione di costo in formulazione spin:

C(x0,x1,x2,x3,x4)=1+1.5x0+2x1+1.3x2+2.5x0x3+3.5x1x4+4x0x1x2C(x_0, x_1, x_2, x_3, x_4) = 1 + 1.5x_0 + 2x_1 + 1.3x_2 + 2.5x_0x_3 + 3.5x_1x_4 + 4x_0x_1x_2

dove (x0,...,x4)∈{−1,1}5(x_0, ..., x_4) \in \{-1, 1\}^5.

La soluzione di questa semplice funzione di costo è

(x0,x1,x2,x3,x4)=(−1,−1,−1,1,1)(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)

con valore minimo C∗=−6C^{*} = -6

1. Crea la funzione obiettivo​

Iniziamo creando un dizionario con i coefficienti della funzione obiettivo come segue:

objective_func = {
    "()": 1,
    "(0,)": 1.5,
    "(1,)": 2,
    "(2,)": 1.3,
    "(0, 3)": 2.5,
    "(1, 4)": 3.5,
    "(0, 1, 2)": 4,
}

2. Esegui l'Optimizer​

Risolviamo il problema eseguendo l'optimizer. Poiché (x0,...,x4)∈{−1,1}5(x_0, ..., x_4) \in \{-1, 1\}^5, dobbiamo impostare problem_type=spin.

# Setup options to run the optimizer
options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Recupera il risultato​

La soluzione del problema di ottimizzazione viene fornita direttamente dall'optimizer.

print(job.result())

Questo mostrerà un dizionario della forma:

{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},
 'solution_info': {'bitstring': '11100',
  'cost': -13.8,
  'seed_transpiler': 42,
  'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},
 'prob_type': 'spin'}

Nota che il dizionario solution mostra il vettore risultato (x0,x1,x2,x3,x4)=(−1,−1,−1,1,1)(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1).

Esempio 2: MaxCut​

Molti problemi su grafi come MaxCut o Maximum Independent Set sono problemi NP-hard e candidati ideali per testare algoritmi quantistici e hardware. Questo esempio dimostra la risoluzione del problema MaxCut su un grafo 3-regolare con il Quantum Optimizer.

Per eseguire questo esempio devi installare il pacchetto networkx in aggiunta a qiskit-ibm-catalog. Per installarlo, esegui il seguente comando:

# %pip install networkx numpy

1. Crea la funzione obiettivo​

Inizia generando un grafo 3-regolare casuale. Per questo grafo, definiamo la funzione obiettivo del problema MaxCut.

import networkx as nx

# Create a random 3-regular graph
G = nx.random_regular_graph(3, 10, seed=42)

# Create the objective function for MaxCut in Ising formulation
def graph_to_ising_maxcut(G):
    """
    Convert a NetworkX graph to an Ising Hamiltonian for the Max-Cut problem.
    Args:
        G (networkx.Graph): The input graph.
    Returns:
        dict: The objective function of the Ising model
    """
    # Initialize the linear and quadratic coefficients
    objective_func = {}
    # Populate the coefficients
    for i, j in G.edges:
        objective_func[f"({i}, {j})"] = 0.5
    return objective_func

objective_func = graph_to_ising_maxcut(G)

2. Esegui l'Optimizer​

Risolvi il problema eseguendo l'optimizer.

options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Recupera il risultato​

Recupera il risultato e mappa la stringa di bit della soluzione sui nodi del grafo originale.

print(job.result())

La soluzione al problema MaxCut è direttamente contenuta nel sotto-dizionario solution dell'oggetto risultato

maxcut_solution = job.result()["solution"]

Esempio 3: Istanze di benchmark​

Le istanze di benchmark sono disponibili su GitHub: istanze di benchmark Kipu.

Le istanze possono essere caricate usando la libreria pygithub. Per installarla, esegui il seguente comando:

# %pip install pygithub

I percorsi per le istanze di benchmark sono:

Maxcut:

  • 'maxcut/maxcut_28_nodes.json'
  • 'maxcut/maxcut_30_nodes.json'
  • 'maxcut/maxcut_32_nodes.json'
  • 'maxcut/maxcut_80_nodes.json'
  • 'maxcut/maxcut_100_nodes.json'
  • 'maxcut/maxcut_120_nodes.json'

HUBO:

  • 'HUBO/hubo1_marrakesh.json'
  • 'HUBO/hubo2_marrakesh.json'

Per riprodurre le prestazioni del benchmark per le istanze HUBO, seleziona il backend ibm_marrakesh e imposta direct_qubit_mapping su True nel sotto-dizionario options. L'esempio seguente esegue l'istanza Maxcut con 32 nodi.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_32_nodes.json"
gh = Github()
repo = gh.get_repo(repo)
branch = "main"
file = repo.get_contents(urllib.parse.quote(path), ref=branch)

# load json file with benchmark problem
problem_json = json.loads(file.decoded_content)

# convert objective function to compatible format
objective_func = {
    key: ast.literal_eval(value) for key, value in problem_json.items()
}

# Setup configuration to run the optimizer
options = {
    "shots": 5_000,
    "num_iterations": 5,
    "use_session": True,
    "direct_qubit_mapping": False,
}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": "ibm_brisbane",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

Casi d'uso​

I casi d'uso tipici per il solver di ottimizzazione sono i problemi di ottimizzazione combinatoria. Puoi risolvere problemi di molti settori come la finanza, la farmaceutica o la logistica. Seguono alcuni esempi.

Se sei interessato ad affrontare un caso d'uso specifico e sviluppare una mappatura dedicata, possiamo assisterti. Contattaci.

Supporto​

Per supporto, contatta support@kipu-quantum.com.

Passi successivi​

Informazioni aggiuntive​

Iskay, come il nome della nostra azienda Kipu Quantum, è una parola peruviana. Sebbene siamo una startup tedesca, queste parole provengono dal paese natale di uno dei nostri co-fondatori, dove il Quipu era una delle primissime macchine di calcolo sviluppate dall'umanità 2000 anni a.C.