Ottimizzare con Pyomo: una guida completa passo passo

Impostare Pyomo

Prima di immergerci nella modellazione, dobbiamo impostare il nostro ambiente installando Pyomo e scegliendo un risolutore appropriato.

1. Requisiti

Per utilizzare Pyomo, è necessario avere Python 3.6 o superiore. Pyomo può essere installato tramite pip.

pip install pyomo

Questo tutorial è creato utilizzando la versione di Pyomo 6.8.0.

import pyomo
print(pyomo.__version__)

Output:

>>> 6.8.0

2. Scelta e installazione del corretto solutore

Nell’ottimizzazione, i solutori sono essenziali in quanto sono gli algoritmi che trovano la soluzione ottimale del problema che hai definito. differenti solutori sono migliori secondo il tipo di problema (ad esempio, lineare, non lineare, intero). Pyomo è uno strumento di modellazione che si affida a solutori esterni per condurre le computazioni effettive.

Ricordiamo alcuni dei solutori più comuni.

Soliti solutori open-source

1. GLPK (GNU Linear Programming Kit)

GLPK è uno strumento popolare per la risoluzione di problemi di programmazione lineare (LP) e di programmazione lineare mista (MIP). 

È una scelta eccellente per compiti di ottimizzazione lineare di base e viene ampiamente utilizzato nelle applicazioni accademiche e industriali.

Installazione

• Windows: Scarica e installa GLPK.
• macOS: 

brew install glpk

• Linux: 

sudo apt-get install glpk-utils

2. CBC (Coin-or Branch and Cut)

CBC è un risolutore open-source per i problemi di programmazione lineare (LP) e di programmazione mista intera (MIP). 

Offre funzionalità avanzate e migliori prestazioni in alcuni casi rispetto a GLPK, rendendolo una scelta robusta per compiti di ottimizzazione più complessi. 

CBC può essere installato tramite il package manager conda.

conda install -c conda-forge coincbc

3. IPOPT (Interior Point OPTimizer)

IPOPT è un potente solutore progettato per i problemi di programmazione non lineare (NLP) a grande scala.

E’ particolarmente adatto per la gestione di modelli complessi e non lineari, rendendolo una scelta ottima per problemi oltre alla programmazione lineare.

IPOPT può essere installato tramite il package manager conda.

!conda install -c conda-forge ipopt

Solutori commerciali

1. CPLEX

CPLEX è un ottimo solutore di ottimizzazione che gestisce in maniera efficiente problemi di programmazione lineare (LP), misti interi (MIP) e di programmazione quadratica (QP).

Richiede una licenza da IBM, ma è disponibile gratuitamente per gli utenti accademici, rendendolo una scelta eccellente per scopi di ricerca e didattici.

2. Gurobi

Gurobi è un solutore commerciale di riferimento noto per la sua velocità e efficiente nell’ risoluzione di problemi LP, MIP, QP e di programmazione non lineare (NLP).

Come CPLEX, richiede una licenza ma offre un accesso gratuito agli utenti accademici. Per questo motivo, è uno strumento standard dell’industria per l’ottimizzazione avanzata.

Soluzionatori open-source contro quelli commerciali.

Solutori open-source come GLPK e CBC sono gratuiti e sufficienti per la maggior parte delle necessità di ottimizzazione di base. Sono scelte eccellenti per progetti a scala ridotta e scopi educativi.

Tuttavia, i solutori commerciali come CPLEX e Gurobi offrono di solito un migliore rendimento, specialmente per problemi più grandi e complessi. Questi solutori includono funzionalità avanzate, tra cui supporto migliorato per la programmazione quadratica e non lineare, e sono ottimizzati per applicazioni industriali a scala industriale.

Sebbene i solutori open-source siano in grado di gestire molte attività di ottimizzazione standard, i solutori commerciali sono spesso una scelta migliore quando si devono affrontare requisiti più complessi e di alto rendimento.

Tenete a mente che i solutori commerciali richiedono una licenza, anche se sono disponibili gratuitamente per gli utenti accademici.

Ora, vediamo come configurare un solutore in Pyomo. In questo caso userò GLPK.

3. Configurare un solutore in Pyomo

Prima di tutto, assicurarsi che l’esecutabile del solutore sia presente nel PATH del sistema dopo l’installazione.

Poi, creare uno script Python e aggiungere il seguente:

