Direkt zum Inhalt
HeimAnleitungenPython

Optimieren mit Pyomo: Eine vollständige Schritt-für-Schritt-Anleitung

Lerne, wie du mit Pyomo, einer leistungsstarken Python-Bibliothek, Optimierungsprobleme modellieren und lösen kannst. Erforsche praktische Beispiele aus der linearen und nichtlinearen Optimierung!
Aktualisierte 29. Okt. 2024  · 25 Min. lesen

Die Optimierung ist ein grundlegendes Instrument, das in verschiedenen Branchen und Disziplinen eingesetzt wird, um die bestmöglichen Entscheidungen innerhalb bestimmter Grenzen zu treffen. Ob es darum geht, die Kosten in einer Lieferkette zu minimieren, die Effizienz von Energiesystemen zu maximieren oder die optimalen Parameter für maschinelle Lernmodelle zu finden- Optimierungsverfahren sind unverzichtbar. 

Python, bekannt für seine Einfachheit und Vielseitigkeit, bietet leistungsstarke Bibliotheken für Optimierungsprobleme. Unter diesen zeichnet sich Pyomo als umfassende und flexible Bibliothek aus, mit der Nutzer komplexe Optimierungsmodelle nahtlos definieren und lösen können.

In diesem Tutorial werden wir Pyomo von Grund auf erkunden. Wir werden alles von der Installation und Einrichtung von Solvern bis hin zur Formulierung und Lösung verschiedener Optimierungsprobleme behandeln!

Eine Bildvisualisierung der machbaren Region, Einschränkungen und Eckpunkte in einem linearen Optimierungsproblem

Erforsche machbare Lösungen in der linearen Programmierung. Bild vom Autor.

Was ist Pyomo?

Pyomo ist eine Open-Source-Bibliothek zum Erstellen und Lösen von Optimierungsmodellen mit Python. Es ermöglicht dir, Optimierungsmodelle auf eine Weise zu definieren, die sowohl mathematisch streng als auch syntaktisch intuitiv für Python-Programmierer ist. Es unterstützt eine breite Palette von Problemtypen, darunter:

  1. Lineare Programmierung (LP): Bei LP geht es darum, eine lineare Zielfunktion zu optimieren, die linearen Gleichheits- und Ungleichheitsbedingungen unterliegt. Es wird häufig für Probleme bei der Ressourcenzuteilung, Terminplanung und Finanzplanung verwendet.
  2. Nichtlineare Programmierung (NLP): NLP beschäftigt sich mit der Optimierung einer nichtlinearen Zielfunktion mit nichtlinearen Nebenbedingungen. Er wird in der Technik und Wirtschaft oft für komplexere Systeme verwendet, bei denen die Beziehungen nicht linear sind.
  3. Gemischt-ganzzahlige Programmierung (MIP): Bei MIP geht es um Optimierungsprobleme, bei denen einige Variablen auf ganze Zahlen beschränkt sind, während andere kontinuierlich sein können. Dies ist in Szenarien wie der Gestaltung der Lieferkette oder der Projektplanung nützlich, wo Entscheidungen diskret sein können (z.B. ein/aus).
  4. Stochastische Programmierung: Die stochastische Programmierung befasst sich mit Optimierungsproblemen, bei denen einige Elemente unsicher sind und als Zufallsvariablen modelliert werden. Es wird häufig im Finanzwesen und im Lieferkettenmanagement eingesetzt, um Entscheidungen unter Unsicherheit zu optimieren.
  5. Dynamische Optimierung: Die dynamische Optimierungkonzentriert sich auf die Optimierung von Entscheidungsvariablen im Zeitverlauf, typischerweise bei sich dynamisch entwickelnden Systemen. Sie wird in Bereichen wie Prozesssteuerung, Robotik und Wirtschaft eingesetzt, um zeitabhängige Prozesse zu steuern.

Eigenschaften von Pyomo

Jetzt, wo wir Pyomo besser verstehen, wollen wir uns einige seiner wichtigsten Funktionen ansehen. 

Flexibilität und Erweiterbarkeit

