{
"cells": [
{
"cell_type": "markdown",
"id": "e0cf0747",
"metadata": {},
"source": [
"---\n",
"title: \"Algoritmi quantistici variazionali\"\n",
"description: \"Questo tutorial offre una panoramica di un algoritmo ibrido quantistico-classico, VQE, e del QAOA\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Algoritmi quantistici: algoritmi quantistici variazionali\n",
"\n",
"\n",
" Takashi Imamichi (24 maggio 2024)\n",
"\n",
" [Scarica il pdf](https://ibm.ent.box.com/s/blnffu0pd7yzxarq3zc3w0jv90365ny2) della lezione originale. Si noti che alcuni frammenti di codice potrebbero diventare deprecati, poiché si tratta di immagini statiche.\n",
"\n",
" *Il tempo approssimativo di esecuzione di questo esperimento è di 9 minuti (testato su un processore Eagle).*\n",
"\n",
" (questo quaderno potrebbe non essere valutato nel tempo previsto dall'Open Plan. Si prega di utilizzare saggiamente le risorse di calcolo quantistico)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "59fbaadc",
"metadata": {},
"source": [
"\n",
"\n",
"## 1. Introduzione\n",
"\n",
"Questo tutorial fornisce una panoramica di un algoritmo ibrido quantistico-classico, concentrandosi in particolare sul variational quantum eigensolver (VQE) e sull'algoritmo di ottimizzazione approssimativa quantistica (QAOA). L'obiettivo primario di questi algoritmi è quello di affrontare problemi di ottimizzazione utilizzando circuiti quantistici con porte quantistiche parametrizzate.\n",
"\n",
"Nonostante i progressi dell'informatica quantistica, la presenza di rumore negli attuali dispositivi quantistici rende difficile estrarre risultati significativi dai circuiti quantistici profondi. Per superare questa sfida, VQE e QAOA adottano un approccio ibrido quantistico-classico, che prevede l'esecuzione iterativa di circuiti quantistici relativamente brevi utilizzando la computazione quantistica e l'ottimizzazione dei parametri dei circuiti quantistici parametrizzati di destinazione utilizzando la computazione classica.\n",
"\n",
"Il QAOA ha il potenziale per fornire soluzioni ottimali ai problemi target su scala utility, grazie all'applicazione di varie tecniche di mitigazione e soppressione degli errori. Il VQE ha molte applicazioni (come la chimica quantistica) in cui è meno scalabile. Tuttavia, sono emersi diversi approcci legati agli autovalori per completare e aumentare la VQE, tra cui la diagonalizzazione del sottospazio di Krylov e la diagonalizzazione quantistica basata sul campionamento (SQD). La comprensione del VQE è un primo passo importante per capire l'ampia gamma di algoritmi ibridi classico-quantistici che sono emersi.\n",
"\n",
"Questo modulo descrive i concetti fondamentali e l'implementazione di VQE e QAOA. Ulteriori esercitazioni esploreranno argomenti e tecniche avanzate per scalare questi algoritmi.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d3f4500f",
"metadata": {},
"source": [
"Per eseguire questo notebook è necessario disporre della seguente libreria nel proprio ambiente.\n",
"Se non l'avete ancora installato, potete farlo togliendo il commento ed eseguendo la seguente cella.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2a8e650f",
"metadata": {},
"outputs": [],
"source": [
"# % pip install 'qiskit[visualization]' qiskit-ibm-runtime"
]
},
{
"cell_type": "markdown",
"id": "be601762",
"metadata": {},
"source": [
"\n",
"\n",
"## 2. Calcolo dell'autovalore minimo di un hamiltoniano semplice\n",
"\n",
"Inizieremo applicando la VQE a un caso molto semplice, per vedere come funziona. Calcoleremo l'autovalore minimo della matrice di Pauli $Z$ con VQE. Inizieremo importando alcuni pacchetti generali.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "e8f398b2",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"from qiskit.circuit import ParameterVector, QuantumCircuit\n",
"from qiskit.primitives import StatevectorEstimator, StatevectorSampler\n",
"from qiskit.quantum_info import SparsePauliOp\n",
"from scipy.optimize import minimize"
]
},
{
"cell_type": "markdown",
"id": "d4395012",
"metadata": {},
"source": [
"Definiamo ora l'operatore di interesse e lo vediamo in forma matriciale.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "a4f374a2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1.+0.j, 0.+0.j],\n",
" [ 0.+0.j, -1.+0.j]])"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"op = SparsePauliOp(\"Z\")\n",
"op.to_matrix()"
]
},
{
"cell_type": "markdown",
"id": "0a001e71",
"metadata": {},
"source": [
"È facile ottenere gli autovalori in modo classico, quindi possiamo verificare il nostro lavoro. Questo potrebbe diventare difficile man mano che si procede verso l'utilità. Qui utilizziamo numpy.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "c9188662",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Eigenvalues: [-1. 1.]\n"
]
}
],
"source": [
"# compute eigenvalues with numpy\n",
"result = np.linalg.eigh(op.to_matrix())\n",
"print(\"Eigenvalues:\", result.eigenvalues)"
]
},
{
"cell_type": "markdown",
"id": "8f9af345",
"metadata": {},
"source": [
"Per ottenere gli autovalori utilizzando un algoritmo quantistico variazionale, costruiamo un circuito con porte che accettano parametri variazionali:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "99d5d36b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# define a variational form\n",
"param = ParameterVector(\"a\", 3)\n",
"qc = QuantumCircuit(1, 1)\n",
"qc.u(param[0], param[1], param[2], 0)\n",
"qc_estimator = qc.copy()\n",
"qc.measure(0, 0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "9607ab51",
"metadata": {},
"source": [
"Se vogliamo stimare il valore di aspettativa di un operatore (come $Z$ ), dobbiamo usare Estimator. Se vogliamo esaminare gli stati del sistema, usiamo Sampler.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "df8ed8d3",
"metadata": {},
"outputs": [],
"source": [
"sampler = StatevectorSampler()\n",
"estimator = StatevectorEstimator()"
]
},
{
"cell_type": "markdown",
"id": "880bccfb",
"metadata": {},
"source": [
"Possiamo calcolare i conteggi delle bitstring 0 e 1 con i valori dei parametri casuali `[1, 2, 3]` utilizzando Sampler.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "5301ee71",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'0': 783, '1': 241}"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# compute counts of bitstrings with random parameter values by Sampler\n",
"result = sampler.run([(qc, [1, 2, 3])]).result()\n",
"counts = result[0].data.c.get_counts()\n",
"counts"
]
},
{
"cell_type": "markdown",
"id": "30ef9b8f",
"metadata": {},
"source": [
"Sappiamo che possiamo calcolare il valore di aspettativa di Z da $\\langle Z \\rangle = p_0 - p_1$ con le probabilità $\\{0: p_0, 1: p_1\\}$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "0f220c8d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.529296875"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# compute the expectation value of Z based on the counts\n",
"(counts.get(\"0\", 0) - counts.get(\"1\", 0)) / sum(counts.values())"
]
},
{
"cell_type": "markdown",
"id": "695ee4bd",
"metadata": {},
"source": [
"Questo circuito funzionava, ma i valori dei parametri scelti non corrispondevano a uno stato a bassissima energia (o a bassi autovalori). L'autovalore ottenuto è di gran lunga superiore al minimo. Il risultato è simile quando si utilizza lo stimatore.\n",
"\n",
"Si noti che Estimator prende i circuiti quantistici senza misurazioni.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c9e05530",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array(0.54030231)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"result = estimator.run([(qc_estimator, op, [1, 2, 3])]).result()\n",
"result[0].data.evs"
]
},
{
"cell_type": "markdown",
"id": "b538e8b5",
"metadata": {},
"source": [
"Dovremo cercare tra i parametri e trovare quelli che producono l'autovalore più basso.\n",
"Creiamo una funzione che riceve i valori dei parametri della forma variazionale e restituisce il valore dell'aspettativa $\\langle Z \\rangle$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "97fead46",
"metadata": {},
"outputs": [],
"source": [
"# define a cost function to look for the minimum eigenvalue of Z\n",
"def cost(x):\n",
" result = sampler.run([(qc, x)]).result()\n",
" counts = result[0].data.c.get_counts()\n",
" expval = (counts.get(\"0\", 0) - counts.get(\"1\", 0)) / sum(counts.values())\n",
" # the following line shows the trajectory of the optimization\n",
" print(expval, counts)\n",
" return expval"
]
},
{
"cell_type": "markdown",
"id": "a97eaeba",
"metadata": {},
"source": [
"Applichiamo la funzione SciPy's `minimize` per trovare l'autovalore minimo di Z.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "44f56300",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0 {'0': 1024}\n",
"0.494140625 {'0': 765, '1': 259}\n",
"0.466796875 {'0': 751, '1': 273}\n",
"0.564453125 {'0': 801, '1': 223}\n",
"-0.4296875 {'1': 732, '0': 292}\n",
"-0.984375 {'1': 1016, '0': 8}\n",
"-0.8984375 {'1': 972, '0': 52}\n",
"-0.990234375 {'1': 1019, '0': 5}\n",
"-0.892578125 {'1': 969, '0': 55}\n",
"-0.986328125 {'1': 1017, '0': 7}\n",
"-0.861328125 {'1': 953, '0': 71}\n",
"-1.0 {'1': 1024}\n",
"-0.982421875 {'1': 1015, '0': 9}\n",
"-0.99609375 {'1': 1022, '0': 2}\n",
"-0.986328125 {'1': 1017, '0': 7}\n",
"-1.0 {'1': 1024}\n",
"-0.990234375 {'1': 1019, '0': 5}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.99609375 {'1': 1022, '0': 2}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-1.0 {'1': 1024}\n",
"-0.99609375 {'1': 1022, '0': 2}\n",
"-1.0 {'1': 1024}\n",
"-0.99609375 {'1': 1022, '0': 2}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.99609375 {'1': 1022, '0': 2}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.99609375 {'1': 1022, '0': 2}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-0.998046875 {'1': 1023, '0': 1}\n",
"-0.994140625 {'1': 1021, '0': 3}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n",
"-1.0 {'1': 1024}\n"
]
},
{
"data": {
"text/plain": [
" message: Optimization terminated successfully.\n",
" success: True\n",
" status: 1\n",
" fun: -1.0\n",
" x: [ 3.182e+00 1.338e+00 1.664e-01]\n",
" nfev: 63\n",
" maxcv: 0.0"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# minimize the cost function with scipy's minimize\n",
"min_result = minimize(cost, [0, 0, 0], method=\"COBYLA\", tol=1e-8)\n",
"min_result"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "4198224e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'0': 1, '1': 1023}"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# check counts of bitstrings with the optimal parameters\n",
"result = sampler.run([(qc, min_result.x)]).result()\n",
"result[0].data.c.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "d4e77e29",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.1 Esercizio fisico\n",
"\n",
"Calcolare l'autovalore minimo di $Z \\otimes Z$ con VQE.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "86a2d76d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"SparsePauliOp(['ZZ'],\n",
" coeffs=[1.+0.j])\n",
"[[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
" [ 0.+0.j -1.+0.j 0.+0.j 0.+0.j]\n",
" [ 0.+0.j 0.+0.j -1.+0.j 0.+0.j]\n",
" [ 0.+0.j 0.+0.j 0.+0.j 1.+0.j]]\n"
]
}
],
"source": [
"z2 = SparsePauliOp(\"ZZ\")\n",
"print(z2)\n",
"print(z2.to_matrix())"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "76092648-3b28-442e-8319-8a8416e0c9d5",
"metadata": {},
"outputs": [],
"source": [
"# compute eigenvalues with numpy"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "f92a23b5",
"metadata": {},
"outputs": [],
"source": [
"# define a variational form\n",
"# qc = ..."
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "496572fb",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"# compute counts of bitstrings with a random parameter values by Sampler\n",
"# result = sampler.run(...)\n",
"# result"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "b4cad5d0",
"metadata": {},
"outputs": [],
"source": [
"# compute the expectation value of ZZ based on the counts"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "5ce555fe",
"metadata": {},
"outputs": [],
"source": [
"# verify the expectation value of ZZ with Estimator"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "c210c435",
"metadata": {},
"outputs": [],
"source": [
"# define a cost function to look for the minimum eigenvalue of ZZ\n",
"# def cost(x):\n",
"# expval = ...\n",
"# return expval"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "a75f3303",
"metadata": {},
"outputs": [],
"source": [
"# minimize the cost function with scipy's minimize\n",
"# min_result = minimize(cost, [...], method=\"COBYLA\", tol=1e-8)\n",
"# min_result"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "8c476943",
"metadata": {},
"outputs": [],
"source": [
"# check counts of bitstrings with the optimal parameter values\n",
"# result = sampler.run(qc, min_result.x).result()\n",
"# result"
]
},