{
"cells": [
{
"cell_type": "markdown",
"id": "b6d1e3ec",
"metadata": {},
"source": [
"---\n",
"title: \"Modellare un fluido non viscoso in movimento utilizzando QUICK-PDE\"\n",
"description: \"Utilizzare la funzione QUICK-PDE per modellare un fluido non viscoso in movimento.\"\n",
"---\n",
"\n",
"{/* cspell:ignore zlabel ylabel xlabel */}\n",
"\n",
"\n",
"\n",
"# Modellare un fluido non viscoso in movimento utilizzando QUICK-PDE\n",
"\n",
"{/* cspell:ignore edgecolor, royalblue, rstride, cstride, Navier, Iterat, Fevals, HDES, PINN, ftarget */}\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "a6f69b77",
"metadata": {},
"source": [
"\n",
" Le funzioni Qiskit sono una funzione sperimentale disponibile solo per gli utenti di IBM Quantum® Premium Plan, Flex Plan e On-Prem (tramite IBM Quantum Platform API) Plan. Sono in stato di anteprima e sono soggetti a modifiche.\n",
"\n",
"\n",
"*Stima di utilizzo: 50 minuti su un processore Heron r2. (NOTA: questa è solo una stima. Il tempo di esecuzione potrebbe variare)*\n",
"\n",
"Si noti che il tempo di esecuzione di questa funzione è generalmente superiore a 20 minuti, quindi si consiglia di suddividere questa esercitazione in due sezioni: la prima, in cui si la prima, in cui si leggono e si lanciano i lavori, e la seconda qualche ora dopo (dando il tempo necessario per completare i lavori), per lavorare con i lavori di (lasciando il tempo necessario per completare i lavori), per lavorare con i risultati dei lavori.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8bf80006",
"metadata": {},
"source": [
"\n",
"\n",
"## Sfondo\n",
"\n",
"Questo tutorial ha lo scopo di illustrare, a livello introduttivo, come utilizzare la funzione QUICK-PDE\n",
"per risolvere complessi problemi multifisici su CPU Heron R2 di 156Q, avvalendosi\n",
"del risolutore H-DES (Hybrid Differential Equation Solver) di ColibriTD's.\n",
"L'algoritmo alla base è descritto [nell'articolo su H-DES](https://arxiv.org/abs/2410.01130).\n",
"Si noti che questo risolutore è in grado di risolvere anche equazioni non lineari.\n",
"\n",
"I problemi multi-fisici, tra cui la dinamica dei fluidi, la diffusione del calore e la deformazione dei materiali, per citarne alcuni, possono essere deformazione dei materiali, per citarne alcuni, possono essere descritti in modo onnipresente da equazioni differenziali Equazioni differenziali parziali (PDE).\n",
"\n",
"Questi problemi sono molto importanti per vari settori industriali e costituiscono un'importante branca della matematica applicata un'importante branca della matematica applicata. Tuttavia, la risoluzione di PDE non lineari pDE multivariate accoppiate con gli strumenti classici rimane impegnativa a causa della richiesta di una quantità esponenziale di risorse.\n",
"\n",
"Questa funzione è appropriata per equazioni con complessità e variabili crescenti variabili, ed è il primo passo per sbloccare possibilità che un tempo erano considerate intrattabili. Per descrivere in modo completo un problema modellato da PDE, è necessario conoscere le condizioni iniziali e quelle al contorno. Questi possono cambiare fortemente cambiare fortemente la soluzione della PDE e il percorso per trovarne la soluzione.\n",
"\n",
"Questa esercitazione insegna come:\n",
"\n",
"1. Definire i parametri della funzione di condizione iniziale.\n",
"2. Regolare il numero di qubit (utilizzato per codificare la funzione dell'equazione differenziale), la profondità e il numero di colpi.\n",
"3. Eseguire QUICK-PDE per risolvere l'equazione differenziale sottostante.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "55b94021",
"metadata": {},
"source": [
"\n",
"\n",
"## Requisiti\n",
"\n",
"Prima di iniziare questa esercitazione, assicuratevi di aver installato quanto segue:\n",
"\n",
"* Qiskit SDK v2.0 o successivo (`pip install qiskit`)\n",
"* Catalogo delle funzioni Qiskit (`pip install qiskit-ibm-catalog`)\n",
"* Matplotlib (`pip install matplotlib`)\n",
"* Accesso alla funzione QUICK-PDE. Compila il [modulo per richiedere l'accesso](https://forms.cloud.microsoft/e/3Wi9cbjQPK).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5486cc33",
"metadata": {},
"source": [
"\n",
"\n",
"## Configura\n",
"\n",
"Autenticatevi con la vostra [chiave API](http://quantum.cloud.ibm.com/) e selezionate la funzione come segue:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "61d78897",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"catalog = QiskitFunctionsCatalog(\n",
" channel=\"ibm_quantum_platform\",\n",
" instance=\"INSTANCE_CRN\",\n",
" # For `token`, use the 44-character API_KEY you created\n",
" # and saved from the IBM Quantum Platform Home dashboard\n",
" token=\"YOUR_API_KEY\",\n",
")\n",
"\n",
"quick = catalog.load(\"colibritd/quick-pde\")"
]
},
{
"cell_type": "markdown",
"id": "939789bb",
"metadata": {},
"source": [
"\n",
"\n",
"## Passaggio 1: impostare le proprietà del problema da risolvere\n",
"\n",
"Questa esercitazione tratta l'esperienza dell'utente da due punti di vista: il problema fisico determinato dalle condizioni iniziali e l'algoritmo problema fisico, determinato dalle condizioni iniziali, e la componente algoritmica nella risoluzione di un esempio di fluidodinamica su un computer quantistico.\n",
"\n",
"La fluidodinamica computazionale (CFD) ha un'ampia gamma di applicazioni ed è quindi importante studiare e risolvere le PDE sottostanti importante studiare e risolvere le PDE sottostanti. Un'importante famiglia di PDE sono le equazioni di Navier-Stokes, che sono un sistema di equazioni differenziali parziali non lineari che descrivono il moto dei fluidi differenziali parziali non lineari che descrivono il moto dei fluidi. Sono altamente rilevanti per problemi scientifici e applicazioni ingegneristiche.\n",
"\n",
"In certe condizioni, le equazioni di Navier-Stokes si riducono all'equazione di Burgers, un'equazione di convezione-diffusione di Burgers, un'equazione di convezione-diffusione che descrive i fenomeni che si verificano nella fluidodinamica, nella dinamica dei gas e nell'acustica non lineare, per citarne alcuni fluidodinamica, dinamica dei gas e acustica non lineare, per citarne alcuni, modellando sistemi dissipativi sistemi dissipativi.\n",
"\n",
"La versione monodimensionale dell'equazione dipende da due variabili: $t \\in \\mathbb{R}_{\\geq 0}$ modellare la dimensione temporale, $x \\in \\mathbb{R}$ rappresentare la dimensione spaziale. La forma generale dell'equazione è chiamata equazione di Burgers viscosa e si legge:\n",
"\n",
"$\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} = \\nu \\frac{\\partial^2 u}{\\partial x^2},$\n",
"\n",
"dove$u(x,t)$\n",
"è il campo di velocità del fluido in una data posizione$x$\n",
"e in un dato istante$t$\n",
", e$\\nu$\n",
"è la viscosità del fluido. La viscosità è una proprietà importante di un fluido\n",
"che misura la sua resistenza al movimento o alla deformazione in funzione della velocità e, pertanto,\n",
"svolge un ruolo cruciale nella determinazione della dinamica di un fluido. Quando la\n",
"viscosità del fluido è nulla ( $\\nu = 0$ ), l'equazione diventa un'equazione di conservazione\n",
"che può generare discontinuità (onde d'urto), a causa dell'assenza della sua\n",
"resistenza interna. In questo caso, l'equazione è detta equazione di Burgers\n",
"non viscosa ed è un caso particolare dell'equazione d'onda non lineare.\n",
"\n",
"A rigore, i flussi inviscidi non si verificano in natura, ma quando si modella un flusso aerodinamico, a causa dell'effetto infinitesimale del trasporto, si utilizza un'analisi aerodinamico, a causa dell'effetto infinitesimale del trasporto, può essere utile una descrizione inviscida del problema descrizione inviscida del problema può essere utile. Sorprendentemente, più del 70% della teoria aerodinamica si occupa di flussi inviscidi.\n",
"\n",
"Questo tutorial utilizza l'equazione di Burgers per fluidi non viscosi come esempio di CFD da risolvere\n",
"su QPU IBM® i utilizzando QUICK-PDE, come indicato di seguito:\n",
"\n",
"$\\frac{\\partial u}{\\partial t} + u\\frac{\\partial u}{\\partial x} = 0.$\n",
"\n",
"La condizione iniziale per questo problema è definita da una funzione lineare:\n",
"$u(t=0,x) = ax + b,\\text{ with }a,b\\in\\mathbb{R},$\n",
"dove $a$ e $b$ sono costanti arbitrarie che influenzano la forma della\n",
"soluzione. È possibile modificare i valori di $a$ e $b$ e osservare come questi influenzano il\n",
"processo di risoluzione e la soluzione. Per questa scelta di condizioni iniziali,\n",
"l'equazione ammette la seguente soluzione analitica:\n",
"\n",
"$u(t, x) = \\frac{ax + b}{at + 1},$\n",
"\n",
"ciò vale fintantoché non si sia formato alcuno shock, ovvero, per es $t < -1/a$, quando $a < 0$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "286ae259",
"metadata": {},
"outputs": [],
"source": [
"job = quick.run(\n",
" use_case=\"CFD_BURGER\",\n",
" physical_parameters={\"a\": 1.0, \"b\": 1.0},\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2957db80",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'functions': {'u': array([[1. , 0.96112378, 0.9230742 , 0.88616096, 0.85058445,\n",
" 0.81644741, 0.78376878, 0.75249908, 0.72253689, 0.69374562,\n",
" 0.66597013, 0.63905258, 0.61284684, 0.58723093, 0.56211691,\n",
" 0.53745752, 0.51324915, 0.48953036, 0.46637547, 0.44388257,\n",
" 0.4221554 , 0.40127848, 0.38128488, 0.36211604, 0.34357308,\n",
" 0.32525895, 0.30651089, 0.28632252, 0.26325504, 0.23533692],\n",
" [1.2375 , 1.19267729, 1.14850734, 1.10544526, 1.06382155,\n",
" 1.02385326, 0.98565757, 0.94926734, 0.91464784, 0.88171402,\n",
" 0.85034771, 0.82041411, 0.79177677, 0.76431068, 0.73791248,\n",
" 0.71250742, 0.68805224, 0.66453346, 0.64196021, 0.62035121,\n",
" 0.59971506, 0.5800232 , 0.56117499, 0.54295419, 0.52497612,\n",
" 0.50662498, 0.48698059, 0.4647339 , 0.43809065, 0.40466247],\n",
" [1.475 , 1.4242308 , 1.37394048, 1.32472956, 1.27705866,\n",
" 1.23125911, 1.18754636, 1.1460356 , 1.10675879, 1.06968242,\n",
" 1.03472529, 1.00177563, 0.9707067 , 0.94139043, 0.91370806,\n",
" 0.88755732, 0.86285533, 0.83953655, 0.81754494, 0.79681986,\n",
" 0.77727473, 0.75876792, 0.74106511, 0.72379234, 0.70637915,\n",
" 0.687991 , 0.66745028, 0.64314527, 0.61292625, 0.57398802],\n",
" [1.7125 , 1.65578431, 1.59937362, 1.54401386, 1.49029576,\n",
" 1.43866495, 1.38943515, 1.34280386, 1.29886974, 1.25765082,\n",
" 1.21910288, 1.18313715, 1.14963664, 1.11847019, 1.08950364,\n",
" 1.06260722, 1.03765842, 1.01453964, 0.99312968, 0.97328851,\n",
" 0.95483439, 0.93751264, 0.92095522, 0.90463049, 0.88778219,\n",
" 0.86935702, 0.84791997, 0.82155665, 0.78776186, 0.74331358],\n",
" [1.95 , 1.88733782, 1.82480676, 1.76329816, 1.70353287,\n",
" 1.6460708 , 1.59132394, 1.53957212, 1.49098069, 1.44561922,\n",
" 1.40348046, 1.36449867, 1.32856657, 1.29554994, 1.26529921,\n",
" 1.23765712, 1.21246152, 1.18954273, 1.16871442, 1.14975716,\n",
" 1.13239406, 1.11625736, 1.10084533, 1.08546864, 1.06918523,\n",
" 1.05072304, 1.02838966, 0.99996803, 0.96259746, 0.91263913]])}, 'samples': {'t': array([0. , 0.03275862, 0.06551724, 0.09827586, 0.13103448,\n",
" 0.1637931 , 0.19655172, 0.22931034, 0.26206897, 0.29482759,\n",
" 0.32758621, 0.36034483, 0.39310345, 0.42586207, 0.45862069,\n",
" 0.49137931, 0.52413793, 0.55689655, 0.58965517, 0.62241379,\n",
" 0.65517241, 0.68793103, 0.72068966, 0.75344828, 0.7862069 ,\n",
" 0.81896552, 0.85172414, 0.88448276, 0.91724138, 0.95 ]), 'x': array([0. , 0.2375, 0.475 , 0.7125, 0.95 ])}}\n"
]
}
],
"source": [
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "ac6f36e3",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 2 (se necessario): ottimizzare il problema per l'esecuzione su hardware quantistico\n",
"\n",
"Per impostazione predefinita, il solutore utilizza parametri fisicamente informati, ovvero i parametri iniziali del circuito per un dato numero di qubit e una data profondità, da cui partirà il nostro solutore.\n",
"\n",
"Anche gli scatti fanno parte dei parametri con un valore predefinito, poiché la loro regolazione fine è importante.\n",
"\n",
"A seconda della configurazione che si sta cercando di risolvere, potrebbe essere necessario adattare i parametri dell'algoritmo per ottenere soluzioni soddisfacenti per ottenere soluzioni soddisfacenti potrebbe essere necessario adattare i parametri dell'algoritmo può richiedere più o meno qubit per le variabili $t$ e $x$, a seconda delle variabili $a$ e $b$. Di seguito viene regolato il numero di qubit per funzione e per variabile, la profondità per funzione e la profondità per variabile variabile, la profondità per funzione e il numero di scatti.\n",
"\n",
"Si può anche vedere come specificare il backend e la modalità di esecuzione.\n",
"\n",
"Inoltre, i parametri fisicamente informati potrebbero indirizzare il processo di ottimizzazione nella direzione sbagliata in una direzione sbagliata; in tal caso, è possibile disattivarli impostando la `initialization` a `\"RANDOM\"`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a6be6c17",
"metadata": {},
"outputs": [],
"source": [
"job_2 = quick.run(\n",
" use_case=\"CFD_BURGER\",\n",
" physical_parameters={\"a\": 0.5, \"b\": 0.25},\n",
" nb_qubits={\"u\": {\"t\": 2, \"x\": 1}},\n",
" depth={\"u\": 3},\n",
" shots=[500, 2500, 5000, 10000],\n",
" initialization=\"RANDOM\",\n",
" backend=\"ibm_kingston\",\n",
" mode=\"session\",\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "808793e8",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'functions': {'u': array([[0.25 , 0.24856543, 0.24687708, 0.2449444 , 0.24277686,\n",
" 0.24038389, 0.23777496, 0.23495952, 0.23194702, 0.22874691,\n",
" 0.22536866, 0.22182171, 0.21811551, 0.21425952, 0.2102632 ,\n",
" 0.20613599, 0.20188736, 0.19752675, 0.19306361, 0.18850741,\n",
" 0.18386759, 0.1791536 , 0.17437491, 0.16954096, 0.16466122,\n",
" 0.15974512, 0.15480213, 0.1498417 , 0.14487328, 0.13990632],\n",
" [0.36875 , 0.36681313, 0.36457201, 0.36203594, 0.35921422,\n",
" 0.35611615, 0.35275103, 0.34912817, 0.34525687, 0.34114643,\n",
" 0.33680614, 0.33224532, 0.32747327, 0.32249928, 0.31733266,\n",
" 0.31198271, 0.30645873, 0.30077002, 0.29492589, 0.28893564,\n",
" 0.28280857, 0.27655397, 0.27018116, 0.26369944, 0.2571181 ,\n",
" 0.25044645, 0.24369378, 0.23686941, 0.22998264, 0.22304275],\n",
" [0.4875 , 0.48506084, 0.48226695, 0.47912748, 0.47565158,\n",
" 0.47184841, 0.46772711, 0.46329683, 0.45856672, 0.45354594,\n",
" 0.44824363, 0.44266894, 0.43683103, 0.43073904, 0.42440212,\n",
" 0.41782942, 0.4110301 , 0.4040133 , 0.39678818, 0.38936388,\n",
" 0.38174955, 0.37395435, 0.36598742, 0.35785791, 0.34957498,\n",
" 0.34114777, 0.33258544, 0.32389713, 0.315092 , 0.30617919],\n",
" [0.60625 , 0.60330854, 0.59996188, 0.59621902, 0.59208895,\n",
" 0.58758067, 0.58270318, 0.57746549, 0.57187658, 0.56594545,\n",
" 0.55968112, 0.55309256, 0.54618879, 0.53897879, 0.53147158,\n",
" 0.52367614, 0.51560147, 0.50725658, 0.49865046, 0.48979211,\n",
" 0.48069053, 0.47135472, 0.46179367, 0.45201638, 0.44203186,\n",
" 0.4318491 , 0.42147709, 0.41092485, 0.40020136, 0.38931562],\n",
" [0.725 , 0.72155625, 0.71765682, 0.71331056, 0.70852631,\n",
" 0.70331293, 0.69767926, 0.69163414, 0.68518643, 0.67834497,\n",
" 0.6711186 , 0.66351618, 0.65554655, 0.64721855, 0.63854104,\n",
" 0.62952285, 0.62017284, 0.61049986, 0.60051274, 0.59022035,\n",
" 0.57963151, 0.56875509, 0.55759992, 0.54617486, 0.53448874,\n",
" 0.52255042, 0.51036875, 0.49795257, 0.48531072, 0.47245205]])}, 'samples': {'t': array([0. , 0.03275862, 0.06551724, 0.09827586, 0.13103448,\n",
" 0.1637931 , 0.19655172, 0.22931034, 0.26206897, 0.29482759,\n",
" 0.32758621, 0.36034483, 0.39310345, 0.42586207, 0.45862069,\n",
" 0.49137931, 0.52413793, 0.55689655, 0.58965517, 0.62241379,\n",
" 0.65517241, 0.68793103, 0.72068966, 0.75344828, 0.7862069 ,\n",
" 0.81896552, 0.85172414, 0.88448276, 0.91724138, 0.95 ]), 'x': array([0. , 0.2375, 0.475 , 0.7125, 0.95 ])}}\n"
]
}
],
"source": [
"print(job_2.result())"
]
},
{
"cell_type": "markdown",
"id": "18f148bf",
"metadata": {},
"source": [
"\n",
"\n",
"## Fase 3: Confronta le prestazioni dell'algoritmo\n",
"\n",
"È possibile confrontare il processo di convergenza della nostra soluzione (HDES) con job\\_2 le prestazioni di un algoritmo e risolutore di reti neurali informate dalla fisica (PINN) (vedere [l](https://arxiv.org/abs/1711.10561) 'articolo e il [repository GitHub](https://github.com/314arhaam/burger-pinn) associato).\n",
"\n",
"Nell'esempio dell'output job\\_2 di (approccio basato sul quantum), solo 13 parametri (12 parametri del circuito più 1 parametro di ridimensionamento) vengono ottimizzati con il risolutore classico.\n",
"Il processo di convergenza è il seguente:\n",
"\n",
"```\n",
"optimizers:\n",
" CMA: {'ftarget': np.float64(0.1), 'verb_disp': 10, 'maxiter': 100}\n",
" CMA: {'ftarget': np.float64(0.005), 'verb_disp': 10, 'maxiter': 20}\n",
" CMA: {'ftarget': np.float64(0.0025), 'verb_disp': 10, 'maxiter': 30}\n",
" CMA: {'ftarget': np.float64(0.0005), 'verb_disp': 10, 'maxiter': 10}\n",
"\n",
"500 shots\n",
"================== CMA =================\n",
"option: {'ftarget': np.float64(0.1), 'verb_disp': 10, 'maxiter': 100}\n",
"0/100, loss: 0.02456641\n",
"\n",
"1000 shots\n",
"================== CMA =================\n",
"option: {'ftarget': np.float64(0.005), 'verb_disp': 10, 'maxiter': 20}\n",
"0/20, loss: 0.03641833\n",
"1/20, loss: 0.02461719\n",
"2/20, loss: 0.0283689\n",
"3/20, loss: 0.009898383\n",
"4/20, loss: 0.04454522\n",
"5/20, loss: 0.007019971\n",
"6/20, loss: 0.00811147\n",
"7/20, loss: 0.01592619\n",
"8/20, loss: 0.00764708\n",
"9/20, loss: 0.01401516\n",
"10/20, loss: 0.01767467\n",
"11/20, loss: 0.01220387\n",
"\n",
"5000 shots\n",
"================== CMA =================\n",
"option: {'ftarget': np.float64(0.0025), 'verb_disp': 10, 'maxiter': 30}\n",
"0/30, loss: 0.01024792\n",
"1/30, loss: 0.004343748\n",
"2/30, loss: 0.01450951\n",
"3/30, loss: 0.008591284\n",
"4/30, loss: 0.00266414\n",
"5/30, loss: 0.007923613\n",
"6/30, loss: 0.02023853\n",
"7/30, loss: 0.01031438\n",
"8/30, loss: 0.009513116\n",
"9/30, loss: 0.008132266\n",
"10/30, loss: 0.005787766\n",
"11/30, loss: 0.00390582\n",
"\n",
"10000 shots\n",
"================== CMA =================\n",
"option: {'ftarget': np.float64(0.0005), 'verb_disp': 10, 'maxiter': 10}\n",
"0/10, loss: 0.002386168\n",
"1/10, loss: 0.004024823\n",
"2/10, loss: 0.001311999\n",
"3/10, loss: 0.003433991\n",
"4/10, loss: 0.002339664\n",
"5/10, loss: 0.002978438\n",
"6/10, loss: 0.005458391\n",
"7/10, loss: 0.002026701\n",
"8/10, loss: 0.00207467\n",
"9/10, loss: 0.001947627\n",
"final_loss: 0.00151994463476429\n",
"\n",
"```\n",
"\n",
"Ciò significa che una perdita inferiore 0.0015 può essere raggiunta dopo 28 iterazioni e ottimizzando solo alcuni parametri classici.\n",
"\n",
"Ora possiamo confrontare lo stesso risultato con la soluzione PINN con la configurazione predefinita suggerita dal documento utilizzando un ottimizzatore basato sul gradiente. L'equivalente del nostro circuito con 13 parametri da ottimizzare è la rete neurale, che richiede almeno otto livelli di 20 neuroni e comporta quindi l'ottimizzazione di 3021 parametri.\n",
"Quindi, l'obiettivo di perdita viene raggiunto al passaggio 315, perdita: 0.0014988397.\n",
"\n",
"\n",
"\n",
"Ora, poiché vogliamo fare un confronto equo, dovremmo usare lo stesso ottimizzatore in entrambi i casi.\n",
"Il numero minimo di iterazioni che abbiamo trovato per 12 livelli di 20 neuroni = 4701 parametri:\n",
"\n",
"```\n",
"(10_w,20)-aCMA-ES (mu_w=5.9,w_1=27%) in dimension 4701 (seed=351961)\n",
"Iterat #Fevals function value axis ratio sigma min&max std t[m:s]\n",
" 1 20 5.398521572351456e-02 1.0e+00 9.98e-03 1e-02 1e-02 0:02.3\n",
" 2 40 5.444650724530220e-02 1.0e+00 9.97e-03 1e-02 1e-02 0:05.1\n",
" 3 60 4.447407275438309e-02 1.0e+00 9.95e-03 1e-02 1e-02 0:08.2\n",
" 4 80 2.068969979882240e-02 1.0e+00 9.94e-03 1e-02 1e-02 0:11.7\n",
" 6 120 1.028892211616039e-02 1.0e+00 9.91e-03 1e-02 1e-02 0:20.1\n",
" 7 140 5.140972323715687e-03 1.0e+00 9.90e-03 1e-02 1e-02 0:25.4\n",
" 9 180 3.811701666563749e-03 1.0e+00 9.87e-03 1e-02 1e-02 0:37.4\n",
" 10 200 3.189878538250923e-03 1.0e+00 9.85e-03 1e-02 1e-02 0:44.2\n",
" 12 240 2.547040116041899e-03 1.0e+00 9.83e-03 1e-02 1e-02 0:59.7\n",
" 14 280 2.166548743844032e-03 1.0e+00 9.80e-03 1e-02 1e-02 1:18.0\n",
" 15 300 1.783065614290535e-03 1.0e+00 9.79e-03 1e-02 1e-02 1:28.4\n",
" 16 320 2.045844215899706e-03 1.0e+00 9.78e-03 1e-02 1e-02 1:39.8\n",
"Stopping early: loss 0.001405 <= target 0.0015\n",
"CMA-ES finished. Best loss: 0.001404788694344461\n",
"```\n",
"\n",
"È possibile fare lo stesso con i dati provenienti da job\\_2 e tracciare un confronto con la soluzione PINN.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1c468600",
"metadata": {},
"outputs": [],
"source": [
"# check the loss function and compare between the two approaches\n",
"print(job_2.logs())"
]
},