Die Flexibilität von Pyomo beruht auf seiner Fähigkeit, komplexe Beziehungen mit Standard-Python-Konstrukten zu modellieren. Es lässt sich mit verschiedenen Open-Source- und kommerziellen Solvern integrieren, sodass viele Optimierungsprobleme einfach gelöst werden können. 

Pythonische Syntax

Pyomo-Modelle basieren auf Python und sind in der Standard-Python-Syntax geschrieben. Das macht die Lernkurve für diejenigen, die mit Python vertraut sind, sanft und ermöglicht es dir, die umfangreichen Bibliotheken von Python in deinen Modellen zu nutzen.

Starke Gemeinschaft und Dokumentation

Pyomo hat eine solide Nutzergemeinschaft und eine umfassende Dokumentation mit Beispielen und Tutorials, die Nutzern auf allen Ebenen helfen.

Anwendungsfälle für Pyomo

Pyomo hat eine breite Palette von praktischen Anwendungen. Hier sind einige von ihnen:

1. Optimierung der Lieferkette

Die Optimierung der Lieferkette umfasst die Verbesserung der Logistik, die Verwaltung der Lagerbestände und die Erstellung effizienter Produktionspläne. 

Dazu kann die Minimierung der Transportkosten, die Optimierung der Lagerstandorte oder der Ausgleich von Angebot und Nachfrage gehören. 

Ein Unternehmen muss zum Beispiel die Kundennachfrage in mehreren Regionen befriedigen und gleichzeitig die Versandkosten minimieren und die Lagerbestände in jedem Vertriebszentrum aufrechterhalten.

2. Finanzielle Modellierung

In der Finanzmodellierung hilft die Optimierung dabei, Ressourcen, wie z.B. Kapital, so zu verteilen, dass die Rendite maximiert und das Risiko minimiert wird. 

Dabei kann es sich um eine Portfolio-Optimierung handeln, bei der die Investoren Risiko und Ertrag ausbalancieren, indem sie eine Kombination von Vermögenswerten auswählen, die Beschränkungen wie Budgetgrenzen, regulatorische Anforderungen oder Risikotoleranz unterliegen. 

Die Finanzmodellierung stellt sicher, dass die Finanzstrategien mit den langfristigen Zielen übereinstimmen und gleichzeitig die potenziellen Risiken minimiert werden.

3. Energiesysteme

Bei der Optimierung von Energiesystemen geht es um die Maximierung der Effizienz von Energieerzeugung, -verteilung und -verbrauch.

Dabei kann es darum gehen, den optimalen Mix an Energiequellen (z.B. erneuerbare oder nicht-erneuerbare) zu bestimmen und gleichzeitig die Brennstoffkosten zu minimieren, Emissionsgrenzwerte einzuhalten und sich an die schwankende Nachfrage anzupassen. 

Diese Art der Optimierung spielt eine zentrale Rolle für das Netzmanagement, den Kraftwerksbetrieb und die Reduzierung der Umweltauswirkungen.

4. Maschinelles Lernen und Datenwissenschaft

Optimierung ist ein zentraler Bestandteil vieler Aufgaben im Bereich des maschinellen Lernens und der Datenwissenschaft, z. B. bei der Abstimmung von Hyperparametern und der Auswahl von Merkmalen. 

Beim Hyperparameter-Tuning helfen Optimierungsalgorithmen, die beste Modellkonfiguration zu finden, um die Vorhersageleistung zu verbessern. 

Bei der Auswahl der Merkmale, einer weiteren wichtigen Aufgabe, geht es darum, die wichtigsten Merkmale zu identifizieren, die zur Genauigkeit eines Modells beitragen, und so die Komplexität zu reduzieren und die Effizienz zu verbessern.

Jetzt, wo der Kontext klar ist, können wir selbst Hand anlegen und Pyomo auf einige Modellierungsprobleme anwenden!

Python von Grund auf lernen

Beherrsche Python für Data Science und erwerbe gefragte Fähigkeiten.
Kostenloses Lernen Beginnen

Pyomo einrichten

Bevor wir mit dem Modellieren beginnen, müssen wir unsere Umgebung einrichten, indem wir Pyomo installieren und einen geeigneten Solver auswählen.

1. Voraussetzungen

Um pyomo zu benutzen, brauchst du Python 3.6 oder höher. Pyomo kann über pip installiert werden.

pip install pyomo

Dieses Tutorial wurde mit pyomo Version 6.8.0 erstellt.

import pyomo
print(pyomo.__version__)

Ausgabe:

>>> 6.8.0

2. Den richtigen Solver auswählen und installieren

In der Optimierung sind Solver unverzichtbar, denn sie sind die Algorithmen, die die optimale Lösung für das von dir definierte Problem finden. Je nach Art des Problems (z. B. linear, nichtlinear, ganzzahlig) sind verschiedene Lösungsverfahren besser geeignet. Pyomo ist ein Modellierungswerkzeug, das auf externe Solver zurückgreift, um die eigentliche Berechnung durchzuführen.

Schauen wir uns einige der gängigsten Löser an.

Open-Source-Löser

1. GLPK (GNU Linear Programming Kit)

GLPK ist ein beliebtes Werkzeug zum Lösen von Problemen der linearen Programmierung (LP) und der gemischt-ganzzahligen Programmierung (MIP).

Sie ist eine ausgezeichnete Wahl für grundlegende lineare Optimierungsaufgaben und wird häufig in akademischen und industriellen Anwendungen eingesetzt.

Installation

brew install glpk
  • Linux: 
sudo apt-get install glpk-utils
2. CBC (Coin-or Branch and Cut)

CBC ist ein Open-Source-Löser für Probleme der linearen Programmierung (LP) und der gemischt-ganzzahligen Programmierung (MIP).

Es bietet erweiterte Funktionen und in einigen Fällen eine bessere Leistung als GLPK, was es zu einer starken Option für komplexere Optimierungsaufgaben macht. 

CBC kann über den conda Paketmanager installiert werden.

conda install -c conda-forge coincbc
3. IPOPT (Interior Point OPTimizer)

IPOPT ist ein leistungsfähiger Solver, der für große Probleme der nichtlinearen Programmierung (NLP).

Sie eignet sich besonders gut für den Umgang mit komplexen, nichtlinearen Modellen und ist damit eine ausgezeichnete Wahl für Probleme, die über die lineare Optimierung hinausgehen. 

IPOPT kann über den conda Paketmanager installiert werden.

!conda install -c conda-forge ipopt

Kommerzielle Löser

1. CPLEX

CPLEX ist ein moderner Optimierungslöser, der Probleme der linearen Programmierung (LP), der gemischt-ganzzahligen Programmierung (MIP) und der quadratischen Programmierung (QP) effizient löst.

Es erfordert eine Lizenz von IBM, ist aber für akademische Nutzer kostenlos erhältlich, was es zu einer hervorragenden Wahl für Forschungs- und Bildungszwecke macht.

2. Gurobi

Gurobi ist ein führender kommerzieller Solver, der für seine Geschwindigkeit und Effizienz bei der Lösung von LP-, MIP-, QP- und nichtlinearen Programmierproblemen (NLP) bekannt ist.

Wie CPLEX erfordert es eine Lizenz, bietet akademischen Nutzern aber kostenlosen Zugang. Damit ist es ein branchenübliches Werkzeug für fortgeschrittene Optimierung.

Open-Source vs. kommerzielle Solver

Open-Source-Solver wie GLPK und CBC sind kostenlos und für die meisten grundlegenden Optimierungsanforderungen ausreichend. Sie eignen sich hervorragend für kleinere Projekte und Bildungszwecke. 

Kommerzielle Löser wie CPLEX und Gurobi bieten jedoch in der Regel eine bessere Leistung, insbesondere bei größeren, komplexeren Problemen. Diese Solver verfügen über fortschrittliche Funktionen, einschließlich erweiterter Unterstützung für quadratische und nichtlineare Programmierung, und sind für groß angelegte industrielle Anwendungen optimiert.

Während Open-Source-Solver viele routinemäßige Optimierungsaufgaben bewältigen können, sind kommerzielle Solver oft die bessere Wahl, wenn es um komplexere, leistungsstarke Anforderungen geht. 

Bedenke, dass kommerzielle Solver lizenzpflichtig sind, obwohl sie für akademische Nutzer kostenlos erhältlich sind.

Sehen wir uns nun an, wie man einen Solver in Pyomo konfiguriert. Ich werde in diesem Fall GLPK verwenden. 

3. Einen Solver in Pyomo konfigurieren

Stelle zunächst sicher, dass sich die ausführbare Datei des Solvers nach der Installation in deinem Systempfad befindet. 

Dann erstellst du ein Python-Skript und fügst Folgendes hinzu:

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

Um sicherzustellen, dass sowohl Pyomo als auch dein Solver richtig installiert sind, lösen wir ein einfaches Testproblem.

Testaufgabe: einfaches lineares Programm

Zielsetzung: Minimiere Z=x+y

Thema ist:

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

Bei diesem Problem geht es darum, den kleinstmöglichen Wert von Zzu finden , der die Summe der beiden Variablen x und y ist . x und y müssen jedoch bestimmte Bedingungen erfüllen .

Erstens: Wenn du x und zweimal yaddierst , muss das Ergebnis mindestens 4 sein. Zweitens: x minus y muss kleiner oder gleich 1 sein. Schließlich werden sowohl x und y Null oder positive Zahlen sein (sie können nicht negativ sein).

Das Ziel ist es, Werte zu finden für x und y zu finden, die diese Bedingungen erfüllen und gleichzeitig Z so klein wie möglich ist.

Implementierung mit 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))

Wenn alles richtig funktioniert, wird die erwartete Ausgabe sein:

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

Lass uns den obigen Code durchgehen: Zunächst werden zwei Variablen definiert, x und y, die nur nicht-negative Werte annehmen können. Das Ziel des Modells ist es, die Summe von x und y (x + y) zu minimieren. Der Code definiert den Solver als glpk, um die optimalen Werte von x und y zu finden, die diese Bedingungen erfüllen und gleichzeitig das Ziel minimieren.

Nachdem wir den Code ausgeführt haben, stellen wir fest, dass die optimalen Werte für die Variablen x = 0,0 und y = 2,0sind , wodurch die Zielfunktion Z = x + y minimiert wird . Daher ist der Mindestwert der Zielfunktion 2,0, der die gegebenen Bedingungen erfüllt.

Grundlagen des Modellierens mit Pyomo

Um Optimierungsprobleme effektiv lösen zu können, musst du wissen, wie du die grundlegenden Komponenten eines Optimierungsmodells in Pyomo definieren kannst.

1. Definieren von Variablen

Variablen stehen für die Entscheidungen, die in einem Optimierungsproblem getroffen werden müssen. In Pyomo sind die Variablen die Größen, die der Solver anpasst, um die Zielfunktion zu optimieren und dabei alle Nebenbedingungen zu erfüllen.

Skalare Variablen

Eine skalare Variable ist eine einzelne Variable, die nicht über eine Menge indiziert ist. Um eine skalare Variable in Pyomo zu definieren, verwendest du die Klasse Var aus dem Modul pyomo.environ.

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

Zuerst importieren wir die Var und erstellen eine Variable x mit Var(). Diese Variable hat keine festgelegten Grenzen, d.h. sie kann jeden realen Wert annehmen, sofern das Modell keine anderen Einschränkungen vorsieht.

Hinzufügen von Grenzen

Du kannst die Werte, die eine Variable annehmen kann, einschränken, indem du Grenzen angibst. Grenzen werden als Tupel (lower_bound, upper_bound) definiert:

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

Festlegen von Domänen

Pyomo bietet vordefinierte Domains, die du verwenden kannst, um die Art der Werte zu bestimmen, die eine Variable annehmen kann, z.B. NonNegativeReals, Integers oder Binary

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

Indizierte Variablen

Wenn du mit mehreren Variablen arbeitest, die sich ähneln, z. B. Variablen, die verschiedene Zeiträume oder Gegenstände repräsentieren, ist es effizient, indizierte Variablen zu verwenden. Indexierte Variablen sind Variablen, die über eine Menge definiert sind.

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

Angenommen, du modellierst die Produktionsmengen für drei Produkte. Du kannst definieren:

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

model.production['A'], model.production['B'] und model.production['C'] stehen für die Produktionsmengen der Produkte A, B bzw. C.

2. Ziele definieren

Die Zielfunktion ist das, was wir zu optimieren (minimieren oder maximieren) versuchen. Sie definiert das Ziel des Modells, z. B. die Minimierung der Kosten oder die Maximierung des Gewinns, und wird in der Regel als mathematische Gleichung mit den Entscheidungsvariablen ausgedrückt. 

Diese werden mit der Klasse Objective definiert:

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. Hinzufügen von Beschränkungen

Constraints definieren die Grenzen oder Anforderungen des Problems:

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

Das obige Beispiel definiert eine Einschränkung im Pyomo-Modell mithilfe der Klasse Constraint. Die Bedingung model.con1 legt fest, dass die Summe der Variablen x und y größer oder gleich 10 sein muss .

4. Modelle parametrisieren

Parameter sind feste Werte, die im Modell verwendet werden, um bekannte Größen oder Konstanten darzustellen, die sich während des Optimierungsprozesses nicht ändern. 

Sie helfen dabei, die Beziehungen zwischen Variablen und Randbedingungen zu definieren und geben dem Modell Struktur, indem sie reale Daten oder Annahmen einbeziehen:

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

Der obige Code definiert einen Parameter p im Pyomo-Modell mithilfe der Klasse Param und initialisiert ihn mit einem festen Wert von 5. Der Parameter p kann nun im Modell verwendet werden, um einen konstanten Wert darzustellen, der sich während des Optimierungsprozesses nicht ändert.

Jetzt lass uns an einem End-to-End-Optimierungsproblem arbeiten!

Pyomo End-to-End Beispiel

Sehen wir uns ein End-to-End-Beispiel für die Lösung eines Optimierungsproblems mit Pyomo an. Wir werden ein reales Szenario modellieren, in dem eine Fabrik zwei Produkte herstellt und das Ziel darin besteht, den Gewinn zu maximieren, während die Maschinenzeit begrenzt ist. 

1. Problemstellung

Eine Fabrik produziert zwei Produkte, P1 und P2. Der Gewinn pro Einheit beträgt:

  • P1: $40
  • P2: $50

Maschinenzeit verfügbar:

  • Maschine A: 100 Stunden
  • Maschine B: 80 Stunden
  • Maschine C: 90 Stunden

Erforderliche Zeit pro Einheit:

Produkt

Maschine A (Stunden)

Maschine B (Stunden)

Maschine C (Stunden)

P1

1

2

0

P2

2

1

3

Zielsetzung: Maximiere den Gewinn.

Entscheidungsvariablen:

  • x₁: Einheiten von P1 zu produzieren.
  • x₂: Einheiten von P2 zu produzieren.

2. Mathematische Formulierung

Zielfunktion:

Maximiere Z = 40x₁ + 50x₂

Beschränkungen:

  1. Kapazität der Maschine A: 1x₁ + 2x₂ ≤ 100
  2. Kapazität der Maschine B: 2x₁ + 1x₂ ≤ 80
  3. Maschine C Kapazität: 3x₂ ≤ 90
  4. Nicht-Negativität: x₁, x₂ ≥ 0

3. Umsetzung

Basierend auf dem Ziel und den Einschränkungen des Problems ist hier der Python-Code, um das Problem zu modellieren, wiederum mit 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}')

Ausgabe:

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

Im obigen Code definieren wir ein lineares Optimierungsmodell, um den Gewinn aus der Produktion von zwei Produkten(P1 und P2) zu maximieren. Die Zielfunktion wird so festgelegt, dass der Gewinn maximiert wird, wobei jede Einheit von P1 einen Beitrag von $40 und jede Einheit von P2 einen Beitrag von $50 leistet.