from pyomo.environ import SolverFactory
solver = SolverFactory('glpk')

Per confermare che entrambi Pyomo e il tuo solutore siano installati correttamente, risolviamo un semplice problema di test.

Problema di test: semplice programma lineare.

Obiettivo: MinimizzareZ=x+y

Soggetto a:

• x + 2y ≥ 4
• x – y ≤ 1
• x ≥ 0
• y ≥ 0

Questo problema riguarda la ricerca del valore più piccolo possibile di Z, che è la somma di due variabili, x e y. Tuttavia, x e y devono soddisfare certe condizioni.

Prima di tutto, quando aggiungi x e due volte y, il risultato deve essere almeno 4. In secondo luogo, x meno y deve essere minore o uguale a 1. Infine, sia x che y devono essere numeri zero o positivi (non possono essere negativi). 

L’obiettivo è trovare valori di x e y che soddisfano queste condizioni mentre rende Z il più piccolo possibile.

Implementazione usando Pyomo:

import pyomo.environ as pyo
# Crea un modello
model = pyo.ConcreteModel()
# Definisci le variabili
model.x = pyo.Var(within=pyo.NonNegativeReals)
model.y = pyo.Var(within=pyo.NonNegativeReals)
# Definisci l'obiettivo
model.obj = pyo.Objective(expr=model.x + model.y, sense=pyo.minimize)
# Definisci le limitazioni
model.con1 = pyo.Constraint(expr=model.x + 2 * model.y >= 4)
model.con2 = pyo.Constraint(expr=model.x - model.y <= 1)
# Seleziona il risolutore
solver = pyo.SolverFactory('glpk')
# Risolve il problema
result = solver.solve(model)
# Mostra i risultati
print('Status:', result.solver.status)
print('Termination Condition:', result.solver.termination_condition)
print('Optimal x:', pyo.value(model.x))
print('Optimal y:', pyo.value(model.y))
print('Optimal Objective:', pyo.value(model.obj))

Se tutto sta funzionando correttamente, l’output atteso sarà:

Status: ok
Termination Condition: optimal
Optimal x: 0.0
Optimal y: 2.0
Optimal Objective: 2.0

Passiamo ora sopra il codice sopra indicato: prima di tutto, definisce due variabili, x e y, che possono assumere solo valori non negativi. L’obiettivo del modello è minimizzare la somma di x e y (x + y). Il codice definisce il solutore come glpk per trovare i valori ottimali di x e y che soddisfano queste ipotesi mentre minimizzano l’obiettivo.

Dopo aver eseguito il codice, scopriamo che i valori ottimali per le variabili sono x = 0.0 e y = 2.0, che minimizzano la funzione obiettivo Z = x + y. Perciò, il valore minimo della funzione obiettivo è 2.0, che soddisfa le constraint date.

Elementi di base del modellismo con Pyomo

Comprendere come definire i componenti base di un modello di ottimizzazione in Pyomo è necessario per impostare e risolvere problemi di ottimizzazione in modo efficiente.

1. Definizione delle variabili

Le variabili rappresentano le decisioni da prendere in un problema di ottimizzazione. In Pyomo, le variabili sono le quantità che il solutore aggiusterà per ottimizzare l’funzione obiettivo mentre soddisfa tutte le risorse.

Variabili scalari

Una variabile scalare è una singola variabile che non è indice su alcun insieme. Per definire una variabile scalare in Pyomo, si utilizza la classe Var dal modulo pyomo.environ.

from pyomo.environ import Var
model.x = Var()

Prime di tutto importiamo la Var e creiamo una variabile x utilizzando Var(). Questa variabile non ha limiti specifici, il che significa che può assumere qualsiasi valore reale a meno che non sia diversamente limitata nel modello.

Aggiunta di limiti

Puoi limitare i valori che una variabile può assumere specificando i limiti. I limiti sono definiti come una tupla (lower_bound, upper_bound):

from pyomo.environ import Var
model.x = Var(bounds=(0, None))

Specificare domini

Pyomo fornisce domini predefiniti che puoi usare per specificare il tipo di valori che una variabile può assumere, come NonNegativeReals, Integers o Binary: 

from pyomo.environ import Var, NonNegativeReals
model.x = Var(domain=NonNegativeReals)

Variabili indice

Quando si lavora con molte variabili simili per natura, come ad esempio variabili che rappresentano periodi diversi o oggetti, è efficiente usare le variabili indice. Le variabili indice sono definite su un insieme.

import pyomo.environ as pyo
model.I = pyo.Set(initialize=[1, 2, 3])
model.y = pyo.Var(model.I, domain=pyo.NonNegativeReals)

Supponendo di modellare le quantità di produzione di tre prodotti. Puoi definire:

model.Products = pyo.Set(initialize=['A', 'B', 'C'])
model.production = pyo.Var(model.Products, domain=pyo.NonNegativeReals)

Ora, model.production['A'], model.production['B'], e model.production['C'] rappresentano le quantità di produzione per i prodotti A, B e C, rispettivamente.

2. Definiti obiettivi

La funzione obiettivo è ciò che cerchiamo di ottimizzare (minimizzare o massimizzare). Define il punto dell’esempio, come minimizzare i costi o massimizzare i profitti, e viene spesso espressa come una equazione matematica che coinvolge le variabili di decisione.

Vengono definite usando la classe Objective:

from pyomo.environ import ConcreteModel, Var, Objective, minimize, maximize, NonNegativeReals
# Crea un modello
model = ConcreteModel()
# Definisci variabili
model.x = Var(within=NonNegativeReals)
model.y = Var(within=NonNegativeReals)
# Minimizzazione (costo)
model.cost = Objective(expr=2 * model.x + 3 * model.y, sense=minimize)
# Quando massimizzazione profitto - (può avere un solo obiettivo alla volta)
# model.profit = Objective(expr=5 * model.x + 4 * model.y, sense=maximize)

3. Aggiunta di vincoli

Le costrizioni definiscono le limitazioni o i requisiti del problema:

from pyomo.environ import Constraint
model.con1 = Constraint(expr=model.x + model.y >= 10)

L’esempio precedente definisce una costrizione nel modello Pyomo utilizzando la classe Constraint. La costrizione model.con1 specifica che la somma delle variabilix e y deve essere maggiore o uguale a10.

4. Parametrizzazione modelli

I parametri sono valori fissi utilizzati nel modello per rappresentare quantità note o costanti che non cambiano durante il processo di ottimizzazione.

AIutano a definire le relazioni tra variabili e vincoli, fornendo struttura al modello attraverso l’integrazione di dati del mondo reale o assunzioni:

from pyomo.environ import Param
model.p = Param(initialize=5)

Il codice sopra definisce un parametro p nel modello Pyomo utilizzando la classe Param e lo inizializza con un valore fisso di5. Il parametro p può ora essere utilizzato nel modello per rappresentare un valore costante che non cambia durante il processo di ottimizzazione.

Ora, proviamo a lavorare ad un problema di ottimizzazione dall’inizio alla fine!

Esempio End-to-End di Pyomo

Osserviamo un esempio dall’inizio alla fine sulla risoluzione di un problema di ottimizzazione utilizzando Pyomo. Modelliamo una situazione reale in cui una fabbrica produce due prodotti, P1 e P2, e il punto nevralgico è massimizzare il profitto considerando le limitazioni del tempo di macchina.

1. Stamento del problema

Una fabbrica produce due prodotti, P1 e P2. Il profitto per unità è:

• P1: $40
• P2: 50$

Tempo macchina disponibile:

• Macchina A: 100 ore
• Macchina B: 80 ore
• Macchina C: 90 ore

Tempo richiesto per unità:

Obiettivo: Massimizzare il profitto.

Variabili di decisione:

• x₁: Unità di P1 da produrre.
• x₂: Unità di P2 da produrre.

2. Formulazione matematica

Funzione obiettivo:

Massimizzare Z = 40x₁ + 50x₂

Vincoli:

1. Capacità macchina A: 1x₁ + 2x₂ ≤ 100
2. Capacità macchina B: 2x₁ + 1x₂ ≤ 80
3. Capacità macchina C: 3x₂ ≤ 90
4. Non negatività: x₁, x₂ ≥ 0

3. Implementazione

Basandosi sull’obiettivo e sulle constranezioni del problema, ecco il codice Python per modellare la situazione, utilizzando GLPK, come detto prima.

