curso
Otimizando com o Pyomo: Um guia passo a passo completo
A otimização é uma ferramenta fundamental usada em vários setores e disciplinas para tomar as melhores decisões possíveis dentro de determinadas restrições. Seja para minimizar os custos em uma cadeia de suprimentos, maximizar a eficiência em sistemas de energia ou encontrar os parâmetros ideais em modelos de aprendizado de máquina, as técnicas de otimização são essenciais.
O Python, conhecido por sua simplicidade e versatilidade, oferece bibliotecas poderosas para problemas de otimização. Entre eles, o Pyomo se destaca como uma biblioteca abrangente e flexível que permite aos usuários definir e resolver modelos de otimização complexos sem problemas.
Neste tutorial, exploraremos o Pyomo desde o início. Cobriremos tudo, desde a instalação e a configuração de solucionadores até a formulação e a solução de diferentes problemas de otimização!
Explorando soluções viáveis em programação linear. Imagem do autor.
O que é Pyomo?
Pyomo é uma biblioteca de código aberto para criar e resolver modelos de otimização usando Python. Ele permite que você defina modelos de otimização de uma forma matematicamente rigorosa e sintaticamente intuitiva para programadores Python. Ele oferece suporte a uma ampla variedade de tipos de problemas, incluindo:
- Programação linear (LP): O LP envolve a otimização de uma função objetiva linear sujeita a restrições lineares de igualdade e desigualdade. É amplamente utilizado para problemas de alocação de recursos, programação e planejamento financeiro.
- Programação não linear (PNL): NLP trata da otimização de uma função objetiva não linear com restrições não lineares. É frequentemente usado em engenharia e economia para sistemas mais complexos em que as relações não são lineares.
- Programação inteira mista (MIP): O MIP envolve problemas de otimização em que algumas variáveis são restritas a números inteiros, enquanto outras podem ser contínuas. Isso é útil em cenários como o design da cadeia de suprimentos ou a programação de projetos, em que as decisões podem ser discretas (por exemplo, ligar/desligar).
- Programação estocástica: Programação estocástica aborda problemas de otimização em que alguns elementos são incertos e modelados como variáveis aleatórias. É comumente aplicado em finanças e gerenciamento da cadeia de suprimentos para otimizar decisões sob incerteza.
- Otimização dinâmica: A otimização dinâmica fse concentra na otimização de variáveis de decisão ao longo do tempo, geralmente envolvendo sistemas em evolução dinâmica. Ele é usado em áreas como controle de processos, robótica e economia para gerenciar processos dependentes do tempo.
Recursos do Pyomo
Agora que entendemos melhor o Pyomo, vamos analisar alguns de seus recursos mais importantes.
Flexibilidade e extensibilidade
A flexibilidade do Pyomo vem de sua capacidade de modelar relacionamentos complexos usando construções padrão do Python. Ele se integra a vários solucionadores comerciais e de código aberto, facilitando a solução de muitos problemas de otimização.
Sintaxe pitônica
Os modelos Pyomo são criados em Python e escritos usando a sintaxe padrão do Python. Isso torna a curva de aprendizado mais suave para quem está familiarizado com o Python e permite que você use as extensas bibliotecas do Python em seus modelos.
Comunidade e documentação sólidas
O Pyomo tem uma comunidade de usuários robusta e uma documentação abrangente, que inclui exemplos e tutoriais para ajudar os usuários em todos os níveis.
Casos de uso do Pyomo
O Pyomo tem uma ampla gama de aplicações no mundo real. Aqui estão alguns deles:
1. Otimização da cadeia de suprimentos
A otimização da cadeia de suprimentos envolve o aprimoramento da logística, o gerenciamento dos níveis de estoque e a criação de programações de produção eficientes.
Isso pode incluir a minimização dos custos de transporte, a otimização dos locais de armazenamento ou o equilíbrio entre oferta e demanda.
Por exemplo, uma empresa pode precisar atender à demanda dos clientes em várias regiões, minimizando os custos de remessa e mantendo os níveis de estoque em cada centro de distribuição.
2. Modelagem financeira
Na modelagem financeira, a otimização ajuda a alocar recursos, como capital, para maximizar os retornos e minimizar os riscos.
Isso pode envolver a otimização do portfólio, em que os investidores equilibram o risco e a recompensa selecionando uma combinação de ativos sujeita a restrições como limites orçamentários, requisitos regulatórios ou tolerância a riscos.
A modelagem financeira garante que as estratégias financeiras se alinhem às metas de longo prazo e, ao mesmo tempo, reduzam os riscos potenciais.
3. Sistemas de energia
A otimização em sistemas de energia se concentra em maximizar a eficiência da geração, distribuição e consumo de energia.
Isso pode envolver a determinação da combinação ideal de fontes de energia (por exemplo, renováveis versus não renováveis), minimizando os custos de combustível, atendendo aos limites de emissão e adaptando-se à demanda flutuante.
Esse tipo de otimização desempenha um papel central no gerenciamento da rede, nas operações da usina de energia e na redução dos impactos ambientais.
4. Aprendizado de máquina e ciência de dados
A otimização é fundamental para muitas tarefas de aprendizado de máquina e ciência de dados, como o ajuste de hiperparâmetros e a seleção de recursos.
No ajuste de hiperparâmetros, os algoritmos de otimização ajudam a encontrar a melhor configuração de modelo para melhorar o desempenho da previsão.
A seleção de recursos, outra tarefa essencial, envolve a identificação dos recursos mais importantes que contribuem para a precisão de um modelo, ajudando a reduzir a complexidade e aumentar a eficiência.
Agora que o contexto está definido, vamos colocar a mão na massa e começar a aplicar o Pyomo em alguns exemplos de problemas de modelagem!
Aprenda Python do zero
Configurando o Pyomo
Antes de mergulharmos na modelagem, precisamos configurar nosso ambiente instalando o Pyomo e escolhendo um solucionador apropriado.
1. Pré-requisitos
Para usar o pyomo, você deve ter o Python 3.6 ou superior. O Pyomo pode ser instalado por meio do pip.
pip install pyomo
Este tutorial foi criado usando a versão do pyomo 6.8.0
.
import pyomo
print(pyomo.__version__)
Saída:
>>> 6.8.0
2. Escolhendo e instalando o solver correto
Na otimização, os solucionadores são essenciais, pois são os algoritmos que encontram a solução ideal para o problema que você definiu. Diferentes solucionadores são mais adequados, dependendo do tipo de problema (por exemplo, linear, não linear, inteiro). O Pyomo é uma ferramenta de modelagem que depende de solucionadores externos para realizar o cálculo real.
Vamos analisar alguns dos solucionadores mais comuns.
Solucionadores de código aberto
1. GLPK (Kit de Programação Linear GNU)
GLPK é uma ferramenta popular para resolver problemas de programação linear (LP) e programação inteira mista (MIP).
É uma excelente opção para tarefas básicas de otimização linear e é amplamente utilizado em aplicações acadêmicas e industriais.
Instalação
- Windows: Baixe e instale o GLPK.
- macOS:
brew install glpk
- Linux:
sudo apt-get install glpk-utils
2. CBC (Coin-or Branch and Cut)
CBC é um solucionador de código aberto para problemas de programação linear (LP) e programação inteira mista (MIP).
Ele oferece recursos avançados e melhor desempenho, em alguns casos, em comparação com o GLPK, o que o torna uma boa opção para tarefas de otimização mais complexas.
O CBC pode ser instalado por meio do gerenciador de pacotes conda.
conda install -c conda-forge coincbc
3. IPOPT (Interior Point OPTimizer)
IPOPT é um solucionador avançado projetado para problemas de programação não linear (PNL) em grande escala. programação não linear (PNL) em larga escala.
Ele é particularmente adequado para lidar com modelos complexos e não lineares, o que o torna uma excelente opção para problemas que vão além da otimização linear.
O IPOPT pode ser instalado por meio do gerenciador de pacotes conda.
!conda install -c conda-forge ipopt
Solucionadores comerciais
1. CPLEX
CPLEX é um solucionador de otimização de última geração que lida com eficiência com problemas de programação linear (LP), programação inteira mista (MIP) e programação quadrática (QP).
Ele requer uma licença da IBM, mas está disponível gratuitamente para usuários acadêmicos, o que o torna uma excelente opção para fins educacionais e de pesquisa.
2. Gurobi
Gurobi é um solucionador comercial líder conhecido por sua velocidade e eficiência na solução de problemas de LP, MIP, QP e programação não linear (NLP).
Como o CPLEX, ele requer uma licença, mas oferece acesso gratuito a usuários acadêmicos. Portanto, é uma ferramenta padrão do setor para otimização avançada.
Solucionadores de código aberto vs. comerciais
Os solucionadores de código aberto, como GLPK e CBC, são gratuitos e suficientes para a maioria das necessidades básicas de otimização. Eles são excelentes opções para projetos de menor escala e para fins educacionais.
No entanto, os solucionadores comerciais, como o CPLEX e o Gurobi, geralmente oferecem desempenho superior, especialmente para problemas maiores e mais complexos. Esses solucionadores têm recursos avançados, incluindo suporte aprimorado à programação quadrática e não linear, e são otimizados para aplicações industriais de larga escala.
Embora os solucionadores de código aberto possam lidar com muitas tarefas rotineiras de otimização, os solucionadores comerciais geralmente são a melhor opção quando se trata de requisitos mais complexos e de alto desempenho.
Lembre-se de que os solucionadores comerciais exigem uma licença, embora estejam disponíveis gratuitamente para usuários acadêmicos.
Agora, vamos ver como você pode configurar um solucionador no Pyomo. Nesse caso, usarei o GLPK.
3. Configuração de um solucionador no Pyomo
Primeiro, certifique-se de que o executável do solver esteja no PATH do sistema após a instalação.
Em seguida, crie um script Python e adicione o seguinte:
from pyomo.environ import SolverFactory
solver = SolverFactory('glpk')
Para confirmar que o Pyomo e o solver estão instalados corretamente, vamos resolver um problema de teste simples.
Problema de teste: programa linear simples
Objetivo: Minimizar Z=x+y
Assunto para:
- x + 2y ≥ 4
- x - y ≤ 1
- x ≥ 0
- y ≥ 0
Este problema consiste em encontrar o menor valor possível de Z, que é a soma de duas variáveis, x e y. No entanto, x e y devem atender a determinadas condições .
Primeiro, quando você adiciona x e duas vezes y, o resultado deve ser pelo menos 4. Segundo, x menos y deve ser menor ou igual a 1. Por fim, ambos x e y devem ser zero ou números positivos (não podem ser negativos).
O objetivo é encontrar valores de x e y que satisfaçam essas condições, fazendo com que Z tão pequeno quanto possível.
Implementação usando 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))
Se tudo estiver funcionando corretamente, o resultado esperado será:
Status: ok
Termination Condition: optimal
Optimal x: 0.0
Optimal y: 2.0
Optimal Objective: 2.0
Vamos examinar o código acima: Primeiro, ele define duas variáveis, x e y, que só podem assumir valores não negativos. O objetivo do modelo é minimizar a soma de x e y (x + y). O código define o solucionador como glpk
para encontrar os valores ideais de x e y que satisfaçam essas restrições e minimizem o objetivo.
Depois de executar o código, descobrimos que os valores ideais para as variáveis são x = 0,0 e y = 2,0, que minimizam a função objetiva Z = x + y. Portanto, o valor mínimo da função objetiva é 2,0, o que satisfaz as restrições fornecidas.
Noções básicas de modelagem com Pyomo
É necessário que você entenda como definir os componentes básicos de um modelo de otimização no Pyomo para configurar e resolver problemas de otimização de forma eficaz.
1. Definição de variáveis
As variáveis representam as decisões que precisam ser tomadas em um problema de otimização. No Pyomo, as variáveis são as quantidades que o solucionador ajustará para otimizar a função objetiva e, ao mesmo tempo, satisfazer todas as restrições.
Variáveis escalares
Uma variável escalar é uma variável única que não é indexada em nenhum conjunto. Para definir uma variável escalar no Pyomo, você usa a classe Var
do módulo pyomo.environ
.
from pyomo.environ import Var
model.x = Var()
Primeiro, importamos o site Var
e criamos uma variável x
usando Var()
. Essa variável não tem limites especificados, o que significa que ela pode assumir qualquer valor real, a menos que haja outra restrição no modelo.
Adição de limites
Você pode restringir os valores que uma variável pode assumir especificando os limites. Os limites são definidos como uma tupla (lower_bound
, upper_bound
):
from pyomo.environ import Var
model.x = Var(bounds=(0, None))
Especificação de domínios
O Pyomo fornece domínios predefinidos que você pode usar para especificar o tipo de valores que uma variável pode assumir, como NonNegativeReals
, Integers
, ou Binary
:
from pyomo.environ import Var, NonNegativeReals
model.x = Var(domain=NonNegativeReals)
Variáveis indexadas
Ao lidar com várias variáveis de natureza semelhante, como variáveis que representam diferentes períodos de tempo ou itens, é eficiente usar variáveis indexadas. As variáveis indexadas são variáveis definidas em um conjunto.
import pyomo.environ as pyo
model.I = pyo.Set(initialize=[1, 2, 3])
model.y = pyo.Var(model.I, domain=pyo.NonNegativeReals)
Suponha que você esteja modelando as quantidades de produção de três produtos. Você pode definir:
model.Products = pyo.Set(initialize=['A', 'B', 'C'])
model.production = pyo.Var(model.Products, domain=pyo.NonNegativeReals)
Agora, model.production['A']
, model.production['B']
e model.production['C']
representam as quantidades de produção dos produtos A, B e C, respectivamente.
2. Definição de objetivos
A função objetivo é o que estamos tentando otimizar (minimizar ou maximizar). Ele define a meta do modelo, como minimizar os custos ou maximizar os lucros, e é normalmente expresso como uma equação matemática que envolve as variáveis de decisão.
Eles são definidos usando a classe 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. Adição de restrições
As restrições definem as limitações ou os requisitos do problema:
from pyomo.environ import Constraint
model.con1 = Constraint(expr=model.x + model.y >= 10)
O exemplo acima define uma restrição no modelo Pyomo usando a classe Constraint
. A restrição model.con1
especifica que a soma das variáveis x e y deve ser maior ou igual a 10.
4. Parametrização de modelos
Os parâmetros são valores fixos usados no modelo para representar quantidades conhecidas ou constantes que não se alteram durante o processo de otimização.
Eles ajudam a definir as relações entre variáveis e restrições, fornecendo estrutura ao modelo por meio da incorporação de dados ou suposições do mundo real:
from pyomo.environ import Param
model.p = Param(initialize=5)
O código acima define um parâmetro p
no modelo Pyomo usando a classe Param
e o inicializa com um valor fixo de 5. O parâmetro p
agora pode ser usado no modelo para representar um valor constante que não se altera durante o processo de otimização.
Agora, vamos trabalhar em um problema de otimização de ponta a ponta!
Exemplo de Pyomo de ponta a ponta
Vamos ver um exemplo de ponta a ponta da solução de um problema de otimização usando o Pyomo. Vamos modelar um cenário do mundo real em que uma fábrica produz dois produtos e o objetivo é maximizar o lucro, considerando as restrições de tempo de máquina.
1. Declaração do problema
Uma fábrica produz dois produtos, P1 e P2. O lucro por unidade é:
- P1: $40
- P2: $50
Tempo de máquina disponível:
- Máquina A: 100 horas
- Máquina B: 80 horas
- Máquina C: 90 horas
Tempo necessário por unidade:
Produto |
Máquina A (horas) |
Máquina B (horas) |
Máquina C (horas) |
P1 |
1 |
2 |
0 |
P2 |
2 |
1 |
3 |
Objetivo: Maximizar o lucro.
Variáveis de decisão:
- x₁: Unidades de P1 a serem produzidas.
- x₂: Unidades de P2 a serem produzidas.
2. Formulação matemática
Função objetiva:
Maximizar Z = 40x₁ + 50x₂
Restrições:
- Capacidade da máquina A: 1x₁ + 2x₂ ≤ 100
- Capacidade da máquina B: 2x₁ + 1x₂ ≤ 80
- Capacidade da máquina C: 3x₂ ≤ 90
- Não negatividade: x₁, x₂ ≥ 0
3. Implementação
Com base no objetivo e nas restrições do problema, aqui está o código Python para modelá-lo, novamente, usando o 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}')
Saída:
>>> Solver Status: ok
>>> Termination Condition: optimal
>>> Optimal production of P1 (x1): 25.0
>>> Optimal production of P2 (x2): 30.0
>>> Maximum Profit: $2500.0
No código acima, definimos um modelo de otimização linear para maximizar o lucro da produção de dois produtos(P1 e P2). A função objetivo é definida para maximizar o lucro, com cada unidade de P1 contribuindo com US$ 40 e cada unidade de P2 com US$ 50.
Impomos três restrições que representam os limites de tempo da máquina para as máquinas A, B e C.
Por fim, usamos o solucionador GLPK para resolver o problema.
A resposta final é produzir 25 unidades de P1 e 30 unidades de P2, onde nosso lucro máximo será de US$ 2.500.
Recursos avançados no Pyomo
Na seção anterior, vimos como é fácil implementar um problema de otimização de ponta a ponta com o Pyomo. No entanto, a maioria dos problemas da vida real não é simples de resolver.
Nesta seção, apresento alguns recursos avançados que você pode usar para resolver cenários mais complexos.
1. Otimização não linear
A otimização não linear minimiza ou maximiza uma função objetiva não linear sujeita a restrições não lineares. Vejamos um exemplo em que minimizamos a soma das diferenças quadradas sujeitas a uma restrição circular.
Declaração do problema
Minimize o objetivo: Z = (x - 1)² + (y - 2)²
Sujeito a:
- x² + y² ≤ 4
- x, y ≥ 0
No Pyomo, podemos definir as variáveis de decisão x e y com limites de 0 para garantir a não negatividade. A função objetiva é escrita como a soma das diferenças quadráticas de pontos específicos, e a restrição garante que a solução esteja dentro de um círculo de raio 2.
Nesse caso, o solucionador IPOPT é adequado por sua capacidade de solução de problemas de otimização não linear:
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. Programação inteira mista (MIP)
A programação mista de números inteiros é usada quando algumas variáveis de decisão são inteiras (geralmente binárias) e outras são contínuas. É valioso para problemas de tomada de decisão, como localização de instalações e planejamento de produção.
Declaração do problema
Uma empresa precisa decidir se abrirá armazéns nos locais A, B e C. A meta é minimizar o custo total, que inclui custos fixos de abertura de depósitos e custos de transporte.
Começamos inicializando os dados, incluindo os custos fixos de abertura de armazéns, custos de transporte, limites de capacidade e 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))
O modelo inclui dois tipos de variáveis de decisão: uma variável binária y
que representa se um depósito está aberto (1 se aberto, 0 caso contrário) e uma variável contínua x
que representa a quantidade de mercadorias transportadas de cada depósito.
A função objetiva soma os custos fixos e os custos de transporte de cada depósito e minimiza o total. As restrições garantem que o total de mercadorias transportadas atenda à demanda e que a capacidade de cada depósito não seja excedida se ele estiver aberto.
3. Lidar com vários objetivos
Às vezes, os problemas de otimização envolvem vários objetivos que podem entrar em conflito, como maximizar o lucro e minimizar o impacto ambiental. Uma abordagem comum é ométodo de soma ponderada , em que cada objetivo recebe um peso para equilibrar sua importância.
Declaração do problema
Nosso objetivo é maximizar o lucro e, ao mesmo tempo, minimizar o impacto ambiental:
- Lucro: Z₁ = 3x + 5y
- Impacto ambiental: Z₂ = 2x + y
Podemos combinar esses objetivos usando pesos w1=0.6
, w2=0.4
, em que o objetivo total se torna uma soma 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
)
Nesse objetivo combinado, maximizamos o lucro e, ao mesmo tempo, minimizamos o impacto ambiental ajustando os pesos.
4. Uso de fontes de dados externas
Ao lidar com grandes conjuntos de dados, a importação de dados de fontes externas, como arquivos CSV, costuma ser útil. O Pyomo funciona bem com o Pandas para ler e usar dados externos.
Podemos ler um arquivo CSV usando o Pandas e usar os dados para inicializar conjuntos e parâmetros em nosso 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)
Dicas e práticas recomendadas para usar o Pyomo
Ao trabalhar com o Pyomo, é importante que você mantenha seus modelos eficientes, bem documentados e fáceis de solucionar problemas.
1. Depuração e solução de problemas
Ao criar modelos de otimização no Pyomo, é comum você encontrar problemas como soluções inviáveis, falhas no solver ou resultados incorretos. Aqui estão algumas práticas recomendadas para depuração:
- Verifique as restrições: Revise suas restrições se o modelo não estiver produzindo uma solução viável. Restrições rígidas podem tornar um problema inviável. Use o método
.display()
do Pyomo para imprimir os valores das variáveis e restrições para verificar se estão se comportando conforme o esperado. - Saída do solucionador: Ative os registros detalhados do solver passando
tee=True
ao chamar o métodosolve()
. Isso pode fornecer informações sobre onde o solucionador pode ter dificuldades, como variáveis não limitadas ou inviabilidade. - Teste modelos simples primeiro: Ao lidar com modelos complexos, teste uma versão simplificada. Isso pode ajudar a isolar possíveis problemas sem a sobrecarga de um modelo totalmente especificado.
A solução de problemas é muito mais fácil se você a abordar sistematicamente, analisando as restrições, a função objetiva e o feedback do solucionador.
2. Eficiência de modelagem
Os problemas de otimização podem se tornar computacionalmente caros à medida que o tamanho do modelo aumenta. Para garantir uma modelagem eficiente, considere as dicas a seguir:
- Use a esparsidade: Evite fazer loop em índices desnecessários ao definir restrições ou objetivos. Aproveitar a esparsidade em seu problema reduz o tempo de computação.
- Variáveis binárias vs. contínuas: Sempre que possível, reduza o número de variáveis binárias ou inteiras. As variáveis contínuas são mais fáceis de serem manipuladas pelos solucionadores, levando a soluções mais rápidas.
- Formulação de restrições: Mantenha as restrições o mais simples possível, tanto na forma matemática quanto na implementação. Evite não linearidades desnecessárias e divida as restrições complexas em restrições menores e gerenciáveis.
Modelos eficientes resolvem mais rapidamente e são mais fáceis de depurar e manter.
3. Documentação e manutenção
A manutenção de modelos Pyomo bem documentados é uma boa prática para uso e colaboração de longo prazo. Uma boa documentação também facilita a revisão e a atualização dos modelos ao longo do tempo:
- Use comentários em linha: Sempre adicione comentários para explicar a finalidade das variáveis, restrições e função objetiva. Isso é especialmente importante em modelos de otimização em que a lógica pode não ser imediatamente óbvia.
- Modularize seu código: Divida seu modelo em seções lógicas ou até mesmo em funções separadas. Essa abordagem modular pode melhorar a legibilidade e facilitar a depuração e a modificação de partes específicas do modelo.
- Acompanhe as alterações do modelo: Mantenha um histórico de versões do seu modelo, especialmente se ele estiver evoluindo. Use ferramentas de controle de versão como o Git para acompanhar as alterações e garantir que todas as atualizações ou melhorias possam ser rastreadas.
A documentação adequada e o código estruturado tornarão seus modelos Pyomo mais acessíveis a futuros colaboradores e mais fáceis de dimensionar ou modificar à medida que os requisitos evoluírem.
Conclusão
O Pyomo é uma ferramenta avançada e flexível para criar e resolver modelos de otimização em Python. Ao longo deste tutorial, exploramos como o Pyomo permite que os usuários modelem vários problemas de otimização, desde a programação linear até a programação não linear e mista de números inteiros.
Com sua sintaxe amigável e integração com solucionadores, o Pyomo torna a formulação e a solução de problemas de otimização do mundo real acessíveis a usuários iniciantes e avançados.
Se você estiver interessado em aprender mais sobre como resolver problemas do mundo real com otimização, confira o curso gratuito Introdução à otimização em Python no DataCamp!
Torne-se um desenvolvedor Python
Perguntas frequentes
Para que o Pyomo é usado?
Pyomo é uma biblioteca Python de código aberto usada para definir e solucionar problemas complexos de otimização, incluindo programação linear, não linear e mista de números inteiros.
Como faço para instalar o Pyomo e seus solucionadores?
Você pode instalar o Pyomo usando pip install pyomo
. Solucionadores como GLPK e CBC podem ser instalados por meio de gerenciadores de pacotes como Homebrew, apt-get ou Conda.
Que tipos de problemas de otimização o Pyomo pode resolver?
O Pyomo oferece suporte a uma ampla gama de problemas de otimização, incluindo Programação Linear (LP), Programação Não Linear (NLP), Programação Misto-Inteira (MIP) e Programação Estocástica.
Posso usar o Pyomo para aplicações do mundo real, como otimização da cadeia de suprimentos?
Sim, o Pyomo é amplamente usado em aplicações do mundo real, como otimização da cadeia de suprimentos, modelagem financeira, otimização de sistemas de energia e tarefas de aprendizado de máquina.
Qual é a diferença entre os solucionadores de código aberto e os comerciais no Pyomo?
Os solucionadores de código aberto, como o GLPK e o CBC, são gratuitos e suficientes para muitos problemas, enquanto os solucionadores comerciais, como o Gurobi e o CPLEX, oferecem desempenho aprimorado e recursos avançados para tarefas de otimização mais complexas e em grande escala.
Aprenda mais sobre Python com estes cursos!
curso
Introdução à estatística em Python
curso
Análise exploratória de dados em Python

blog
6 práticas recomendadas de Python para um código melhor
tutorial
Otimização em Python: Técnicas, pacotes e práticas recomendadas
tutorial
Tutorial do Adam Optimizer: Intuição e implementação em Python
tutorial
Exponentes em Python: Um guia abrangente para iniciantes

Satyam Tripathi
9 min
tutorial
Tutorial de execução de scripts Python no Power BI
tutorial