Wir legen drei Beschränkungen fest, die die Zeitlimits für die Maschinen A, B und C darstellen. 

Schließlich verwenden wir den GLPK Solver, um das Problem zu lösen. 

Die endgültige Antwort lautet 25 Einheiten von P1 und 30 Einheiten von P2 zu produzieren, wobei unser maximaler Gewinn $2.500 beträgt.

Erweiterte Funktionen in Pyomo

Im vorigen Abschnitt haben wir gesehen, wie einfach es ist, ein durchgängiges Optimierungsproblem mit Pyomo umzusetzen. Die meisten Probleme im echten Leben sind jedoch nicht einfach zu lösen.

In diesem Abschnitt stelle ich dir einige erweiterte Funktionen vor, mit denen du komplexere Szenarien lösen kannst.

1. Nichtlineare Optimierung

Die nichtlineare Optimierung minimiert oder maximiert eine nichtlineare Zielfunktion, die nichtlinearen Nebenbedingungen unterliegt. Schauen wir uns ein Beispiel an, bei dem wir die Summe der quadratischen Differenzen unter einer Kreisbeschränkung minimieren.

Problemstellung

Minimiere das Ziel: Z = (x - 1)² + (y - 2)²

Vorbehaltlich der:

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

In Pyomo können wir die Entscheidungsvariablen x und y mit den Grenzen von 0 definieren , um die Nicht-Negativität zu gewährleisten. Die Zielfunktion wird als die Summe der quadrierten Differenzen von bestimmten Punkten geschrieben und die Nebenbedingung stellt sicher, dass die Lösung innerhalb eines Kreises mit dem Radius 2 liegt.

In diesem Fall eignet sich der IPOPT-Löser aufgrund seiner Fähigkeit, nichtlineare Optimierungsprobleme zu lösen:

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. Gemischt-ganzzahlige Programmierung (MIP)

Gemischt-ganzzahlige Programmierung wird verwendet, wenn einige Entscheidungsvariablen ganzzahlig sind (oft binär), während andere kontinuierlich sind. Sie ist wertvoll für Entscheidungsprobleme wie Standortwahl und Produktionsplanung.

Problemstellung

Ein Unternehmen muss entscheiden, ob es an den Standorten A, B und C Lagerhäuser eröffnen soll. Das Ziel ist es, die Gesamtkosten zu minimieren, zu denen auch die Fixkosten für die Eröffnung von Lagern und die Transportkosten gehören.

Wir beginnen mit der Initialisierung der Daten, einschließlich der Fixkosten für die Eröffnung von Lagern, Transportkosten, Kapazitätsgrenzen und der Gesamtnachfrage: 

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))

Das Modell enthält zwei Arten von Entscheidungsvariablen: eine binäre Variable y, die angibt, ob ein Lagerhaus geöffnet ist (1, wenn es geöffnet ist, sonst 0), und eine kontinuierliche Variable x, die die Menge der von jedem Lagerhaus transportierten Waren darstellt. 

Die Zielfunktion summiert die Fixkosten und Transportkosten jedes Lagers und minimiert die Summe. Die Beschränkungen stellen sicher, dass die insgesamt transportierten Waren der Nachfrage entsprechen und dass die Kapazität jedes Lagers nicht überschritten wird, wenn es geöffnet ist. 

3. Umgang mit mehreren Zielen

Manchmal beinhalten Optimierungsprobleme mehrere Ziele, die miteinander in Konflikt stehen können, wie z.B. die Maximierung des Gewinns bei gleichzeitiger Minimierung der Umweltauswirkungen. Ein gängiger Ansatz ist die gewichtete Summenmethode, bei der jedem Ziel ein Gewicht zugewiesen wird, um seine Bedeutung auszugleichen.

Problemstellung

Unser Ziel ist es, den Gewinn zu maximieren und gleichzeitig die Auswirkungen auf die Umwelt zu minimieren:

  • Gewinn: Z₁ = 3x + 5y
  • Auswirkungen auf die Umwelt: Z₂ = 2x + y

Wir können diese Ziele mit den Gewichten w1=0.6, w2=0.4 kombinieren, so dass das Gesamtziel eine gewichtete Summe wird:

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
)

Bei diesem kombinierten Ziel maximieren wir den Gewinn und minimieren gleichzeitig die Umweltauswirkungen, indem wir die Gewichte anpassen.

4. Externe Datenquellen nutzen

Bei großen Datenmengen ist es oft nützlich, Daten aus externen Quellen wie CSV-Dateien zu importieren. Pyomo arbeitet gut mit Pandas zusammen, um externe Daten zu lesen und zu nutzen.

Wir können eine CSV-Datei mit Pandas einlesen und die Daten verwenden, um Sets und Parameter in unserem Modell zu initialisieren:

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)

Tipps und bewährte Praktiken für die Verwendung von Pyomo

Wenn du mit Pyomo arbeitest, ist es wichtig, dass deine Modelle effizient, gut dokumentiert und leicht zu beheben sind. 

1. Fehlersuche und Fehlerbehebung

Bei der Erstellung von Optimierungsmodellen in Pyomo kommt es häufig zu Problemen wie undurchführbaren Lösungen, Fehlern im Solver oder falschen Ergebnissen. Hier sind einige Best Practices für die Fehlersuche:

  • Beschränkungen überprüfen: Überprüfe deine Randbedingungen, wenn dein Modell keine machbare Lösung ergibt. Enge Beschränkungen können ein Problem undurchführbar machen. Verwende die Methode .display() von Pyomo, um die Werte von Variablen und Beschränkungen auszudrucken und zu überprüfen, ob sie sich wie erwartet verhalten.
  • Solver-Ausgabe: Aktiviere detaillierte Solver-Protokolle, indem du tee=True beim Aufruf der Methode solve() übergibst. Dies kann Aufschluss darüber geben, wo der Solver Schwierigkeiten hat, z. B. bei unbeschränkten Variablen oder Unmöglichkeit.
  • Teste zuerst einfache Modelle: Wenn du es mit komplexen Modellen zu tun hast, teste eine vereinfachte Version. Dies kann helfen, potenzielle Probleme einzugrenzen, ohne dass der Aufwand eines vollständig spezifizierten Modells entsteht.

Die Fehlersuche ist viel einfacher, wenn du systematisch vorgehst und die Nebenbedingungen, die Zielfunktion und das Feedback des Solvers analysierst.

2. Effizienz modellieren

Optimierungsprobleme können mit zunehmender Größe des Modells sehr rechenintensiv werden. Um eine effiziente Modellierung zu gewährleisten, solltest du die folgenden Tipps beachten:

  • Verwende Sparsamkeit: Vermeide es, bei der Definition von Beschränkungen oder Zielen über unnötige Indizes zu gehen. Die Nutzung von Sparsamkeit in deinem Problem reduziert die Berechnungszeit.
  • Binäre vs. kontinuierliche Variablen: Reduziere nach Möglichkeit die Anzahl der binären oder ganzzahligen Variablen. Kontinuierliche Variablen sind für die Löser einfacher zu handhaben und führen zu schnelleren Lösungen.
  • Formulierung von Einschränkungen: Halte die Beschränkungen so einfach wie möglich, sowohl in der mathematischen Form als auch in der Umsetzung. Vermeide unnötige Nichtlinearitäten und zerlege komplexe Bedingungen in kleinere, überschaubare Bedingungen.

Effiziente Modelle lassen sich schneller lösen und sind einfacher zu debuggen und zu warten.

3. Dokumentation und Wartung

Die Pflege von gut dokumentierten Pyomo-Modellen ist eine gute Praxis für die langfristige Nutzung und Zusammenarbeit. Eine gute Dokumentation macht es auch einfacher, Modelle im Laufe der Zeit zu überarbeiten und zu aktualisieren:

  • Verwende Inline-Kommentare: Füge immer Kommentare hinzu, um den Zweck von Variablen, Nebenbedingungen und der Zielfunktion zu erklären. Das ist vor allem bei Optimierungsmodellen wichtig, bei denen die Logik vielleicht nicht sofort ersichtlich ist.
  • Modularisiere deinen Code: Gliedere dein Modell in logische Abschnitte oder sogar in einzelne Funktionen. Dieser modulare Ansatz kann die Lesbarkeit verbessern und das Debuggen und Ändern bestimmter Teile des Modells erleichtern.
  • Verfolge Modelländerungen: Führe eine Versionsgeschichte deines Modells, besonders wenn es sich weiterentwickelt. Verwende Tools zur Versionskontrolle wie Git, um Änderungen zu verfolgen und sicherzustellen, dass alle Aktualisierungen oder Verbesserungen zurückverfolgt werden können.

Eine ordentliche Dokumentation und strukturierter Code machen deine Pyomo-Modelle für zukünftige Mitarbeiter leichter zugänglich und lassen sich leichter skalieren oder ändern, wenn sich deine Anforderungen ändern.

Fazit

Pyomo ist ein leistungsstarkes und flexibles Werkzeug zum Erstellen und Lösen von Optimierungsmodellen in Python. In diesem Tutorial haben wir uns angeschaut, wie Pyomo es Nutzern ermöglicht, verschiedene Optimierungsprobleme zu modellieren, von linearer Programmierung bis hin zu nichtlinearer und gemischt-ganzzahliger Programmierung. 

Mit seiner benutzerfreundlichen Syntax und der Integration von Solvern macht Pyomo das Formulieren und Lösen von realen Optimierungsproblemen sowohl für Anfänger als auch für fortgeschrittene Benutzer zugänglich.

Wenn du mehr darüber erfahren möchtest, wie du reale Probleme mit Optimierung lösen kannst, dann schau dir den kostenlosen Kurs Introduction to Optimization in Python auf DataCamp an!

Werde ein Python-Entwickler

Erwerbe die Programmierkenntnisse, die alle Python-Entwickler/innen brauchen.

FAQs

Wofür wird Pyomo verwendet?

Pyomo ist eine Open-Source-Python-Bibliothek zur Definition und Lösung komplexer Optimierungsprobleme, einschließlich linearer, nichtlinearer und gemischt-ganzzahliger Programmierung.

Wie installiere ich Pyomo und seine Solver?

Du kannst Pyomo mit pip install pyomo installieren. Solver wie GLPK und CBC können über Paketmanager wie Homebrew, apt-get oder Conda installiert werden.

Welche Arten von Optimierungsproblemen kann Pyomo lösen?

 Pyomo unterstützt eine breite Palette von Optimierungsproblemen, darunter lineare Programmierung (LP), nichtlineare Programmierung (NLP), gemischt-ganzzahlige Programmierung (MIP) und stochastische Programmierung.

Kann ich Pyomo für reale Anwendungen wie die Optimierung der Lieferkette nutzen?

Ja, Pyomo wird häufig für reale Anwendungen wie Lieferkettenoptimierung, Finanzmodellierung, Energiesystemoptimierung und maschinelles Lernen eingesetzt.

Was ist der Unterschied zwischen Open-Source- und kommerziellen Solvern in Pyomo?

Open-Source-Solver wie GLPK und CBC sind kostenlos und für viele Probleme ausreichend, während kommerzielle Solver wie Gurobi und CPLEX eine höhere Leistung und erweiterte Funktionen für komplexere, groß angelegte Optimierungsaufgaben bieten.


Photo of Moez Ali
Author
Moez Ali
LinkedIn
Twitter

Datenwissenschaftler, Gründer und Schöpfer von PyCaret

Themen

Lerne mehr über Python mit diesen Kursen!

Zertifizierung verfügbar

Course

Einführung in Python für Entwickler

3 hr
27.3K
Beherrsche die Grundlagen der Programmierung in Python. Keine Vorkenntnisse erforderlich!
See DetailsRight Arrow
Start Course
Mehr anzeigenRight Arrow