
{
"cell_type": "markdown",
"id": "b82ba33a",
"metadata": {},
"source": [
"\n",
"\n",
"#### Soluzioni dell'esercizio\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7f2e0a4e",
"metadata": {},
"source": [
"Definiamo l'operatore di interesse e lo visualizziamo in forma matriciale.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "a1f9d371",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"SparsePauliOp(['ZZ'],\n",
" coeffs=[1.+0.j])\n",
"[[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n",
" [ 0.+0.j -1.+0.j 0.+0.j 0.+0.j]\n",
" [ 0.+0.j 0.+0.j -1.+0.j 0.+0.j]\n",
" [ 0.+0.j 0.+0.j 0.+0.j 1.+0.j]]\n"
]
}
],
"source": [
"z2 = SparsePauliOp(\"ZZ\")\n",
"print(z2)\n",
"print(z2.to_matrix())"
]
},
{
"cell_type": "markdown",
"id": "b123e9d9",
"metadata": {},
"source": [
"Per ottenere gli autovalori utilizzando un algoritmo quantistico variazionale, costruiamo un circuito con porte che accettano parametri variazionali:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "7d5e894a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# define a variational form\n",
"param = ParameterVector(\"a\", 6)\n",
"qc = QuantumCircuit(2, 2)\n",
"qc.u(param[0], param[1], param[2], 0)\n",
"qc.u(param[3], param[4], param[5], 1)\n",
"qc_estimator = qc.copy()\n",
"qc.measure([0, 1], [0, 1])\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "f1d86563",
"metadata": {},
"source": [
"Se vogliamo stimare il valore di aspettativa di un operatore (come $Z \\otimes Z$ ), useremo Estimator. Se vogliamo esaminare gli stati del sistema, usiamo Sampler.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "e3bda5ff",
"metadata": {},
"outputs": [],
"source": [
"sampler = StatevectorSampler()\n",
"estimator = StatevectorEstimator()"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "aeac09f7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'10': 661, '11': 203, '01': 47, '00': 113}"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# compute counts of bitstrings with random parameter values by Sampler\n",
"result = sampler.run([(qc, [1, 2, 3, 4, 5, 6])]).result()\n",
"counts = result[0].data.c.get_counts()\n",
"counts"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "c96acbdf",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-0.3828125"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# compute the expectation value of ZZ based on the counts\n",
"(\n",
" counts.get(\"00\", 0)\n",
" - counts.get(\"01\", 0)\n",
" - counts.get(\"10\", 0)\n",
" + counts.get(\"11\", 0)\n",
") / sum(counts.values())"
]
},
{
"cell_type": "markdown",
"id": "d2cc2ed8",
"metadata": {},
"source": [
"Questo circuito funzionava, ma i valori dei parametri scelti non corrispondevano a uno stato a bassissima energia (o a bassi autovalori). L'autovalore ottenuto è di gran lunga superiore al minimo. Il risultato è simile quando si utilizza lo stimatore.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "474b84c5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array(-0.35316516)"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# verify the expectation value of ZZ with Estimator\n",
"result = estimator.run([(qc_estimator, z2, [1, 2, 3, 4, 5, 6])]).result()\n",
"result[0].data.evs"
]
},
{
"cell_type": "markdown",
"id": "25f4a655",
"metadata": {},
"source": [
"Dovremo cercare tra i parametri e trovare quelli che producono l'autovalore più basso.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "f29322f3",
"metadata": {},
"outputs": [],
"source": [
"# define a cost function to look for the minimum eigenvalue of ZZ\n",
"def cost(x):\n",
" result = sampler.run([(qc, x)]).result()\n",
" counts = result[0].data.c.get_counts()\n",
" expval = (\n",
" counts.get(\"00\", 0)\n",
" - counts.get(\"01\", 0)\n",
" - counts.get(\"10\", 0)\n",
" + counts.get(\"11\", 0)\n",
" ) / sum(counts.values())\n",
" print(expval, counts)\n",
" return expval"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "12d8ba03",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0 {'00': 1024}\n",
"0.578125 {'00': 808, '01': 216}\n",
"0.5234375 {'00': 780, '01': 244}\n",
"0.548828125 {'00': 793, '01': 231}\n",
"0.3515625 {'00': 637, '10': 164, '11': 55, '01': 168}\n",
"0.3359375 {'00': 638, '11': 46, '10': 174, '01': 166}\n",
"0.283203125 {'00': 602, '10': 181, '01': 186, '11': 55}\n",
"-0.087890625 {'01': 414, '00': 184, '10': 143, '11': 283}\n",
"0.236328125 {'10': 27, '11': 623, '01': 364, '00': 10}\n",
"-0.0625 {'11': 261, '01': 403, '00': 219, '10': 141}\n",
"0.248046875 {'01': 366, '11': 628, '00': 11, '10': 19}\n",
"-0.0625 {'10': 145, '11': 254, '01': 399, '00': 226}\n",
"0.228515625 {'01': 373, '11': 609, '00': 20, '10': 22}\n",
"0.0546875 {'11': 376, '10': 273, '01': 211, '00': 164}\n",
"-0.447265625 {'01': 731, '10': 10, '11': 267, '00': 16}\n",
"-0.71484375 {'01': 871, '11': 99, '00': 47, '10': 7}\n",
"-0.46484375 {'01': 741, '00': 253, '10': 9, '11': 21}\n",
"-0.87890625 {'01': 962, '00': 39, '11': 23}\n",
"-0.640625 {'00': 176, '01': 837, '11': 8, '10': 3}\n",
"-0.88671875 {'01': 966, '00': 41, '11': 17}\n",
"-0.994140625 {'01': 1021, '11': 3}\n",
"-0.91796875 {'01': 982, '11': 35, '00': 7}\n",
"-0.994140625 {'01': 1021, '11': 2, '00': 1}\n",
"-0.939453125 {'01': 993, '00': 31}\n",
"-0.990234375 {'01': 1019, '11': 5}\n",
"-0.90234375 {'01': 974, '00': 21, '11': 29}\n",
"-0.98046875 {'01': 1014, '11': 10}\n",
"-0.994140625 {'01': 1021, '00': 3}\n",
"-0.990234375 {'01': 1019, '11': 4, '00': 1}\n",
"-0.98828125 {'01': 1018, '11': 6}\n",
"-0.990234375 {'01': 1019, '11': 4, '00': 1}\n",
"-0.994140625 {'01': 1021, '11': 2, '00': 1}\n",
"-0.99609375 {'01': 1022, '11': 2}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-0.99609375 {'01': 1022, '00': 2}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-0.99609375 {'01': 1022, '00': 1, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-0.99609375 {'01': 1022, '11': 1, '00': 1}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-0.994140625 {'01': 1021, '00': 3}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-0.99609375 {'01': 1022, '11': 2}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '00': 1}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.998046875 {'01': 1023, '11': 1}\n",
"-0.99609375 {'01': 1022, '11': 2}\n",
"-1.0 {'01': 1024}\n",
"-0.998046875 {'01': 1023, '11': 1}\n"
]
},
{
"data": {
"text/plain": [
" message: Optimization terminated successfully.\n",
" success: True\n",
" status: 1\n",
" fun: -0.998046875\n",
" x: [ 3.167e+00 6.940e-01 1.033e+00 -2.894e-02 8.933e-01\n",
" 1.885e+00]\n",
" nfev: 128\n",
" maxcv: 0.0"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"text/plain": [
" message: Optimization terminated successfully.\n",
" success: True\n",
" status: 1\n",
" fun: -0.99609375\n",
" x: [ 3.098e+00 -5.402e-01 1.091e+00 -1.004e-02 3.615e-01\n",
" 6.913e-01]\n",
" nfev: 115\n",
" maxcv: 0.0"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# minimize the cost function with scipy's minimize\n",
"min_result = minimize(cost, [0, 0, 0, 0, 0, 0], method=\"COBYLA\", tol=1e-8)\n",
"min_result"
]
},
{
"cell_type": "markdown",
"id": "d3e2de8d",
"metadata": {},
"source": [
"Abbiamo ottenuto un autovalore estremamente vicino al minimo fornito da numpy.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "d34a8544",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'01': 1024}"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# check counts of bitstrings with the optimal parameters\n",
"result = sampler.run([(qc, min_result.x)]).result()\n",
"result[0].data.c.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "bc51e7bf-e582-49ba-93f8-035624d56ccf",
"metadata": {},
"source": [
"\n",
"\n",
"## 3. Ottimizzazione quantistica con i modelli Qiskit\n",
"\n",
"In questa guida impareremo a conoscere i modelli Qiskit e l'ottimizzazione approssimativa quantistica. Un modello Qiskit è un insieme intuitivo e ripetibile di passaggi per l'implementazione di un flusso di lavoro di calcolo quantistico:\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "636ed1de-fc34-4cdd-9398-6fbd7c7fc9c6",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8d3218ca-ce9e-40b4-a041-1b1d09bac8f5",
"metadata": {},
"source": [
"Applicheremo questi modelli al contesto **dell** 'ottimizzazione combinatoria e mostreremo come risolvere il problema **del taglio massimo** utilizzando **l** 'algoritmo di ottimizzazione approssimativa quantistica (QAOA), un metodo iterativo ibrido (quantistico-classico).\n",
"\n",
"Si noti che questa parte di QAOA si basa sulla \"Parte 1: QAOA su piccola scala\" del tutorial sull' [algoritmo di ottimizzazione approssimativa quantistica](/docs/tutorials/quantum-approximate-optimization-algorithm). Vedere il tutorial per imparare a ridimensionarlo.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "1e943b1a-218a-468c-bb63-4269896ebebe",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.1 Modello Qiskit (su piccola scala) per l'ottimizzazione\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "68fd0b4f-baa4-45dc-9f4c-d9cdff01a651",
"metadata": {},
"source": [
"In questa sezione useremo un problema di \"max-cut\" su piccola scala per illustrare i passaggi necessari per risolvere un problema di ottimizzazione utilizzando un computer quantistico.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "74b92ba5-c48a-405c-9c4b-04e985a7afbc",
"metadata": {},
"source": [
"Il problema del max-cut è un problema di ottimizzazione di difficile risoluzione (più precisamente, è un problema NP-difficile) che trova numerose applicazioni nel clustering, nella scienza delle reti e nella fisica statistica. Questo tutorial prende in esame un grafo costituito da nodi collegati da spigoli e mira a suddividere i nodi in due insiemi \"tagliando\" gli spigoli, in modo tale da massimizzare il numero di spigoli tagliati.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "887eb6ea-f58e-482f-8965-953a08fceecf",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "893a25f2",
"metadata": {},
"source": [
"Per contestualizzare il problema prima di tradurlo in un algoritmo quantistico, è possibile comprendere meglio come il problema del taglio massimo si trasformi in un problema di ottimizzazione combinatoria classica considerando innanzitutto la minimizzazione di una funzione $f(x)$\n",
"\n",
"$$\n",
"\\min_{x\\in \\{0, 1\\}^n}f(x),\n",
"$$\n",
"\n",
"dove l'ingresso $x$ è un vettore le cui componenti corrispondono a ciascun nodo di un grafo. Quindi, vincoliamo ciascuno di questi componenti a essere $0$ o $1$ (che rappresentano l'inclusione o l'esclusione dal taglio). Questo esempio su piccola scala utilizza un grafo con $n=5$ nodi.\n",
"\n",
"Si potrebbe scrivere una funzione di una coppia di nodi $i,j$ che indichi se il bordo corrispondente $(i,j)$ è nel taglio. Per esempio, la funzione $x_i + x_j - 2 x_i x_j$ è 1 solo se uno dei due $x_i$ o $x_j$ sono 1 (il che significa che il bordo è nel taglio) e zero altrimenti. Il problema della massimizzazione degli spigoli nel taglio può essere formulato come\n",
"\n",
"$$\n",
"\\max_{x\\in \\{0, 1\\}^n} \\sum_{(i,j)} x_i + x_j - 2 x_i x_j,\n",
"$$\n",
"\n",
"che può essere riscritta come una minimizzazione della forma\n",
"\n",
"$$\n",
"\\min_{x\\in \\{0, 1\\}^n} \\sum_{(i,j)} 2 x_i x_j - x_i - x_j.\n",
"$$\n",
"\n",
"Il minimo di $f(x)$ in questo caso si ha quando il numero di bordi attraversati dal taglio è massimo. Come si può vedere, non c'è ancora nulla che riguardi l'informatica quantistica. È necessario riformulare questo problema in qualcosa che un computer quantistico possa capire.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e2105a90-027f-44d7-97d1-c2c99373d488",
"metadata": {},
"source": [
"Inizializzare il problema creando un grafo con $n=5$ nodi.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "d3c0dfa7",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import rustworkx as rx\n",
"from rustworkx.visualization import mpl_draw"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "99e763fe",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"n = 5\n",
"\n",
"graph = rx.PyGraph()\n",
"graph.add_nodes_from(range(1, n + 1))\n",
"edge_list = [\n",
" (0, 1, 1.0),\n",
" (0, 2, 1.0),\n",
" (1, 2, 1.0),\n",
" (1, 3, 1.0),\n",
" (2, 4, 1.0),\n",
" (3, 4, 1.0),\n",
"]\n",
"graph.add_edges_from(edge_list)\n",
"pos = rx.spring_layout(graph, seed=2)\n",
"mpl_draw(graph, node_size=600, pos=pos, with_labels=True, labels=str)"
]
},
{
"cell_type": "markdown",
"id": "a06e4386-d7bd-4914-9baa-36a5cc60e3ab",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.2 Passaggio 1. Mappare gli input classici su un problema quantistico\n",
"\n",
"Il primo passo del modello consiste nel mappare il problema classico (grafo) in **circuiti** e **operatori** quantistici. A tal fine, sono tre le fasi principali da seguire:\n",
"\n",
"1. Utilizzare una serie di riformulazioni matematiche per rappresentare questo problema utilizzando la notazione dei problemi di ottimizzazione binaria non vincolata quadratica (QUBO).\n",
"2. Riscrivere il problema di ottimizzazione come un'hamiltoniana per la quale lo stato fondamentale corrisponde alla soluzione che minimizza la funzione di costo.\n",
"3. Creare un circuito quantistico che prepari lo stato fondamentale di questa hamiltoniana attraverso un processo simile alla ricottura quantistica.\n",
"\n",
"**Nota:** nella metodologia QAOA, in ultima analisi, si vuole avere un operatore (**hamiltoniano** ) che rappresenti la **funzione di costo** del nostro algoritmo ibrido, nonché un circuito parametrizzato (**Ansatz** ) che rappresenti gli stati quantistici con le soluzioni candidate al problema. È possibile campionare questi stati candidati e poi valutarli utilizzando la funzione di costo.\n",
"\n",
"\n",
"\n",
"#### Grafico → problema di ottimizzazione\n",
"\n",
"Il primo passo della mappatura è un cambiamento di notazione, di seguito viene espresso il problema in notazione QUBO:\n",
"\n",
"$$\n",
"\\min_{x\\in \\{0, 1\\}^n}x^T Q x,\n",
"$$\n",
"\n",
"dove $Q$ è una matrice $n\\times n$ di numeri reali, $n$ corrisponde al numero di nodi del grafo, $x$ è il vettore di variabili binarie introdotto sopra e $x^T$ indica la trasposizione del vettore $x$.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c00a3493-abab-46d8-86a9-5b853979a575",
"metadata": {},
"source": [
"```\n",
"Problem name: maxcut\n",
"\n",
"Minimize\n",
" 2*x_1*x_2 + 2*x_1*x_3 + 2*x_2*x_3 + 2*x_2*x_4 + 2*x_3*x_5 + 2*x_4*x_5 - 2*x_1\n",
" - 3*x_2 - 3*x_3 - 2*x_4 - 2*x_5\n",
"\n",
"Subject to\n",
" No constraints\n",
"\n",
" Binary variables (5)\n",
" x_1 x_2 x_3 x_4 x_5\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a5b9e551-38a1-4543-b9f1-caaefb0ef3a9",
"metadata": {},
"source": [
"\n",
"\n",
"#### Problema di ottimizzazione → Hamiltoniano\n",
"\n",
"È quindi possibile riformulare il problema QUBO come un' **hamiltoniana** (in questo caso, una matrice che rappresenta l'energia di un sistema):\n",
"\n",
"$$\n",
"H_C=\\sum_{ij}Q_{ij}Z_iZ_j + \\sum_i b_iZ_i.\n",
"$$\n",
"\n",
"**Fasi di riformulazione dal problema QAOA all'Hamiltoniana**\n",
"\n",
"Per dimostrare come il problema QAOA possa essere riscritto in questo modo, sostituiamo prima le variabili binarie $x_i$ con un nuovo insieme di variabili $z_i\\in\\{-1, 1\\}$ tramite\n",
"\n",
"$$\n",
"x_i = \\frac{1-z_i}{2}.\n",
"$$\n",
"\n",
"Qui si può notare che se $x_i$ è $0$, allora $z_i$ deve essere $1$. Sostituendo le $x_i$ con le $z_i$ nel problema di ottimizzazione ( $x^TQx$ ), si ottiene una formulazione equivalente.\n",
"\n",
"$$\n",
"x^TQx=\\sum_{ij}Q_{ij}x_ix_j \\\\ =\\frac{1}{4}\\sum_{ij}Q_{ij}(1-z_i)(1-z_j) \\\\=\\frac{1}{4}\\sum_{ij}Q_{ij}z_iz_j-\\frac{1}{4}\\sum_{ij}(Q_{ij}+Q_{ji})z_i + \\frac{n^2}{4}.\n",
"$$\n",
"\n",
"Ora, se definiamo $b_i=-\\sum_{j}(Q_{ij}+Q_{ji})$, eliminiamo il prefattore e il termine costante $n^2$, otteniamo le due formulazioni equivalenti dello stesso problema di ottimizzazione.\n",
"\n",
"$$\n",
"min_{x\\in\\{0,1\\}^n} x^TQx\\Longleftrightarrow \\min_{z\\in\\{-1,1\\}^n}z^TQz + b^Tz\n",
"$$\n",
"\n",
"Qui, $b$ dipende da $Q$. Si noti che per ottenere $z^TQz + b^Tz$ abbiamo eliminato il fattore 1/4 e un offset costante di $n^2$ che non hanno alcun ruolo nell'ottimizzazione.\n",
"\n",
"Ora, per ottenere una formulazione quantistica del problema, si promuovono le variabili $z_i$ a una matrice di Pauli $Z$, come una matrice $2\\times 2$ della forma\n",
"\n",
"$$\n",
"Z_i = \\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}.\n",
"$$\n",
"\n",
"Sostituendo queste matrici nel problema di ottimizzazione di cui sopra, si ottiene la seguente hamiltoniana\n",
"\n",
"$$\n",
"H_C=\\sum_{ij}Q_{ij}Z_iZ_j + \\sum_i b_iZ_i.\n",
"$$\n",
"\n",
"*Ricordiamo inoltre che le matrici $Z$ sono incorporate nello spazio computazionale del computer quantistico, cioè uno spazio di Hilbert di dimensioni $2^n\\times 2^n$. Pertanto, si devono intendere termini come $Z_iZ_j$ come il prodotto tensoriale $Z_i\\otimes Z_j$ incorporato nello spazio di Hilbert $2^n\\times 2^n$. Ad esempio, in un problema con cinque variabili decisionali, il termine $Z_1Z_3$ è inteso come $I\\otimes Z_3\\otimes I\\otimes Z_1\\otimes I$ dove $I$ è la matrice identità $2\\times 2$.*\n",
"\n",
"Questa hamiltoniana è chiamata funzione di costo hamiltoniana. Ha la proprietà che il suo stato fondamentale corrisponde alla soluzione di minimizza la funzione di costo $f(x)$. Pertanto, per risolvere il problema di ottimizzazione è necessario preparare lo stato fondamentale di $H_C$ (o uno stato con un'elevata sovrapposizione con esso) sul computer quantistico. Quindi, il campionamento da questo stato produrrà, con un'alta probabilità, la soluzione di $\\min~f(x)$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "47256f53-8e02-494e-864a-a6f45b10442a",
"metadata": {},
"outputs": [],
"source": [
"def build_max_cut_operator(graph: rx.PyGraph) -> tuple[SparsePauliOp, float]:\n",
" sp_list = []\n",
" constant = 0\n",
" for s, t in graph.edge_list():\n",
" w = graph.get_edge_data(s, t)\n",
" sp_list.append((\"ZZ\", [s, t], w / 2))\n",
" constant -= 1 / 2\n",
" return SparsePauliOp.from_sparse_list(\n",
" sp_list, num_qubits=graph.num_nodes()\n",
" ), constant"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "01a2d8eb-b63b-40bc-93c5-0b547c06b194",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cost Function Hamiltonian: SparsePauliOp(['IIIZZ', 'IIZIZ', 'IIZZI', 'IZIZI', 'ZIZII', 'ZZIII'],\n",
" coeffs=[0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j])\n",
"Constant: -3.0\n"
]
}
],
"source": [
"cost_hamiltonian, constant = build_max_cut_operator(graph)\n",
"print(\"Cost Function Hamiltonian:\", cost_hamiltonian)\n",
"print(\"Constant:\", constant)"
]
},
{
"cell_type": "markdown",
"id": "33f71b0d-4a2a-4082-8c1a-ce9d2b769048",
"metadata": {},
"source": [
"\n",
"\n",
"#### Circuito quantistico hamiltoniano\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "00431c46-30c2-40f9-99df-40baf8da98f6",
"metadata": {},
"source": [
"L'Hamiltonian $H_C$ contiene la definizione quantistica del problema. Ora è possibile creare un circuito quantistico che aiuterà a *campionare* buone soluzioni dal computer quantistico. Il QAOA si ispira alla ricottura quantistica e applica strati alternati di operatori nel circuito quantistico.\n",
"\n",
"L'idea generale è quella di partire dallo stato fondamentale di un sistema noto, $H^{\\otimes n}|0\\rangle$, e poi indirizzare il sistema verso lo stato fondamentale dell'operatore di costo a cui si è interessati. Ciò avviene applicando gli operatori $\\exp\\{-i\\gamma_k H_C\\}$ e $\\exp\\{-i\\beta_k H_m\\}$ con gli angoli $\\gamma_1,...,\\gamma_p$ e $\\beta_1,...,\\beta_p~$.\n",
"\n",
"Il circuito quantistico generato è **parametrizzato** da $\\gamma_i$ e $\\beta_i$, quindi è possibile provare diversi valori di $\\gamma_i$ e $\\beta_i$ e campionare lo stato risultante.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "ca09d6bf-e421-4ada-9515-1f69687bb511",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0d12bc53-7805-43e4-b4cb-754fd234b519",
"metadata": {},
"source": [
"In questo caso proveremo un esempio con 1 livello QAOA che contiene due parametri: $\\gamma_1$ e $\\beta_1$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "1f6215c0",
"metadata": {},
"outputs": [],
"source": [
"from qiskit.circuit.library import QAOAAnsatz"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "7bd8c6d4-f40f-4a11-a440-0b26d9021b53",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"circuit = QAOAAnsatz(cost_operator=cost_hamiltonian, reps=1)\n",
"circuit.measure_all()\n",
"circuit.draw(\"mpl\")"
]
},
{
"cell_type": "code",
"execution_count": 28,
"id": "148d2d62",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"circuit.decompose(reps=3).draw(\"mpl\", fold=-1)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "315c495a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"ParameterView([ParameterVectorElement(β[0]), ParameterVectorElement(γ[0])])"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"circuit.parameters"
]
},
{
"cell_type": "markdown",
"id": "82f70daa-ff68-447a-8064-8b7df7a646cf",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.3 Fase 2. Ottimizzare i circuiti per l'esecuzione dell'hardware quantistico\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c08be444-e3ed-4178-a10b-414069b1b411",
"metadata": {},
"source": [
"Il circuito di cui sopra contiene una serie di astrazioni utili per pensare agli algoritmi quantistici, ma non è possibile eseguirli sull'hardware. Per poter essere eseguito su una QPU, il circuito deve essere sottoposto a una serie di operazioni che costituiscono la fase di **transpilazione** o **ottimizzazione del circuito** del modello.\n",
"\n",
"La libreria Qiskit offre una serie di **passaggi di trasposizione** che soddisfano un'ampia gamma di trasformazioni circuitali. È necessario assicurarsi che il circuito sia **ottimizzato** per il proprio scopo.\n",
"\n",
"La trasposizione potrebbe comportare diverse fasi, quali:\n",
"\n",
"* **Mappatura iniziale** dei qubit del circuito (come le variabili decisionali) ai qubit fisici del dispositivo.\n",
"* **Srotolamento** delle istruzioni del circuito quantistico alle istruzioni native dell'hardware che il backend comprende.\n",
"* **Instradamento** dei qubit del circuito che interagiscono verso qubit fisici adiacenti.\n",
"* **Soppressione degli errori** mediante l'aggiunta di porte a singolo bit per sopprimere il rumore con disaccoppiamento dinamico.\n",
"\n",
"Ulteriori informazioni sulla transpilazione sono disponibili nella nostra [documentazione](/docs/guides/transpile).\n",
"\n",
"Il codice seguente trasforma e ottimizza il circuito astratto in un formato pronto per l'esecuzione su uno dei dispositivi accessibili tramite il cloud utilizzando il **servizio Qiskit IBM® Runtime**.\n",
"\n",
"Si noti che è possibile testare i programmi localmente con la \"modalità di test locale\" prima di inviarli ai computer quantistici reali.\n",
"Ulteriori informazioni sulla modalità di test locale sono disponibili nella [documentazione.](/docs/guides/local-testing-mode)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95cd3eed-0348-4373-b664-16a65d42f1e7",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
" service = QiskitRuntimeService(channel=\"ibm_quantum_platform\")\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"# Use a quantum device\n",
"service = QiskitRuntimeService()\n",
"backend = service.least_busy(min_num_qubits=127)\n",
"# backend = service.backend(\"ibm_kingston\")\n",
"\n",
"# You can test your programs locally with a fake backend (local testing mode)\n",
"# backend = FakeBrisbane()\n",
"\n",
"print(backend)\n",
"\n",
"# Create pass manager for transpilation\n",
"pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n",
"\n",
"candidate_circuit = pm.run(circuit)\n",
"candidate_circuit.draw(\"mpl\", fold=False, idle_wires=False)"
]
},
{
"cell_type": "markdown",
"id": "4e75cad7-f599-4937-b5fe-f4d01f53423c",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.4 Fase 3. Eseguire utilizzando le primitive di IBM Quantum\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9b99ce67-f121-4244-b62a-536be38fea86",
"metadata": {},
"source": [
"Nel flusso di lavoro QAOA, i parametri ottimali di QAOA vengono trovati in un ciclo di ottimizzazione iterativa, che esegue una serie di valutazioni del circuito e utilizza un ottimizzatore classico per trovare i parametri ottimali $\\beta_k$ e $\\gamma_k$. Questo ciclo di esecuzione viene eseguito attraverso i seguenti passaggi:\n",
"\n",
"1. Definire i parametri iniziali\n",
"2. Istanziare un nuovo `Session` contenente il loop di ottimizzazione e la primitiva utilizzata per campionare il circuito\n",
"3. Una volta trovato un insieme ottimale di parametri, eseguire il circuito un'ultima volta per ottenere una distribuzione finale che verrà utilizzata nella fase di post-processing.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "00b2b0f1-9bad-4ad3-b93e-5cbf40395dbf",
"metadata": {},
"source": [
"\n",
"\n",
"#### Definire il circuito con i parametri iniziali\n",
"\n",
"Si parte da parametri scelti in modo arbitrario.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "afa5747f-44dc-4e41-a875-7b6f896f13e2",
"metadata": {},
"outputs": [],
"source": [
"initial_gamma = np.pi\n",
"initial_beta = np.pi / 2\n",
"init_params = [initial_gamma, initial_beta]"
]
},
{
"cell_type": "markdown",
"id": "b867f1b0-7196-4d34-9b28-e3fb1de8221c",
"metadata": {},
"source": [
"\n",
"\n",
"#### Definire il backend e la primitiva di esecuzione\n",
"\n",
"Utilizzare le **primitive \" IBM Quantum \"** per interagire con i backend \" IBM® \". Le due primitive sono Sampler ed Estimator, e la scelta della primitiva dipende dal tipo di misurazione che si desidera eseguire sul computer quantistico. Per minimizzare $H_C$, utilizzare Estimator poiché il valore della funzione di costo corrisponde semplicemente al valore atteso di $\\langle H_C \\rangle$.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "36c789f2",
"metadata": {},
"source": [
"\n",
"\n",
"#### Esegui\n",
"\n",
"Le primitive offrono una varietà di [modalità di esecuzione](/docs/guides/execution-modes) per programmare i carichi di lavoro sui dispositivi quantistici e un flusso di lavoro QAOA viene eseguito iterativamente in una sessione.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "122b7dc8-8d8a-45f2-813e-6199905d765b",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "fff58deb",
"metadata": {},
"source": [
"È possibile inserire la funzione di costo basata sul campionatore nella routine di minimizzazione di SciPy per trovare i parametri ottimali.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "ff947109-cddc-4d3c-9119-2c729df73115",
"metadata": {},
"outputs": [],
"source": [
"def cost_func_estimator(params, ansatz, hamiltonian, estimator):\n",
" # transform the observable defined on virtual qubits to\n",
" # an observable defined on all physical qubits\n",
" isa_hamiltonian = hamiltonian.apply_layout(ansatz.layout)\n",
"\n",
" pub = (ansatz, isa_hamiltonian, params)\n",
" job = estimator.run([pub])\n",
"\n",
" results = job.result()[0]\n",
" cost = results.data.evs\n",
"\n",
" objective_func_vals.append(cost)\n",
"\n",
" return cost"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "f5f46775",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" message: Optimization terminated successfully.\n",
" success: True\n",
" status: 1\n",
" fun: -0.6557925874481715\n",
" x: [ 2.873e+00 9.414e-01]\n",
" nfev: 21\n",
" maxcv: 0.0\n"
]
}
],
"source": [
"from qiskit_ibm_runtime import Session, EstimatorV2\n",
"from scipy.optimize import minimize\n",
"\n",
"objective_func_vals = [] # Global variable\n",
"with Session(backend=backend) as session:\n",
" # If using qiskit-ibm-runtime<0.24.0, change `mode=` to `session=`\n",
" estimator = EstimatorV2(mode=session)\n",
" estimator.options.default_shots = 1000\n",
"\n",
" # Set simple error suppression/mitigation options\n",
" estimator.options.dynamical_decoupling.enable = True\n",
" estimator.options.dynamical_decoupling.sequence_type = \"XY4\"\n",
" estimator.options.twirling.enable_gates = True\n",
" estimator.options.twirling.num_randomizations = \"auto\"\n",
"\n",
" result = minimize(\n",
" cost_func_estimator,\n",
" init_params,\n",
" args=(candidate_circuit, cost_hamiltonian, estimator),\n",
" method=\"COBYLA\",\n",
" tol=1e-2,\n",
" )\n",
" print(result)"
]
},
{
"cell_type": "markdown",
"id": "ad878b62",
"metadata": {},
"source": [
"L'ottimizzatore è riuscito a ridurre i costi e a trovare parametri migliori per il circuito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "f923dd5d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.figure(figsize=(12, 6))\n",
"plt.plot(objective_func_vals)\n",
"plt.xlabel(\"Iteration\")\n",
"plt.ylabel(\"Cost\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "e2ea6359",
"metadata": {},
"source": [
"Una volta trovati i parametri ottimali per il circuito, è possibile assegnarli e campionare la distribuzione finale ottenuta con i parametri ottimizzati. È qui che si dovrebbe usare la primitiva *Sampler*, poiché è la distribuzione di probabilità delle misure delle stringhe di bit che corrisponde al taglio ottimale del grafo.\n",
"\n",
"**Nota:** ciò significa preparare uno stato quantico $\\psi$ nel computer e poi misurarlo. Una misurazione farà collassare lo stato in un singolo stato base computazionale - per esempio, `010101110000...` - che corrisponde a una soluzione candidata $x$ al nostro problema di ottimizzazione iniziale ( $\\max f(x)$ o $\\min f(x)$ a seconda del compito).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"id": "f8dddf5a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"optimized_circuit = candidate_circuit.assign_parameters(result.x)\n",
"optimized_circuit.draw(\"mpl\", fold=False, idle_wires=False)"
]
},
{
"cell_type": "code",
"execution_count": 37,
"id": "fd9669cf",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{12: 0.0652, 31: 0.0089, 4: 0.0085, 13: 0.0731, 26: 0.0256, 28: 0.0246, 17: 0.0405, 25: 0.0591, 20: 0.031, 15: 0.0221, 8: 0.017, 21: 0.0371, 14: 0.0461, 16: 0.0229, 19: 0.0723, 23: 0.0199, 22: 0.0478, 18: 0.0708, 24: 0.0165, 6: 0.0525, 7: 0.0155, 5: 0.0245, 3: 0.0231, 29: 0.0121, 30: 0.0062, 10: 0.0363, 1: 0.0097, 9: 0.042, 27: 0.0094, 11: 0.0349, 0: 0.0129, 2: 0.0119}\n"
]
}
],
"source": [
"from qiskit_ibm_runtime import SamplerV2\n",
"\n",
"# If using qiskit-ibm-runtime<0.24.0, change `mode=` to `backend=`\n",
"sampler = SamplerV2(mode=backend)\n",
"\n",
"# Set simple error suppression/mitigation options\n",
"sampler.options.dynamical_decoupling.enable = True\n",
"sampler.options.dynamical_decoupling.sequence_type = \"XY4\"\n",
"sampler.options.twirling.enable_gates = True\n",
"sampler.options.twirling.num_randomizations = \"auto\"\n",
"\n",
"pub = (optimized_circuit,)\n",
"job = sampler.run([pub], shots=int(1e4))\n",
"counts_int = job.result()[0].data.meas.get_int_counts()\n",
"counts_bin = job.result()[0].data.meas.get_counts()\n",
"shots = sum(counts_int.values())\n",
"final_distribution_int = {key: val / shots for key, val in counts_int.items()}\n",
"final_distribution_bin = {key: val / shots for key, val in counts_bin.items()}\n",
"print(final_distribution_int)"
]
},
{
"cell_type": "markdown",
"id": "2c89613f",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.5 Fase 4. Post-elaborazione, restituisce il risultato in formato classico\n",
"\n",
"La fase di post-elaborazione interpreta il risultato del campionamento per fornire una soluzione al problema originale. In questo caso, si è interessati alla stringa di bit con la probabilità più alta, poiché questa determina il taglio ottimale. Le simmetrie del problema consentono quattro possibili soluzioni e il processo di campionamento ne restituirà una con una probabilità leggermente superiore, ma si può notare nella distribuzione tracciata qui sotto che quattro delle stringhe di bit sono distintamente più probabili delle altre.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "d4f7fc70-883f-4b6b-8e92-2fc4afbbea46",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Result bitstring: [1, 0, 1, 1, 0]\n"
]
}
],
"source": [
"# auxiliary functions to sample most likely bitstring\n",
"def to_bitstring(integer, num_bits):\n",
" result = np.binary_repr(integer, width=num_bits)\n",
" return [int(digit) for digit in result]\n",
"\n",
"\n",
"keys = list(final_distribution_int.keys())\n",
"values = list(final_distribution_int.values())\n",
"most_likely = keys[np.argmax(np.abs(values))]\n",
"most_likely_bitstring = to_bitstring(most_likely, len(graph))\n",
"most_likely_bitstring.reverse()\n",
"\n",
"print(\"Result bitstring:\", most_likely_bitstring)"
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "32a3020e-c1ea-4aff-988c-d7910a690fa8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"matplotlib.rcParams.update({\"font.size\": 10})\n",
"final_bits = final_distribution_bin\n",
"values = np.abs(list(final_bits.values()))\n",
"top_4_values = sorted(values, reverse=True)[:4]\n",
"positions = []\n",
"for value in top_4_values:\n",
" positions.append(np.where(values == value)[0])\n",
"fig = plt.figure(figsize=(11, 6))\n",
"ax = fig.add_subplot(1, 1, 1)\n",
"plt.xticks(rotation=45)\n",
"plt.title(\"Result Distribution\")\n",
"plt.xlabel(\"Bitstrings (reversed)\")\n",
"plt.ylabel(\"Probability\")\n",
"ax.bar(list(final_bits.keys()), list(final_bits.values()), color=\"tab:grey\")\n",
"for p in positions:\n",
" ax.get_children()[p[0].item()].set_color(\"tab:purple\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "6cfcb278",
"metadata": {},
"source": [
"\n",
"\n",
"#### Visualizza il taglio migliore\n",
"\n",
"Dalla stringa di bit ottimale, è possibile visualizzare questo taglio sul grafico originale.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"id": "22a48124-e6b4-4144-bee1-f01fa4c7ccbb",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"colors = [\"tab:grey\" if i == 0 else \"tab:purple\" for i in most_likely_bitstring]\n",
"mpl_draw(graph, node_size=600, pos=pos, with_labels=True, labels=str, node_color=colors)"
]
},
{
"cell_type": "markdown",
"id": "4c4803ab",
"metadata": {},
"source": [
"E calcolare il valore del taglio. La soluzione non è ottimale a causa del rumore (il valore di taglio della soluzione ottimale è 5).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"id": "7208ee7d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The value of the cut is: 5\n"
]
}
],
"source": [
"from typing import Sequence\n",
"\n",
"\n",
"def evaluate_sample(x: Sequence[int], graph: rx.PyGraph) -> float:\n",
" assert len(x) == len(\n",
" list(graph.nodes())\n",
" ), \"The length of x must coincide with the number of nodes in the graph.\"\n",
" return sum(\n",
" x[u] * (1 - x[v]) + x[v] * (1 - x[u]) for u, v in list(graph.edge_list())\n",
" )\n",
"\n",
"\n",
"cut_value = evaluate_sample(most_likely_bitstring, graph)\n",
"print(\"The value of the cut is:\", cut_value)"
]
},
{
"cell_type": "markdown",
"id": "1450be7e",
"metadata": {},
"source": [
"Si conclude così l'esercitazione su piccola scala di QAOA.\n",
"Imparerete come adattare QAOA a livello di utility in \"Parte 2: scalare!\" del tutorial sull' [algoritmo di ottimizzazione approssimativa quantistica](/docs/tutorials/quantum-approximate-optimization-algorithm).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "2a4f85ab",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'2.0.2'"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Check Qiskit version\n",
"import qiskit\n",
"\n",
"qiskit.__version__"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}