
{
"cell_type": "markdown",
"id": "50b94af2",
"metadata": {},
"source": [
"\n",
"\n",
"## Passaggio 4: Utilizzare il risultato\n",
"\n",
"Con la vostra soluzione, potete ora scegliere cosa farne. Di seguito viene mostrato come tracciare il risultato.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fe0a7d02",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"solution = job.result()\n",
"\n",
"# Plot the solution of the second simulation job_2\n",
"_ = plt.figure()\n",
"ax = plt.axes(projection=\"3d\")\n",
"\n",
"# plot the solution using the 3d plotting capabilities of pyplot\n",
"t, x = np.meshgrid(solution[\"samples\"][\"t\"], solution[\"samples\"][\"x\"])\n",
"ax.plot_surface(\n",
" t,\n",
" x,\n",
" solution[\"functions\"][\"u\"],\n",
" edgecolor=\"royalblue\",\n",
" lw=0.25,\n",
" rstride=26,\n",
" cstride=26,\n",
" alpha=0.3,\n",
")\n",
"ax.scatter(t, x, solution, marker=\".\")\n",
"ax.set(xlabel=\"t\", ylabel=\"x\", zlabel=\"u(t,x)\")\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "058ab2d8",
"metadata": {},
"source": [
"Si noti la differenza di condizioni iniziali per il secondo run e il suo effetto sul risultato:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6dab21c9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"solution_2 = job_2.result()\n",
"\n",
"# Plot the solution of the second simulation job_2\n",
"_ = plt.figure()\n",
"ax = plt.axes(projection=\"3d\")\n",
"\n",
"# plot the solution using the 3d plotting capabilities of pyplot\n",
"t, x = np.meshgrid(solution_2[\"samples\"][\"t\"], solution_2[\"samples\"][\"x\"])\n",
"ax.plot_surface(\n",
" t,\n",
" x,\n",
" solution_2[\"functions\"][\"u\"],\n",
" edgecolor=\"royalblue\",\n",
" lw=0.25,\n",
" rstride=26,\n",
" cstride=26,\n",
" alpha=0.3,\n",
")\n",
"ax.scatter(t, x, solution_2, marker=\".\")\n",
"ax.set(xlabel=\"t\", ylabel=\"x\", zlabel=\"u(t,x)\")\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "2cb5785c",
"metadata": {},
"source": [
"\n",
"\n",
"## Sondaggio tutorial\n",
"\n",
"Dedicate un minuto a fornire un feedback su questa esercitazione. Le vostre indicazioni ci aiuteranno a migliorare la nostra offerta di contenuti e l'esperienza degli utenti:\n",
"\n",
"[Collegamento al sondaggio](https://your.feedback.ibm.com/jfe/form/SV_3BLFkNVEuh0QBWm)\n",
"\n"
]
},
{
"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"
},
"hours": 1.5,
"qpuSeconds": 3000
},
"nbformat": 4,
"nbformat_minor": 5
}