Passo 1: Importare le Librerie
import pyomo.environ as pyo
Passo 2: Creare un Modello Concreto
model = pyo.ConcreteModel()
Passo 3: Definire le Variabili di Decisione (Unità di P1 e P2 da produrre)
model.x1 = pyo.Var(within=pyo.NonNegativeReals)
model.x2 = pyo.Var(within=pyo.NonNegativeReals)
Passo 4: Definire la Funzione Obiettivo (Massimizzare il profitto)
model.profit = pyo.Objective(expr=40 * model.x1 + 50 * model.x2, sense=pyo.maximize)
Passo 5: Definire le Convenzioni
Convenzione della Capacità Macchina A: 1x1 + 2x2 <= 100
model.machine_a = pyo.Constraint(expr=1 * model.x1 + 2 * model.x2 <= 100)
Convenzione della Capacità Macchina B: 2x1 + 1x2 <= 80
model.machine_b = pyo.Constraint(expr=2 * model.x1 + 1 * model.x2 <= 80)
Convenzione della Capacità Macchina C: 3x2 <= 90
model.machine_c = pyo.Constraint(expr=3 * model.x2 <= 90)
Passo 6: Risolvere il Modello usando il Solutore GLPK
solver = pyo.SolverFactory('glpk')
result = solver.solve(model)
Passo 7: Analizzare i Risultati
Mostrare lo Stato del Solutore e le condizioni di termine
print('Solver Status:', result.solver.status)
print('Termination Condition:', result.solver.termination_condition)
Ottenere e mostrare i valori ottimali per x1, x2, e il massimo profitto
x1_opt = pyo.value(model.x1)
x2_opt = pyo.value(model.x2)
profit_opt = pyo.value(model.profit)
print(f'Optimal production of P1 (x1): {x1_opt}')
print(f'Optimal production of P2 (x2): {x2_opt}')
print(f'Maximum Profit: ${profit_opt}')

Output:

>>> Solver Status: ok
>>> Termination Condition: optimal
>>> Optimal production of P1 (x1): 25.0
>>> Optimal production of P2 (x2): 30.0
>>> Maximum Profit: $2500.0

Nel codice sopra, definiamo un modello di ottimizzazione lineare per massimizzare il profitto dalla produzione di due prodotti (P1 e P2). L’funzione obiettivo è impostata per massimizzare il profitto, con ciascuna unità di P1 che contribuisce con 40 dollari e ciascuna unità di P2 che contribuisce con 50 dollari.

Impostiamo tre vincoli che rappresentano i limiti di tempo di macchina per le Macchine A, B e C.

Infine, usiamo il solutore GLPK per risolvere il problema.

La risposta finale è di produrre 25 unità di P1 e 30 unità di P2 dove il nostro massimo profitto sarà di 2.500 dollari.

Funzionalità avanzate in Pyomo

Nella sezione precedente abbiamo visto quanto sia semplice implementare un problema di ottimizzazione dall’inizio alla fine utilizzando Pyomo. Tuttavia, la maggior parte dei problemi reali non è facile da risolvere.

In questa sezione presento alcune funzionalità avanzate che puoi utilizzare per risolvere scenario più complessi.

1. Ottimizzazione non lineare

L’ottimizzazione non lineare minimizza o massimizza una funzione obiettivo non lineare soggetta a constraint non lineari. Consideriamo un esempio in cui minimizziamo la somma delle differenze quadrate soggetta a una constraint circolare.

Enunciato del problema

Ottieni l’obiettivo minimo:Z = (x – 1)² + (y – 2)²

Soggetto a:

• x² + y² ≤ 4
• x, y ≥ 0

In Pyomo, possiamo definire le variabili di decisione x e y con dei limiti tra 0 per garantire la non negatività. La funzione obiettivo è scritta come la somma delle differenze quadrate dai punti specifici, e la restrizione garantisce che la soluzione si trovi all’interno di un cerchio di raggio 2.

In questo caso, il solutore IPOPT è adatto per la sua capacità di risolvere problemi di ottimizzazione non lineare:

import pyomo.environ as pyo
model = pyo.ConcreteModel()
# Definisci variabili con i limiti inferiori
model.x = pyo.Var(bounds=(0, None))
model.y = pyo.Var(bounds=(0, None))
# Funzione obiettivo: minimizza (x - 1)² + (y - 2)²
model.obj = pyo.Objective(expr=(model.x - 1)**2 + (model.y - 2)**2, sense=pyo.minimize)
# Vincolo: x² + y² ≤ 4 (cerchio di raggio 2)
model.circle = pyo.Constraint(expr=model.x**2 + model.y**2 <= 4)
solver = pyo.SolverFactory('ipopt')
result = solver.solve(model)
print('Optimal x:', pyo.value(model.x))
print('Optimal y:', pyo.value(model.y))
print('Minimum Z:', pyo.value(model.obj))

2. Ottimizzazione mista intera (MIP)

L’ottimizzazione mista intera viene utilizzata quando alcune variabili decisionale sono interi (spesso binari) mentre altre sono continue. È preziosa per problemi di decisione come la localizzazione delle strutture e la pianificazione della produzione.

Stipulazione del problema

Una compagnia deve decidere se aprire magazzini in posizioni A, B, e C. L’obiettivo è minimizzare il costo totale, che include i costi fissi dell’apertura dei magazzini e i costi di trasporto.

Iniziamo impostando i dati iniziali, inclusi i costi fissi dell’apertura dei magazzini, i costi di trasporto, i limiti di capienza e la domanda totale:

locations = ['A', 'B', 'C']
FixedCost = {'A': 1000, 'B': 1200, 'C': 1500}
TransportCost = {'A': 5, 'B': 4, 'C': 6}
Capacity = {'A': 100, 'B': 80, 'C': 90}
Demand = 150
model = pyo.ConcreteModel()
# Variabile binaria: 1 se il magazzino è aperto, 0 altrimenti
model.y = pyo.Var(locations, domain=pyo.Binary)
# Variabile reale: quantità di merci trasportate
model.x = pyo.Var(locations, domain=pyo.NonNegativeReals)
model.cost = pyo.Objective(
    expr=sum(FixedCost[i] * model.y[i] + TransportCost[i] * model.x[i] for i in locations),
    sense=pyo.minimize
)
# Vincolo della domanda
model.demand = pyo.Constraint(expr=sum(model.x[i] for i in locations) >= Demand)
# Vincoli di capienza
def capacity_rule(model, i):
    return model.x[i] <= Capacity[i] * model.y[i]
model.capacity = pyo.Constraint(locations, rule=capacity_rule)
solver = pyo.SolverFactory('cbc')
result = solver.solve(model)
for i in locations:
    print(f"Warehouse {i}: Open={pyo.value(model.y[i])}, Transported={pyo.value(model.x[i])}")
print('Minimum Total Cost:', pyo.value(model.cost))

Il modello include due tipi di variabili di decisione: una variabile binaria y che rappresenta se un magazzino è aperto (1 se aperto, 0 altrimenti) e una variabile reale x che rappresenta la quantità di merci trasportate da ciascun magazzino.

L’obiettivo funzionale è costituito dalla somma dei costi fissi e dei costi di trasporto di ciascuna magazzino, e si cerca di minimizzare il totale. Le restrizioni garantiscono che il totale merci trasportati soddisfi la domanda e che la capacità di ciascun magazzino non venga superata se è aperto.

3. Gestione di obiettivi multipli

A volte, i problemi di ottimizzazione coinvolgono obiettivi multipli che potrebbero essere in conflitto, come massimizzare il profitto mentre minimizziamo l’impatto ambientale. Un approcio comune è il metodo della somma ponderata, dove ogni obiettivo è assegnato un peso per equilibrare l’importanza.

Enunciato del problema

Purpose: massimizzare il profitto minimizzando l’impatto ambientale:

• Profitto:Z₁ = 3x + 5y
• Impatto ambientale:Z₂ = 2x + y

Possiamo combinare questi obiettivi usando le pesature w1=0.6, w2=0.4, dove l’obiettivo totale diventa una somma ponderata:

w1 = 0.6
w2 = 0.4
model.obj = pyo.Objective(
    expr=w1 * (3 * model.x + 5 * model.y) - w2 * (2 * model.x + model.y),
    sense=pyo.maximize
)

In questo obiettivo combinato, massimizziamo il profitto minimizzando l’impatto ambientale modificando le pesature.

4. Utilizzo di fonti dati esterne

Quando si lavora con grandi set di dati, importare dati da fonti esterne, come file CSV, è spesso utile. Pyomo funziona bene con Pandas per la lettura e l’utilizzo di dati esterni.

Possiamo leggere un file CSV usando Pandas e utilizzare i dati per inizializzare insiemi e parametri nel nostro modello:

import pandas as pd
data = pd.read_csv('parameters.csv')
# Definisci insieme da dati CSV
model.I = pyo.Set(initialize=data['index'].unique())
# Definisci parametro inizializzato da dati CSV
param_dict = data.set_index('index')['value'].to_dict()
model.param = pyo.Param(model.I, initialize=param_dict)

Suggerimenti e Migliori Pratiche per l’Uso di Pyomo

Quando si lavora con Pyomo, è importante mantenere i vostri modelli efficienti, ben documentati e facili da risolvere problemi.

1. Debugging e risoluzione problemi

Costruendo modelli di ottimizzazione in Pyomo, è comune incontrare problemi come soluzioni infeasibili, fallimenti del solver o risultati sbagliati. Ecco alcune migliori pratiche per il debugging:

• Verifica vincoli: Se il tuo modello non sta producendo una soluzione fattibile, rivedi i tuoi vincoli. I vincoli troppo stringenti possono rendere un problema infeasibile. Usa il metodo .display() di Pyomo per stampare i valori delle variabili e dei vincoli per verificare che stiano comportandosi come atteso.
• Output del solutore: Abilita i log dettagliati del solutore passando tee=True quando viene chiamata la funzione solve(). Questo può fornire informazioni su dove il solutore potrebbe incontrare problemi, come variabili non limitate o infeasibilità.
• Testare prima modelli semplici: Quando si trattano di modelli complessi, testare una versione semplificata. Questo può aiutare ad isolare eventuali problemi senza il sovraccarico di un modello completamente specificato.

La risoluzione dei problemi è molto più semplice se si approccia sistematicamente, analizzando le limitazioni, la funzione obiettivo e la risposta del solutore.

2. Efficienza nel modellare

I problemi di ottimizzazione possono diventare computazionalmente costosi con l’aumentare dimensione del modello. Per garantire un modellaggio efficiente, considerare i seguenti consigli:

• Utilizzare la sparsity: Evitare di iterare sugli indici non necessari quando si definiscono vincoli o obiettivi. Sfruttare la sparsity nel proprio problema riduce il tempo di calcolo.
• Variabili binarie contro continue: Dove possibile, riducire il numero di variabili binarie o interi. Le variabili continue sono più semplici per i solutori, portando a soluzioni più veloci.
• Formulazione dei vincoli: Mantiene i vincoli il più semplici possibile, sia nella forma matematica che nella loro implementazione. Evita nonlinearità non necessarie e scompone i vincoli complessi in più piccoli e gestibili.

I modelli efficienti risolvono più velocemente e sono più facili da debugare e mantenere.

3. Documentazione e manutenzione

La manutenzione di modelli Pyomo ben documentati è una buona pratica per un utilizzo a lungo termine e per la collaborazione. Una buona documentazione rende anche più semplice rientrare in contatto e aggiornare i modelli nel tempo:

• Usa commenti in linea: Aggiungi sempre commenti per spiegare lo scopo delle variabili, delle limitazioni e dell’obiettivo funzione. Questo è specialmente importante nei modelli di ottimizzazione in cui la logica potrebbe non essere immediatamente chiara.
• Pianifica la modularizzazione del tuo codice: Divide il tuo modello in sezioni logiche o persino funzioni separate. Questo approcio modulare può migliorare la leggibilità e rendere più semplice la debugging e la modifica di parti specifiche del modello.
• Tieni traccia delle modifiche al modello: Mantiene una storia delle versioni del tuo modello, specialmente se evolve. Utilizza strumenti di versionamento come Git per tenere traccia delle modifiche e garantire che qualsiasi aggiornamento o miglioramento possa essere risalito indietro.

Una documentazione corretta e un codice strutturato renderanno i tuoi modelli di Pyomo più accessibili ai futuri collaboratori e renderà più semplice scalare o modificare i requisiti in base all’evoluzione.

Conclusione

Pyomo è uno strumento potente e flessibile per la costruzione e la risoluzione di modelli di ottimizzazione in Python. In questo tutorial, abbiamo esplorato come Pyomo consente agli utenti di modellare diversi problemi di ottimizzazione, dalla programmazione lineare a quella non lineare e programmazione mista a interi.

Grazie alla sua sintassi user-friendly e all’integrazione con i solver, Pyomo rende accessibile la formulazione e la risoluzione di problemi reali di ottimizzazione sia agli iniziatori che agli utenti avanzati.

Se sei interessato a imparare di più su come risolvere problemi reali con l’ottimizzazione, prova il corso gratuito Introduzione all’Ottimizzazione in Python su DataCamp!