curso
Optimizar con Pyomo: Guía completa paso a paso
La optimización es una herramienta fundamental utilizada en diversas industrias y disciplinas para tomar las mejores decisiones posibles dentro de unas limitaciones dadas. Ya se trate de minimizar costes en una cadena de suministro, maximizar la eficiencia en sistemas energéticos o encontrar los parámetros óptimos en modelos de aprendizaje automático, las técnicas de optimización son esenciales.
Python, conocido por su sencillez y versatilidad, ofrece potentes bibliotecas para problemas de optimización. Entre ellas, Pyomo destaca como una biblioteca completa y flexible que permite a los usuarios definir y resolver modelos de optimización complejos sin problemas.
En este tutorial, exploraremos Pyomo desde cero. Lo cubriremos todo, desde la instalación y configuración de los solucionadores hasta la formulación y resolución de diferentes problemas de optimización.
Exploración de soluciones factibles en programación lineal. Imagen del autor.
¿Qué es Pyomo?
Pyomo es una biblioteca de código abierto para construir y resolver modelos de optimización utilizando Python. Te permite definir modelos de optimización de forma matemáticamente rigurosa y sintácticamente intuitiva para los programadores de Python. Admite una amplia gama de tipos de problemas, incluidos:
- Programación lineal (PL): LP consiste en optimizar una función objetivo lineal sujeta a restricciones lineales de igualdad y desigualdad. Se utiliza mucho para problemas de asignación de recursos, programación y planificación financiera.
- Programación no lineal (PNL): PNL se ocupa de optimizar una función objetivo no lineal con restricciones no lineales. Suele utilizarse en ingeniería y economía para sistemas más complejos en los que las relaciones no son lineales.
- Programación entera mixta (PIM): MIP implica problemas de optimización en los que algunas variables están restringidas a ser enteras, mientras que otras pueden ser continuas. Esto es útil en escenarios como el diseño de la cadena de suministro o la programación de proyectos, donde las decisiones pueden ser discretas (por ejemplo, activar/desactivar).
- Programación estocástica: La programación estocástica aborda problemas de optimización en los que algunos elementos son inciertos y se modelan como variables aleatorias. Se aplica comúnmente en finanzas y gestión de la cadena de suministro para optimizar las decisiones bajo incertidumbre.
- Optimización dinámica: La optimización dinámica fse centra en la optimización de variables de decisión a lo largo del tiempo, normalmente en sistemas que evolucionan dinámicamente. Se utiliza en campos como el control de procesos, la robótica y la economía para gestionar procesos dependientes del tiempo.
Características de Pyomo
Ahora que entendemos mejor Pyomo, repasemos algunas de sus características más importantes.
Flexibilidad y extensibilidad
La flexibilidad de Pyomo proviene de su capacidad para modelar relaciones complejas utilizando construcciones estándar de Python. Se integra con varios solucionadores comerciales y de código abierto, lo que facilita la resolución de muchos problemas de optimización.
Sintaxis pitónica
Los modelos de Pyomo se construyen en Python y se escriben utilizando la sintaxis estándar de Python. Esto hace que la curva de aprendizaje sea suave para quienes estén familiarizados con Python y te permite utilizar las amplias bibliotecas de Python en tus modelos.
Comunidad y documentación sólidas
Pyomo cuenta con una sólida comunidad de usuarios y una completa documentación, que incluye ejemplos y tutoriales para ayudar a usuarios de todos los niveles.
Casos de uso de Pyomo
Pyomo tiene una amplia gama de aplicaciones en el mundo real. Aquí tienes algunas de ellas:
1. Optimización de la cadena de suministro
La optimización de la cadena de suministro implica mejorar la logística, gestionar los niveles de inventario y crear programas de producción eficientes.
Esto puede incluir minimizar los costes de transporte, optimizar la ubicación de los almacenes o equilibrar la oferta y la demanda.
Por ejemplo, una empresa puede necesitar satisfacer la demanda de sus clientes en varias regiones, minimizando al mismo tiempo los costes de envío y manteniendo los niveles de existencias en cada centro de distribución.
2. Modelización financiera
En la modelización financiera, la optimización ayuda a asignar recursos, como el capital, para maximizar los beneficios minimizando el riesgo.
Esto puede implicar la optimización de la cartera, en la que los inversores equilibran el riesgo y la recompensa seleccionando una combinación de activos sujeta a restricciones como límites presupuestarios, requisitos normativos o tolerancia al riesgo.
La modelización financiera garantiza que las estrategias financieras se alinean con los objetivos a largo plazo, al tiempo que mitigan los riesgos potenciales.
3. Sistemas energéticos
La optimización en los sistemas energéticos se centra en maximizar la eficiencia de la generación, distribución y consumo de energía.
Esto puede implicar determinar la combinación óptima de fuentes de energía (por ejemplo, renovables frente a no renovables) minimizando al mismo tiempo los costes de combustible, cumpliendo los límites de emisiones y adaptándose a la fluctuación de la demanda.
Este tipo de optimización desempeña un papel fundamental en la gestión de la red, el funcionamiento de las centrales eléctricas y la reducción del impacto medioambiental.
4. Aprendizaje automático y ciencia de datos
La optimización es fundamental para muchas tareas de aprendizaje automático y ciencia de datos, como el ajuste de hiperparámetros y la selección de características.
En el ajuste de hiperparámetros, los algoritmos de optimización ayudan a encontrar la mejor configuración del modelo para mejorar el rendimiento predictivo.
La selección de características, otra tarea crítica, consiste en identificar las características más importantes que contribuyen a la precisión de un modelo, ayudando a reducir la complejidad y a mejorar la eficacia.
Ahora que el contexto está establecido, ¡pongámonos manos a la obra y empecemos a aplicar Pyomo a algunos problemas de modelado de ejemplo!
Aprende Python desde cero
Configurar Pyomo
Antes de sumergirnos en el modelado, tenemos que configurar nuestro entorno instalando Pyomo y eligiendo un solucionador adecuado.
1. Requisitos previos
Para utilizar pyomo, debes tener Python 3.6 o superior. Pyomo se puede instalar a través de pip.
pip install pyomo
Este tutorial se ha creado utilizando pyomo versión 6.8.0
.
import pyomo
print(pyomo.__version__)
Salida:
>>> 6.8.0
2. Elegir e instalar el solucionador adecuado
En optimización, los solucionadores son esenciales, ya que son los algoritmos que encuentran la solución óptima al problema que has definido. Según el tipo de problema (lineal, no lineal, entero, etc.), son más adecuados distintos solucionadores. Pyomo es una herramienta de modelado que depende de solucionadores externos para realizar el cálculo real.
Repasemos algunos de los solucionadores más habituales.
Solucionadores de código abierto
1. GLPK (Kit de Programación Lineal GNU)
GLPK es una popular herramienta para resolver problemas de programación lineal (LP) y de programación entera mixta (MIP).
Es una opción excelente para tareas básicas de optimización lineal y se utiliza mucho en aplicaciones académicas e industriales.
Instalación
- Windows: Descarga e instala GLPK.
- macOS:
brew install glpk
- Linux:
sudo apt-get install glpk-utils
2. CBC (Rama y Corte de la Moneda)
CBC es un solucionador de código abierto para problemas de programación lineal (PL) y programación entera mixta (PIM).
Ofrece funciones avanzadas y mejor rendimiento, en algunos casos, en comparación con GLPK, lo que lo convierte en una opción sólida para tareas de optimización más complejas.
CBC puede instalarse mediante el gestor de paquetes conda.
conda install -c conda-forge coincbc
3. IPOPT (Optimizador del Punto Interior)
IPOPT es un potente solucionador diseñado para programación no lineal (PNL) a gran escala.
Es especialmente adecuado para tratar modelos complejos y no lineales, lo que lo convierte en una opción excelente para problemas que van más allá de la optimización lineal.
IPOPT puede instalarse mediante el gestor de paquetes conda.
!conda install -c conda-forge ipopt
Solucionadores comerciales
1. CPLEX
CPLEX es un solucionador de optimización de última generación que resuelve eficazmente problemas de programación lineal (LP), programación entera mixta (MIP) y programación cuadrática (QP).
Requiere una licencia de IBM, pero está disponible gratuitamente para los usuarios académicos, lo que la convierte en una opción excelente para fines educativos y de investigación.
2. Gurobi
Gurobi es un solver comercial líder conocido por su velocidad y eficacia en la resolución de problemas de LP, MIP, QP y programación no lineal (NLP).
Al igual que CPLEX, requiere una licencia, pero ofrece acceso gratuito a los usuarios académicos. Por tanto, es una herramienta estándar de la industria para la optimización avanzada.
Solucionadores de código abierto frente a comerciales
Los solucionadores de código abierto como GLPK y CBC son gratuitos y suficientes para la mayoría de las necesidades básicas de optimización. Son opciones excelentes para proyectos a pequeña escala y con fines educativos.
Sin embargo, los solucionadores comerciales como CPLEX y Gurobi suelen ofrecer un rendimiento superior, especialmente para los problemas más grandes y complejos. Estos solucionadores tienen funciones avanzadas, como el soporte mejorado de programación cuadrática y no lineal, y están optimizados para aplicaciones industriales a gran escala.
Aunque los solucionadores de código abierto pueden encargarse de muchas tareas rutinarias de optimización, los solucionadores comerciales suelen ser una mejor opción cuando se trata de requisitos más complejos y de alto rendimiento.
Ten en cuenta que los solucionadores comerciales requieren una licencia, aunque están disponibles gratuitamente para los usuarios académicos.
Veamos ahora cómo configurar un solucionador en Pyomo. En este caso utilizaré GLPK.
3. Configurar un solucionador en Pyomo
En primer lugar, asegúrate de que el ejecutable del solucionador está en el PATH de tu sistema tras la instalación.
A continuación, crea un script en Python y añade lo siguiente:
from pyomo.environ import SolverFactory
solver = SolverFactory('glpk')
Para confirmar que tanto Pyomo como tu solucionador están correctamente instalados, vamos a resolver un sencillo problema de prueba.
Problema de prueba: programa lineal simple
Objetivo: Minimizar Z=x+y
Asunto:
- x + 2y ≥ 4
- x - y ≤ 1
- x ≥ 0
- y ≥ 0
Este problema consiste en encontrar el menor valor posible de Z, que es la suma de dos variables, x e y. Sin embargo, x e y deben cumplir ciertas condiciones .
En primer lugar, cuando sumas x y dos veces y, el resultado debe ser al menos 4. En segundo lugar, x menos y debe ser menor o igual que 1. Por último, tanto x y y deben ser cero o números positivos (no pueden ser negativos).
El objetivo es encontrar valores de x y y que satisfagan estas condiciones haciendo que Z sea lo más pequeño posible.
Implementación con Pyomo:
import pyomo.environ as pyo
# Create a model
model = pyo.ConcreteModel()
# Define variables
model.x = pyo.Var(within=pyo.NonNegativeReals)
model.y = pyo.Var(within=pyo.NonNegativeReals)
# Define objective
model.obj = pyo.Objective(expr=model.x + model.y, sense=pyo.minimize)
# Define constraints
model.con1 = pyo.Constraint(expr=model.x + 2 * model.y >= 4)
model.con2 = pyo.Constraint(expr=model.x - model.y <= 1)
# Select solver
solver = pyo.SolverFactory('glpk')
# Solve the problem
result = solver.solve(model)
# Display results
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))
Si todo funciona correctamente, el resultado esperado será:
Status: ok
Termination Condition: optimal
Optimal x: 0.0
Optimal y: 2.0
Optimal Objective: 2.0
Repasemos el código anterior: En primer lugar, define dos variables, x e y, que sólo pueden tomar valores no negativos. El objetivo del modelo es minimizar la suma de x e y (x + y). El código define el solucionador como glpk
para encontrar los valores óptimos de x e y que satisfagan estas restricciones minimizando el objetivo.
Tras ejecutar el código, comprobamos que los valores óptimos de las variables son x = 0,0 e y = 2,0, que minimizan la función objetivo Z = x + y. Por tanto, el valor mínimo de la función objetivo es 2,0, que satisface las restricciones dadas.
Conceptos básicos de modelado con Pyomo
Entender cómo definir los componentes básicos de un modelo de optimización en Pyomo es necesario para plantear y resolver problemas de optimización con eficacia.
1. Definición de variables
Las variables representan las decisiones que hay que tomar en un problema de optimización. En Pyomo, las variables son las cantidades que el solucionador ajustará para optimizar la función objetivo satisfaciendo todas las restricciones.
Variables escalares
Una variable escalar es una variable única que no está indexada sobre ningún conjunto. Para definir una variable escalar en Pyomo, utilizas la clase Var
del módulo pyomo.environ
.
from pyomo.environ import Var
model.x = Var()
Primero importamos el Var
y creamos una variable x
utilizando Var()
. Esta variable no tiene límites especificados, lo que significa que puede tomar cualquier valor real a menos que el modelo la limite.
Añadir límites
Puedes restringir los valores que puede tomar una variable especificando límites. Los límites se definen como una tupla (lower_bound
, upper_bound
):
from pyomo.environ import Var
model.x = Var(bounds=(0, None))
Especificar dominios
Pyomo proporciona dominios predefinidos que puedes utilizar para especificar el tipo de valores que puede tomar una variable, como NonNegativeReals
, Integers
, o Binary
:
from pyomo.environ import Var, NonNegativeReals
model.x = Var(domain=NonNegativeReals)
Variables indexadas
Cuando se trata de múltiples variables de naturaleza similar, como variables que representan distintos periodos de tiempo o artículos, es eficaz utilizar variables indexadas. Las variables indexadas son variables que se definen sobre un conjunto.
import pyomo.environ as pyo
model.I = pyo.Set(initialize=[1, 2, 3])
model.y = pyo.Var(model.I, domain=pyo.NonNegativeReals)
Supón que estás modelando las cantidades de producción de tres productos. Puedes definir:
model.Products = pyo.Set(initialize=['A', 'B', 'C'])
model.production = pyo.Var(model.Products, domain=pyo.NonNegativeReals)
Ahora, model.production['A']
, model.production['B']
y model.production['C']
representan las cantidades de producción de los productos A, B y C, respectivamente.
2. Definición de objetivos
La función objetivo es lo que intentamos optimizar (minimizar o maximizar). Define el objetivo del modelo, como minimizar los costes o maximizar los beneficios, y suele expresarse como una ecuación matemática en la que intervienen las variables de decisión.
Se definen mediante la clase Objective
:
from pyomo.environ import ConcreteModel, Var, Objective, minimize, maximize, NonNegativeReals
# Create a model
model = ConcreteModel()
# Define variables
model.x = Var(within=NonNegativeReals)
model.y = Var(within=NonNegativeReals)
# Minimization (cost)
model.cost = Objective(expr=2 * model.x + 3 * model.y, sense=minimize)
# When Maximization profit - (can have one objective at a time)
# model.profit = Objective(expr=5 * model.x + 4 * model.y, sense=maximize)
3. Añadir restricciones
Las restricciones definen las limitaciones o requisitos del problema:
from pyomo.environ import Constraint
model.con1 = Constraint(expr=model.x + model.y >= 10)
El ejemplo anterior define una restricción en el modelo Pyomo utilizando la clase Constraint
. La restricción model.con1
especifica que la suma de las variables x e y debe ser mayor o igual que 10.
4. Parametrización de los modelos
Los parámetros son valores fijos utilizados en el modelo para representar cantidades conocidas o constantes que no cambian durante el proceso de optimización.
Ayudan a definir las relaciones entre las variables y las restricciones, proporcionando estructura al modelo mediante la incorporación de datos o supuestos del mundo real:
from pyomo.environ import Param
model.p = Param(initialize=5)
El código anterior define un parámetro p
en el modelo Pyomo utilizando la clase Param
y lo inicializa con un valor fijo de 5. El parámetro p
puede utilizarse ahora en el modelo para representar un valor constante que no cambia durante el proceso de optimización.
Ahora, ¡trabajemos en un problema de optimización de extremo a extremo!
Ejemplo Pyomo End-to-End
Veamos un ejemplo completo de resolución de un problema de optimización utilizando Pyomo. Modelaremos un escenario real en el que una fábrica produce dos productos, y el objetivo es maximizar el beneficio teniendo en cuenta las limitaciones de tiempo de la máquina.
1. Planteamiento del problema
Una fábrica produce dos productos, P1 y P2. El beneficio por unidad es:
- P1: $40
- P2: $50
Tiempo de máquina disponible:
- Máquina A: 100 horas
- Máquina B: 80 horas
- Máquina C: 90 horas
Tiempo necesario por unidad:
Producto |
Máquina A (horas) |
Máquina B (horas) |
Máquina C (horas) |
P1 |
1 |
2 |
0 |
P2 |
2 |
1 |
3 |
Objetivo: Maximiza el beneficio.
Variables de decisión:
- x₁: Unidades de P1 a producir.
- x₂: Unidades de P2 a producir.
2. Formulación matemática
Función objetivo:
Maximizar Z = 40x₁ + 50x₂
Restricciones:
- Capacidad de la máquina A: 1x₁ + 2x₂ ≤ 100
- Capacidad de la máquina B: 2x₁ + 1x₂ ≤ 80
- Capacidad de la máquina C: 3x₂ ≤ 90
- No negatividad: x₁, x₂ ≥ 0
3. Aplicación
Basándonos en el objetivo y las restricciones del problema, aquí tienes el código Python para modelarlo, de nuevo, utilizando GLPK.
# Step 1: Import Libraries
import pyomo.environ as pyo
# Step 2: Create a Concrete Model
model = pyo.ConcreteModel()
# Step 3: Define Decision Variables (Units of P1 and P2 to produce)
model.x1 = pyo.Var(within=pyo.NonNegativeReals)
model.x2 = pyo.Var(within=pyo.NonNegativeReals)
# Step 4: Define the Objective Function (Maximize profit)
model.profit = pyo.Objective(expr=40 * model.x1 + 50 * model.x2, sense=pyo.maximize)
# Step 5: Define Constraints
# Machine A capacity constraint: 1x1 + 2x2 <= 100
model.machine_a = pyo.Constraint(expr=1 * model.x1 + 2 * model.x2 <= 100)
# Machine B capacity constraint: 2x1 + 1x2 <= 80
model.machine_b = pyo.Constraint(expr=2 * model.x1 + 1 * model.x2 <= 80)
# Machine C capacity constraint: 3x2 <= 90
model.machine_c = pyo.Constraint(expr=3 * model.x2 <= 90)
# Step 6: Solve the Model using GLPK solver
solver = pyo.SolverFactory('glpk')
result = solver.solve(model)
# Step 7: Analyze Results
# Display Solver Status and Termination Condition
print('Solver Status:', result.solver.status)
print('Termination Condition:', result.solver.termination_condition)
# Get and display the optimal values for x1, x2, and the maximum profit
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}')
Salida:
>>> Solver Status: ok
>>> Termination Condition: optimal
>>> Optimal production of P1 (x1): 25.0
>>> Optimal production of P2 (x2): 30.0
>>> Maximum Profit: $2500.0
En el código anterior, definimos un modelo de optimización lineal para maximizar el beneficio de producir dos productos(P1 y P2). La función objetivo se establece para maximizar el beneficio, y cada unidad de P1 contribuye con 40 $ y cada unidad de P2 con 50 $.
Imponemos tres restricciones que representan los límites de tiempo de máquina para las Máquinas A, B y C.
Por último, utilizamos el solucionador GLPK para resolver el problema.
La respuesta final es producir 25 unidades de P1 y 30 unidades de P2, donde nuestro beneficio máximo será de 2.500 $..
Funciones avanzadas de Pyomo
En la sección anterior, vimos lo fácil que es implementar un problema de optimización de extremo a extremo con Pyomo. Sin embargo, la mayoría de los problemas de la vida real no son sencillos de resolver.
En esta sección, te presento algunas funciones avanzadas que puedes utilizar para resolver situaciones más complejas.
1. Optimización no lineal
La optimización no lineal minimiza o maximiza una función objetivo no lineal sujeta a restricciones no lineales. Veamos un ejemplo en el que minimizamos la suma de las diferencias al cuadrado sujetas a una restricción circular.
Planteamiento del problema
Minimiza el objetivo: Z = (x - 1)² + (y - 2)²
Sujeto a:
- x² + y² ≤ 4
- x, y ≥ 0
En Pyomo, podemos definir las variables de decisión x e y con límites de 0 para garantizar la no negatividad. La función objetivo se escribe como la suma de las diferencias al cuadrado de puntos concretos, y la restricción garantiza que la solución se encuentra dentro de un círculo de radio 2.
En este caso, el solucionador IPOPT es adecuado por su capacidad de resolución de problemas de optimización no lineal:
import pyomo.environ as pyo
model = pyo.ConcreteModel()
# Define variables with lower bounds
model.x = pyo.Var(bounds=(0, None))
model.y = pyo.Var(bounds=(0, None))
# Objective function: minimize (x - 1)² + (y - 2)²
model.obj = pyo.Objective(expr=(model.x - 1)**2 + (model.y - 2)**2, sense=pyo.minimize)
# Constraint: x² + y² ≤ 4 (circle of radius 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. Programación entera mixta (PIM)
La programación mixta entera se utiliza cuando algunas variables de decisión son enteras (a menudo binarias) mientras que otras son continuas. Es valioso para problemas de toma de decisiones como la ubicación de instalaciones y la planificación de la producción.
Planteamiento del problema
Una empresa debe decidir si abre almacenes en los emplazamientos A, B y C. El objetivo es minimizar el coste total, que incluye los costes fijos de apertura de almacenes y los costes de transporte.
Empezamos inicializando los datos, incluidos los costes fijos de apertura de almacenes, los costes de transporte, los límites de capacidad y la demanda total:
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()
# Binary variable: 1 if warehouse is open, 0 otherwise
model.y = pyo.Var(locations, domain=pyo.Binary)
# Continuous variable: amount of goods transported
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
)
# Demand constraint
model.demand = pyo.Constraint(expr=sum(model.x[i] for i in locations) >= Demand)
# Capacity constraints
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))
El modelo incluye dos tipos de variables de decisión: una variable binaria y
que representa si un almacén está abierto (1 si está abierto, 0 en caso contrario), y una variable continua x
que representa la cantidad de mercancías transportadas desde cada almacén.
La función objetivo suma los costes fijos y los costes de transporte de cada almacén y minimiza el total. Las restricciones garantizan que el total de mercancías transportadas satisfaga la demanda y que no se supere la capacidad de cada almacén si está abierto.
3. Gestión de objetivos múltiples
A veces, los problemas de optimización implican múltiples objetivos que pueden entrar en conflicto, como maximizar el beneficio minimizando el impacto medioambiental. Un enfoque habitual es elmétodo de suma ponderada , en el que a cada objetivo se le asigna un peso para equilibrar su importancia.
Planteamiento del problema
Nuestro objetivo es maximizar los beneficios minimizando el impacto medioambiental:
- Beneficios: Z₁ = 3x + 5y
- Impacto medioambiental: Z₂ = 2x + y
Podemos combinar estos objetivos utilizando ponderaciones w1=0.6
, w2=0.4
, donde el objetivo total se convierte en una suma ponderada:
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
)
En este objetivo combinado, maximizamos el beneficio a la vez que minimizamos el impacto medioambiental ajustando las ponderaciones.
4. Utilizar fuentes de datos externas
Cuando se trabaja con grandes conjuntos de datos, a menudo resulta útil importar datos de fuentes externas, como archivos CSV. Pyomo funciona bien con Pandas para leer y utilizar datos externos.
Podemos leer un archivo CSV utilizando Pandas y utilizar los datos para inicializar conjuntos y parámetros en nuestro modelo:
import pandas as pd
data = pd.read_csv('parameters.csv')
# Define set from CSV data
model.I = pyo.Set(initialize=data['index'].unique())
# Define parameter initialized from CSV data
param_dict = data.set_index('index')['value'].to_dict()
model.param = pyo.Param(model.I, initialize=param_dict)
Consejos y buenas prácticas para utilizar Pyomo
Cuando trabajes con Pyomo, es importante que tus modelos sean eficientes, estén bien documentados y sean fáciles de solucionar.
1. Depuración y resolución de problemas
Al construir modelos de optimización en Pyomo, es habitual encontrarse con problemas como soluciones no factibles, fallos del solucionador o resultados incorrectos. Aquí tienes algunas buenas prácticas para depurar:
- Comprueba las limitaciones: Revisa tus restricciones si tu modelo no produce una solución factible. Las restricciones estrictas pueden hacer que un problema sea inviable. Utiliza el método
.display()
de Pyomo para imprimir los valores de las variables y restricciones y comprobar que se comportan como se espera. - Salida del solucionador: Activa los registros detallados del solucionador pasando
tee=True
al llamar al métodosolve()
. Esto puede proporcionar una idea de dónde puede tener problemas el solucionador, como variables no limitadas o inviabilidad. - Prueba primero los modelos sencillos: Cuando se trate de modelos complejos, prueba una versión simplificada. Esto puede ayudar a aislar posibles problemas sin la sobrecarga de un modelo totalmente especificado.
La resolución de problemas es mucho más fácil si la enfocas sistemáticamente, analizando las restricciones, la función objetivo y la retroalimentación del solucionador.
2. Eficacia del modelado
Los problemas de optimización pueden volverse costosos computacionalmente a medida que aumenta el tamaño del modelo. Para garantizar un modelado eficaz, ten en cuenta los siguientes consejos:
- Utiliza la dispersión: Evita pasar por índices innecesarios al definir restricciones u objetivos. Aprovechar la dispersión en tu problema reduce el tiempo de cálculo.
- Variables binarias frente a continuas: Siempre que sea posible, reduce el número de variables binarias o enteras. Las variables continuas son más fáciles de manejar para los solucionadores, lo que conduce a soluciones más rápidas.
- Formulación de restricciones: Mantén las restricciones lo más sencillas posible, tanto en su forma matemática como en su aplicación. Evita las no linealidades innecesarias y descompone las restricciones complejas en otras más pequeñas y manejables.
Los modelos eficientes resuelven más rápido y son más fáciles de depurar y mantener.
3. Documentación y mantenimiento
Mantener modelos Pyomo bien documentados es una buena práctica para su uso y colaboración a largo plazo. Una buena documentación también facilita la revisión y actualización de los modelos a lo largo del tiempo:
- Utiliza comentarios en línea: Añade siempre comentarios para explicar la finalidad de las variables, las restricciones y la función objetivo. Esto es especialmente importante en los modelos de optimización, donde la lógica puede no ser inmediatamente obvia.
- Modulariza tu código: Divide tu modelo en secciones lógicas o incluso en funciones separadas. Este enfoque modular puede mejorar la legibilidad y facilitar la depuración y modificación de partes concretas del modelo.
- Sigue los cambios del modelo: Guarda un historial de versiones de tu modelo, sobre todo si evoluciona. Utiliza herramientas de control de versiones como Git para realizar un seguimiento de los cambios y asegurarte de que cualquier actualización o mejora pueda rastrearse.
Una documentación adecuada y un código estructurado harán que tus modelos Pyomo sean más accesibles para futuros colaboradores y más fáciles de escalar o modificar a medida que evolucionen tus requisitos.
Conclusión
Pyomo es una herramienta potente y flexible para construir y resolver modelos de optimización en Python. A lo largo de este tutorial, hemos explorado cómo Pyomo permite a los usuarios modelar diversos problemas de optimización, desde la programación lineal hasta la programación no lineal y la programación entera mixta.
Con su sintaxis fácil de usar y su integración con los solucionadores, Pyomo hace que formular y resolver problemas de optimización del mundo real sea accesible tanto para principiantes como para usuarios avanzados.
Si estás interesado en aprender más sobre cómo resolver problemas del mundo real con optimización, ¡consulta el curso gratuito Introducción a la Optimización en Python en DataCamp!
Conviértete en Desarrollador Python
Preguntas frecuentes
¿Para qué sirve Pyomo?
Pyomo es una biblioteca Python de código abierto que se utiliza para definir y resolver problemas complejos de optimización, incluida la programación lineal, no lineal y mixta entera.
¿Cómo instalo Pyomo y sus solucionadores?
Puedes instalar Pyomo utilizando pip install pyomo
. Los solucionadores como GLPK y CBC pueden instalarse mediante gestores de paquetes como Homebrew, apt-get o Conda.
¿Qué tipos de problemas de optimización puede resolver Pyomo?
Pyomo admite una amplia gama de problemas de optimización, como la Programación Lineal (LP), la Programación No Lineal (NLP), la Programación de Números Mixtos (MIP) y la Programación Estocástica.
¿Puedo utilizar Pyomo para aplicaciones del mundo real, como la optimización de la cadena de suministro?
Sí, Pyomo se utiliza ampliamente para aplicaciones del mundo real, como la optimización de la cadena de suministro, la modelización financiera, la optimización de sistemas energéticos y tareas de aprendizaje automático.
¿Cuál es la diferencia entre los solucionadores de código abierto y los comerciales en Pyomo?
Los solucionadores de código abierto como GLPK y CBC son gratuitos y suficientes para muchos problemas, mientras que los solucionadores comerciales como Gurobi y CPLEX ofrecen un mayor rendimiento y funciones avanzadas para tareas de optimización más complejas y a gran escala.
¡Aprende más sobre Python con estos cursos!
curso
Introducción a la Estadística en Python
curso
Análisis Exploratorio de Datos en Python
tutorial
Optimización en Python: Técnicas, Paquetes y Buenas Prácticas
tutorial
Tutorial sobre el uso de XGBoost en Python

Bekhruz Tuychiev
16 min
tutorial
Tutorial del Optimizador Adam: Intuición e implementación en Python
tutorial
Tutorial sobre la ejecución de scripts de Python en Power BI
tutorial