Gurobi: Mathematische Optimierung für knifflige Probleme

Einfache Lösungsansätze und Trial-and-Error-Methoden haben Probleme, wenn die Variablen größer werden. Gurobi geht mit diesen komplexen Sachen schnell und präzise um und löst Probleme in Sekundenschnelle, die sonst Stunden dauern könnten. Das ist der Unterschied zwischen der Hoffnung auf einen machbaren Plan und dem mathematischen Nachweis, dass man den optimalen Plan hat.

Dieses Tutorial zeigt dir,wie du mit dem starken kommerziellen Solver Gurobi umgehst . Ich zeige dir, wie du die Python-Bibliothek installierst, dein erstes Modell erstellst und dich an anspruchsvollere Probleme wie gemischt-ganzzahlige Programmierung heranwagst.

Mathematische Optimierung und die Rolle von Gurobi verstehen

Bevor du Code schreibst, ist es gut zu wissen, was Optimierung eigentlich bedeutet. Dieser Kontext zeigt dir, wann du Gurobi anstelle von Standardprogrammieransätzen verwenden solltest.

Was ist mathematische Optimierung?

Mathematische Optimierung findet die beste Lösung aus allen möglichen Lösungen. Du legst fest, was „am besten“ bedeutet (Kosten minimieren, Gewinn maximieren, Zeit minimieren), was du kontrollieren kannst (Entscheidungsvariablen) und welchen Einschränkungen du unterliegst (Beschränkungen). Der Optimierer sucht nach möglichen Lösungen, um die beste zu finden.

Das ist anders als bei der traditionellen Programmierung, wo man genaue Schritte festlegt. Bei der Optimierung beschreibst du das Problem mathematisch und lässt den Solver herausfinden, wie es gelöst werden kann. Du schreibst keine „Wenn-dann“-Logik, sondern definierst Beziehungen und lässt Algorithmen die besten Werte finden.

Die Bedeutung von Gurobi in der Optimierung

Warum Gurobi so besonders ist

Gurobi ist immer einer der schnellsten kommerziellen Optimierer, die es gibt. Benchmarks zeigen oft, dass es bei großen Problemen deutlich besser abschneidet als Open-Source-Alternativen. Diese Geschwindigkeit ist wichtig, wenn du stündlich Optimierungen durchführst oder Ergebnisse innerhalb strenger Zeitvorgaben brauchst.

Anwendung in der Industrie

Firmen aus den Bereichen Logistik, Finanzen, Energie und Gesundheitswesen nutzen Gurobi für ihre Produktionssysteme. FedEx macht die Lieferwege besser, während Finanzfirmen Milliarden in Portfolios stecken. Energieunternehmen planen die Stromerzeugung. Das sind keine theoretischen Übungen, sondern Systeme, die mit echtem Geld und echten Einschränkungen arbeiten.

Lösungsfähigkeiten

Gurobi kann lineare Programmierung (LP), gemischt-ganzzahlige Programmierung (MIP), quadratische Programmierung (QP) und noch mehr. Es hat coole Algorithmen wie die gleichzeitige Optimierung, bei der mehrere Lösungsmethoden gleichzeitig laufen und die schnellste gewinnt. Du bekommst Zuverlässigkeit und Geschwindigkeit, ohne Algorithmen manuell auswählen zu müssen.

Gurobi einrichten

Die Installation von Gurobi ist echt einfach. Sobald es eingerichtet ist, läuft es super mitPython von .

Installation und Einrichtung

Herunterladen und installieren

Gehauf die Website von Gurobi und hol dir das Installationsprogramm „ ” für dein Betriebssystem. Es enthält den Optimierer, die Schnittstelle „ gurobipy “ und die Dokumentation. Starte das Installationsprogrammmit den Standardeinstellungen, es sei denn, du brauchst einen anderen Pfad.

Nach der Installation solltest du checken, ob alles funktioniert:

import gurobipy as gp
print(f"Gurobi version: {gp.__version__}")

Hier checken wir die Installation, indem wir die Versionsnummer ausdrucken. Ein erfolgreicher Ausdruck zeigt, dass deine Umgebung bereit ist.

Lizenzierungsoptionen

Für alles, was über kleine Testprobleme hinausgeht, braucht man bei Gurobi eine Lizenz. Deine Optionen:

• Kostenlose Testlizenz: 30-tägige Testphase. Frag es einfach auf der Website von Gurobi mit deiner Arbeits-E-Mail-Adresse an.
• Akademische Lizenz: Kostenlos für Lehrkräfte und Studierende. Check deine akademische E-Mail-Adresse, um uneingeschränkten Zugriff zu bekommen – ideal zum Lernen.
• Kommerzielle Lizenz: Für die Arbeit echt wichtig. Die Preise hängen von der Größe ab. Benutzergebundene Lizenzen sind für einzelne Datenwissenschaftler super, während Floating-Lizenzen Teams die gemeinsame Nutzung von Kapazitäten ermöglichen.
• Cloud-Lizenz: Pay-as-you-go. Keine Kosten im Voraus, du zahlst nur für das, was du wirklich nutzt. Nützlich für gelegentliche Optimierungsaufgaben.

Ich nutze die akademische Lizenz fürs Lernen und die kommerzielle für die Produktion. Mit der Testversion kannst du alles in Ruhe ausprobieren, bevor du dich entscheidest.

Umgebungskonfiguration

Python-Einrichtung

Gurobi läuft mit Python 3.7+. Ich empfehle, eine virtuelle Umgebung zu nutzen, um Konflikte zu vermeiden:

python -m venv gurobi_env
gurobi_env\Scripts\activate
source gurobi_env/bin/activate
pip install gurobipy

Diese Befehle richten einen sauberen Arbeitsbereich ein und laden die Bibliothek.

Jupyter Notebook-Integration

Für interaktive Entwicklung funktionieren Notebooks super mit Gurobi:

pip install jupyter
jupyter notebook
import gurobipy as gp
print("Gurobi ready!")

Dieser Code installiert Jupyter, startet den Server und macht eine kurze Überprüfung, um sicherzustellen, dass Gurobi im Notebook richtig geladen wird.

Wann man Gurobi NICHT verwenden sollte

Gurobi ist echt stark, aber nicht immer die beste Wahl.

• Einfache Probleme: Wenn du 50 Variablen und einfache lineare Einschränkungen hast,funktionieren kostenlose Solver wie scipy.optimize.linprog oder Excel Solversuper.

• Kosten: Kommerzielle Lizenzen sind teuer. Für nicht so wichtige interne Tools könnten Open-Source-Optionen wie CBC oder GLPK (über PuLP) schon reichen.

• Heuristik: Wenn du für ein Echtzeit-Spiel in Millisekunden eine „ausreichend gute“ Antwort brauchst, sind Heuristiken (wie genetische Algorithmen) oft besser als exakte Lösungsprogramme.

Benutz Gurobi, wenn die Probleme groß sind (10.000+ Variablen) oder du erweiterte Funktionen wie quadratische Nebenbedingungen brauchst.

Plattformkompatibilität

Gurobi läuft auf Windows, macOS und Linux. Cloud-Umgebungen wie AWS, Azure und Google Cloud bieten Gurobi über ihre Marktplätze an. Ich habe Gurobi-Modelle auf allen drei großen Clouds eingesetzt, ohne dass es Probleme mit der Plattform gab.

Modelle zur Gebäudeoptimierung

Nachdem du Gurobi installiert hast, lass uns dein erstes Modell erstellen. Diese Grundkonzepte gelten für jedes Problem, das du lösen wirst.

Wichtige Teile eines Optimierungsmodells

Jedes Modell hat drei wichtige Teile:

Entscheidungsvariablen

Das sind die Entscheidungen, die der Optimierer trifft. Bei der Produktionsplanung könnte das „Stückzahl von Produkt A“ und „Stückzahl von Produkt B“ sein. Du legst die Variablen fest, Gurobi gibt ihnen Werte.

Zielfunktion

Das ist dein Ziel, was du maximieren oder minimieren willst. Maximiere den Gewinn (3*product_a + 5*product_b) oder minimiere die Kosten. Du bekommst ein Ziel pro Modell.

Einschränkungen

Das sind deine Grenzen. Du kannst nicht mehr produzieren, als die Fabrikkapazität hergibt, oder mehr ausgeben, als dein Budget zulässt. Einschränkungen zeigen, welche Lösungen wirklich möglich sind.

Best Practices für die Formulierung

Benutze klare Variablennamen. Nimm statt x[1] lieber produce_product_a. Das spart dir später stundenlanges Debuggen, wie ich im Abschnitt zur Fehlerbehebung erklären werde.

Halt die Einschränkungen einfach. Wenn du komplexe Logik in kleinere, einfachere Einschränkungen aufteilst, wird dein Modell leichter zu lesen und zu debuggen.

Modern Gurobi: Die Matrix-API

Wenn du aus dem Bereich Data Science kommst, könnte dir die loop-basierte Modellierung langsam vorkommen. Gurobi 13.0+ hat jetzt eine Matrix-API, die NumPy-Arrays nutzt, wodurch das Erstellen von Modellen 10- bis 50-mal schneller geht.

So sieht ein Bäckereimodell mit Vektoren aus:

import gurobipy as gp
import numpy as np

# Data
prices = np.array([2.0, 5.0])
resources = np.array([[0.5, 2.0], [1.0, 1.0]])
limits = np.array([100.0, 80.0])

model = gp.Model("bakery_matrix")
x = model.addMVar(shape=2, name="x")

model.setObjective(prices @ x, gp.GRB.MAXIMIZE)
model.addConstr(resources @ x <= limits, name="constraints")

model.optimize()

Die Syntax „ A @ x <= b “ ist übersichtlicher und der Standard für Produktionssysteme.

Ein einfaches lineares Programmierungsmodell erstellen

Lass uns ein echtes Problem lösen: Eine Bäckerei muss entscheiden, wie viele Brote und Kuchen sie backen soll, um möglichst viel Gewinn zu machen.

Problemstellung:

- Gewinn aus Brot: 2 $ | Mehl: 0,5 kg

- Gewinn aus dem Kuchen: 5 $ | Mehl: 2 kg

- Verfügbares Mehl: 100 kg

- Ofenkapazität: 80 Artikel

Hier ist das Modell:

import gurobipy as gp
from gurobipy import GRB

model = gp.Model("bakery_optimization")

bread = model.addVar(name="bread", vtype=GRB.CONTINUOUS, lb=0)
cake = model.addVar(name="cake", vtype=GRB.CONTINUOUS, lb=0)

model.setObjective(2 * bread + 5 * cake, GRB.MAXIMIZE)

model.addConstr(0.5 * bread + 2 * cake <= 100, name="flour_limit")
model.addConstr(bread + cake <= 80, name="oven_capacity")

model.optimize()

if model.status == GRB.OPTIMAL:
    print(f"Optimal profit: ${model.objVal:.2f}")
    print(f"Bake {bread.X:.2f} loaves of bread")
    print(f"Bake {cake.X:.2f} cakes")
else:
    print("No optimal solution found")

Dieser Code startet das Modell, legt Variablen fest und setzt das Gewinnziel. Es nutzt die oben definierten Einschränkungen und findet den besten Plan.

Solver-Protokolle verstehen

Wenn du „ model.optimize() “ ausführst, erstellt Gurobi ein Protokoll. So liest du es:

Gurobi Optimizer version 13.0.0...
Presolve removed 0 rows and 0 columns
...
Explored 0 nodes (2 simplex iterations) in 0.01 seconds
Optimal objective  2.800000000e+02

• Presolve: Gurobi macht dein Problem einfacher, bevor es gelöst wird. „Entfernte Zeilen“ heißt, dass es doppelte Einschränkungen gefunden hat.
• Simplex iterations: Wie viele Schritte hat der Algorithmus gemacht? Viele kleine Probleme könnten auf Probleme bei der Formulierung hindeuten.
• Optimal objective: Dein Endergebnis (z. B. 280 $ Gewinn).
• Lücke: Bei ganzzahligen Problemen zeigt das den Unterschied zwischen der bisher besten gefundenen Lösung und der theoretisch besten.

Wenn du das Protokoll im Auge behältst, kannst du erkennen, ob ein Modell „hängen geblieben“ ist oder einfach nur hart arbeitet.

Die Konzepte hier lassen sich direkt skalieren. Egal, ob du 10 oder 10.000 Variablen hast, das Muster bleibt dasselbe.

Von Gurobi unterstützte fortgeschrittene Problemtypen

Lineare Programmierung ist nur der Anfang. Gurobi kann mit komplexen Typen umgehen, die die Feinheiten der realen Welt erfassen, einschließlich der neuen nichtkonvexen MINLP-Funktionen in Version 13.0.

Gemischte ganzzahlige lineare Programmierung

Was macht es anders?

Bei der gemischt-ganzzahligen Programmierung (MIP) können Variablen ganze Zahlen sein. Du kannst keine 0,7 Fabriken bauen, also brauchst du ganzzahlige Lösungen.

Praktische Anwendungen

Standort der Einrichtung: Ein Lager in Stadt A eröffnen? Ja (1) oder Nein (0).

Produktionsplanung: Losgrößen müssen oft ganze Zahlen sein.

Netzwerkdesign: Routing-Entscheidungen sind meistens binär. Der Verkehr fließt durch eine Verbindung oder eben nicht.

Beispiel: Standort der Einrichtung

import gurobipy as gp
from gurobipy import GRB

model = gp.Model("facility_location")

cities = ['CityA', 'CityB', 'CityC']
fixed_costs = {'CityA': 10000, 'CityB': 8000, 'CityC': 12000}

open_warehouse = model.addVars(cities, vtype=GRB.BINARY, name="open")

model.setObjective(
    gp.quicksum(fixed_costs[city] * open_warehouse[city] for city in cities),
    GRB.MINIMIZE
)

model.addConstr(gp.quicksum(open_warehouse[city] for city in cities) >= 2)

model.optimize()

print("Open warehouses in:")
for city in cities:
    if open_warehouse[city].X > 0.5:
        print(f"  {city}")

Hier verwenden wir binäre Variablen, um zu entscheiden, ob ein Lager eröffnet werden soll. Das Modell hält die Fixkosten niedrig und sorgt dafür, dass mindestens zwei Einrichtungen offen bleiben.

Quadratische und nichtlineare Programmierung

Quadratische Programmierung (QP)

Wenn dein Ziel quadratische Terme oder variable Produkte enthält, hast du ein QP. Die Portfoliooptimierung ist ein klassisches Beispiel, weil das Risiko (Varianz) quadratisch ist.

Quadratisch beschränkte Programmierung (QCP)

Beschränkungen können auch quadratisch sein. Denk mal an Probleme mit Kreisen oder gekrümmten Grenzen.

Beispiel: Portfoliooptimierung

import gurobipy as gp
from gurobipy import GRB
import numpy as np

model = gp.Model("portfolio")

assets = ['StockA', 'StockB', 'StockC']
expected_returns = [0.12, 0.18, 0.10]

covariance = np.array([
    [0.04, 0.01, 0.02],
    [0.01, 0.09, 0.03],
    [0.02, 0.03, 0.05]
])

weights = model.addVars(len(assets), name="weight", lb=0, ub=1)

model.setObjective(
    gp.quicksum(expected_returns[i] * weights[i] for i in range(len(assets))),
    GRB.MAXIMIZE
)

model.addConstr(gp.quicksum(weights[i] for i in range(len(assets))) == 1)

risk_expr = gp.quicksum(
    covariance[i][j] * weights[i] * weights[j]
    for i in range(len(assets))
    for j in range(len(assets))
)
model.addConstr(risk_expr <= 0.05, name="risk_limit")

model.optimize()

print("Optimal portfolio allocation:")
for i, asset in enumerate(assets):
    print(f"{asset}: {weights[i].X * 100:.1f}%")

Dieses Setup kümmert sich um die Optimierung des Portfolios. Es maximiert die Renditen und begrenzt gleichzeitig das Gesamtrisiko (Varianz) streng mithilfe quadratischer Beschränkungen.

Weitere unterstützte Problemtypen

Zweitordnungs-Kegelprogrammierung (SOCP)

Probleme mit geometrischen Einschränkungen, wie zum Beispiel die Definition eines Kegels oder einer kreisförmigen Grenze, gehören in diese Kategorie. Häufig in der robusten Optimierung und im technischen Design.

Gemischt-ganzzahlige quadratische Programmierung (MIQP)

Kombiniert ganzzahlige Variablen mit quadratischen Zielfunktionen oder Nebenbedingungen. Nützlich bei der diskreten Optimierung mit nichtlinearen Beziehungen.

Gurobi unterstützt alle diese Typen von Haus aus. Du musst Probleme nicht neu formulieren, um sie an einen bestimmten Solver anzupassen. Gurobi erkennt den Problemtyp automatisch und wendet die passenden Algorithmen an.

Von Gurobi unterstützte Arten von Optimierungsproblemen. Bild vom Autor.

Gurobi-Algorithmen und ihre Anwendungen

Algorithmusauswahl

Gurobi wählt die Algorithmen automatisch aus, aber es ist echt hilfreich, die Optionen zu kennen, wenn man Probleme mit langsamen Lösungen hat.

Methodenwerte:

• -1 (Standard): Lass Gurobi entscheiden

• 0: Primal Simplex (passt für die meisten LPs)

• 1: Dual-Simplex (gut, wenn man von einer unmöglichen Situation startet)

• 2: Barriere (am besten für große Modelle oder QP)

• 3: Parallel (führt mehrere Methoden aus, wählt die schnellste)

• 4: Deterministische Parallelität

• 5: Deterministischer paralleler Simplex

• PDHG (Methode erster Ordnung: Gurobi 13.0 hat auch PDHG, eine auf Gradienten basierende Methode, die super für riesige LPs ist und auf GPUs läuft.

Schau im Solver-Protokoll nach, was gelaufen ist (z. B. „Barriere gelöstes Modell ...“).

Wann sollte man „ “ überschreiben? Wenn der Standard mehrere Stunden dauert, probier mal „Barrier“ für riesige Modelle oder „Concurrent“ für Probleme, bei denen man das Ergebnis nicht vorhersagen kann.

model.Params.Method = 2
model.Params.BarConvTol = 1e-8

Das wählt die Barrier-Methode aus und macht die Toleranz enger, was bei großen oder sensiblen Datensätzen echt hilfreich ist.

Die erweiterten Funktionen von Gurobi nutzen

Sobald du die Grundlagen drauf hast, bietet Gurobi coole Tools für Probleme in Unternehmen.

Verteilte Optimierung

Bei riesigen Modellen, die auf einem einzelnen Rechner zu lange dauern, kannst du die Arbeit aufteilen. Die verteilte Optimierung von Gurobi nutzt mehrere Computer, um ein einzelnes Problem schneller zu lösen.

Du machst einen Rechner zum „Manager“ und die anderen zu „Workern“. Der Manager schickt Teile des Suchbaums an die Mitarbeiter, die sie parallel bearbeiten. Für kleine Modelle ist das echt übertrieben, aber für globale Lieferketten oder Flugplanprobleme ist es echt wichtig.

Mehrzieloptimierung

Im echten Leben gibt's selten nur ein Ziel. Du möchtest vielleicht den Gewinn maximieren und die Umweltbelastung minimieren.

Gurobi macht das so, dass du Prioritäten festlegen kannst. Du kannst ihm sagen: „Maximiere zuerst den Gewinn und minimiere dann den Abfall, ohne den Gewinn um mehr als 10 % zu verringern.“ Du kannst sie auch wiegen: Objective = 0.7 * Profit - 0.3 * Waste.

# Multi-objective example
model.setObjectiveN(profit_expr, index=0, priority=2, name="Profit")
model.setObjectiveN(waste_expr, index=1, priority=1, name="Waste")

Echtzeit-Interaktion und Rückrufe

Manchmal willst du eingreifen, während Gurobi die Lösung berechnet. Mit Callbacks kannst du benutzerdefinierten Code an bestimmten Punkten ausführen, z. B. jedes Mal, wenn eine neue Lösung gefunden wird.

Ich nutze Callbacks, um frühzeitig abzubrechen, wenn eine Lösung „gut genug“ ist, oder um eigene Heuristiken einzubauen, von denen ich weiß, dass sie für meine speziellen Daten funktionieren.

Cloud-Funktionen

Die Optimierung auf deinem Laptop reicht für die Entwicklung, aber in der Produktion braucht man oft mehr Leistung. Mit Gurobi Cloud kannst du die schwere Arbeit an AWS, Azure oder Gurobis eigene Instant Cloud abgeben. Du bezahlst nur für die Lösungszeit, was super für gelegentliche, hohe Arbeitslasten ist.

Praktische Modellierungs-Best-Practices

Effiziente Modelle zu schreiben, braucht eine gute Strategie. Hier sind ein paar Tipps, wie du deinen Code sauber und schnell halten kannst.

Strategien zur Modellformulierung

Fang einfach an und mach es nach und nach komplizierter.

Mach am ersten Tag kein Modell mit 50 Einschränkungen. Fang mit der Kernlogik an, überprüfe sie und verfeinere sie dann. Ich habe viel zu viel Zeit damit verbracht, komplizierte Modelle zu debuggen, nur um dann festzustellen, dass der Fehler in den Grundlagen lag.

Benutze aussagekräftige Namen für Variablen und Einschränkungen.

x1 = model.addVar(name="x1")
model.addConstr(x1 + x2 <= 100, name="c1")

units_produced = model.addVar(name="units_produced")
model.addConstr(
    units_produced + units_stored <= warehouse_capacity,
    name="warehouse_capacity_limit"
)

Schau dir den Unterschied an: Der zweite Block erklärt die Geschäftslogik ganz klar. Wie ich schon gesagt habe, erspart dir das jede Menge Ärger beim Debuggen.

Daten vorbereiten

Überprüfe deine Daten, bevor du mit der Modellierung anfängst. Schau mal nach, ob irgendwelche Werte fehlen oder unmögliche Einschränkungen vorliegen. Es ist echt nervig, nach drei Stunden Rechnen Datenfehler zu entdecken.

Skalier deine Daten richtig

Gurobi geht gut mit numerischer Genauigkeit um, aber extreme Werte machen Probleme. Wenn die Kosten in Millionen und die Mengen in Tausendstel angegeben sind, skalier sie auf ähnliche Größenordnungen:

# Instead of cost = 10000000 and quantity = 0.0001
# Scale to cost = 10 (in millions) and quantity = 100 (in 1/1000 units)

Numerische Probleme sind bei gut skalierten Modellen selten, bei schlecht skalierten Modellen dagegen häufig.

Überlegungen zur numerischen Stabilität

Gurobi nutzt Fließkommaarithmetik, die nicht unendlich ist. Wenn deine Einschränkung „ x <= 1000000000 ” lautet und deine Toleranz „1e-6 ” ist , kannst du komische Ergebnisse bekommen.

Vermeide Einschränkungen wie „ if y=0 then x <= 1,000,000,000 “. Nimm stattdessen die kleinste gültige Obergrenze (z. B. Gesamtmarktgröße). Engere Grenzen bedeuten schnellere und stabilere Lösungen.

Warmstarts und Modelländerungen

Man löst ein Problem selten nur einmal. Normalerweise kommen neue Daten rein (z. B. aktualisierte Nachfrage).

Anstatt das Modell komplett neu zu erstellen, probier doch mal einen Warmstartaus: . Du gibst Gurobi die vorherige Lösung als Ausgangspunkt. Da der optimale Plan von gestern wahrscheinlich dem heutigen sehr ähnlich ist, kann Gurobi einen Großteil der Sucharbeit überspringen.

# Warm start example
bread.Start = 40  # Start search assuming we bake 40 loaves

Programmierschnittstellen und Integration

Python-API von Gurobi

Wir haben „ gurobipy ” benutzt, weil es Pythonic ist. Es unterstützt Operatorüberladung (x + y <= 5) und lässt sich direkt mit pandas und NumPy verbinden. Das ist die beliebteste Art, Gurobi für die Datenwissenschaft zu nutzen.

Integration mit anderen Sprachen

Produktionssysteme laufen oft mit C++, Java oder .NET, weil das schnell ist. Gurobi hat sie alle drauf. Die Konzepte (Variablen, Einschränkungen, Ziele) sind die gleichen; nur die Syntax ist anders.

Für sprachübergreifende Arbeitsabläufe mache ich oft Prototypen in Python (schnelles Programmieren) und setze sie in C++ (schnelle Ausführung) um. Dabei nutze ich die Dateiformate von Gurobi (.mps oder .lp), um Modelle zwischen den beiden Sprachen zu verschieben.

Unterstützung für Modellierungssprachen

Gurobi lässt sich auch in spezielle Modellierungssprachen wie AMPL und GAMS oder sogar Excel einbinden.

- AMPL/GAMS: Super für rein mathematische Forscher, die keinen Software-Code schreiben wollen.

- Excel: Praktisch für schnelle Prototypen oder um Leuten aus dem Business ein Modell zu zeigen, das sie anfassen können, ohne Python installieren zu müssen.

Leistungsoptimierung und -abstimmung

Workflow optimieren

Stell nicht einfach irgendwelche Sender ein. Mach's so:

1. Messung der Basis: Mit den Standardeinstellungen ausführen, Lösungszeit notieren.

2. Leg zuerst feste Grenzen fest: Produktionssysteme brauchen TimeLimit.

3. Tausch Genauigkeit gegen Geschwindigkeit: Entspann dich nur, wenn das Geschäft es zulässt. MIPGap

4. Test-Thread-Skalierung: Mehr Threads ≠ schneller (abnehmender Ertrag nach 4–8).

# Example: Production deployment
model.Params.TimeLimit = 300  # Hard 5-min cutoff for API response
baseline_time = model.Runtime

if baseline_time > 240:  # If cutting it close
    model.Params.MIPGap = 0.02  # Accept 2% suboptimality
    # Business rationale: 2% cost increase < late delivery penalty

Leistungsbenchmarks

Benchmarks zeigen, dass Gurobi bei schwierigen MIP-Problemen immer wieder um ein Vielfaches besser abschneidet als Open-Source-Löser. Während „ scipy ” mit kleinen LPs gut klarkommt, zeigt Gurobi seine Stärke, wenn es richtig komplex wird. Auf der Website von Hans Mittelmann gibt's Vergleichstests, die die Leistung von Solvern unabhängig checken.

Fehlersuche und Fehlerbehebung

Modellunmöglichkeit

Wenn Gurobi meldet, dass das Modell nicht machbar ist, gibt's einen Konflikt zwischen deinen Einschränkungen. Keine Lösung kann alle gleichzeitig zufriedenstellen.

Finde die widersprüchlichen Einschränkungen:

model.computeIIS()
model.write("infeasible.ilp")

print("Conflicting constraints:")
for c in model.getConstrs():
    if c.IISConstr:
        print(f"  {c.ConstrName}: {c.ConstrExpr}")

Das berechnet das irreduzible inkonsistente Subsystem (IIS) und zeigt genau an, welche Einschränkungen miteinander kollidieren.

Unbegrenzte Modelle

Ein unbegrenztes Modell heißt, dass das Ziel unendlich verbessert werden kann. Zeigt normalerweise fehlende Einschränkungen an.

Check:

- Hast du alle Variablen gebunden? addVar(lb=0, ub=1000)

- Sind die Einschränkungen richtig formuliert?

- Ist die Zielfunktion richtig?

Solver-Protokolle verwenden

Aktiviere die detaillierte Protokollierung, um zu sehen, was Gurobi macht:

model.Params.OutputFlag = 1
model.Params.LogToConsole = 1
model.Params.LogFile = "gurobi.log"

Das aktiviert die ausführliche Ausgabe und speichert eine Kopie in einer lokalen Datei, sodass du einen detaillierten Verlauf des Lösungsprozesses bekommst.

Umgang mit Daten

In echten Apps kommen die Daten aus Dateien, nicht aus fest programmierten Listen.

import pandas as pd

# Load data
df = pd.read_csv("facility_costs.csv")
fixed_costs = dict(zip(df['city'], df['fixed_cost']))

# Validate BEFORE modeling
if any(c < 0 for c in fixed_costs.values()):
    raise ValueError("Costs cannot be negative")

Dieses Muster, Load-Validate-Model, verhindert versteckte Fehler.

Praktische Anwendungen von Gurobi

Theorie ist super, aber schauen wir mal, wie die Industrie das wirklich nutzt.

Optimierung der Lieferkette

Design des Verteilungsnetzes

FedEx, UPS und Amazon nutzen die Ideen aus dem Kurs „Supply Chain Analytics in Python“, um die Kosten niedrig zu halten und gleichzeitig die Lieferzusagen einzuhalten.

Wir nutzen für dieses Beispiel die Matrix-API, um die Skalierung effizient zu handhaben.

import gurobipy as gp
from gurobipy import GRB
import numpy as np

# 1. Data Generation
factories = ["F1", "F2"]
warehouses = ["W1", "W2", "W3"]
customers = ["C1", "C2", "C3", "C4"]

# Cost matrices (Factory->Warehouse, Warehouse->Customer)
transport_fw = np.array([[2.0, 4.0, 5.0], [3.0, 1.0, 6.0]])
transport_wc = np.array([
    [1.5, 2.0, 3.0, 4.0],
    [3.0, 1.0, 2.0, 2.5],
    [5.0, 4.0, 1.0, 1.5]
])

# Capacity and Demand
factory_cap = np.array([1000, 1000])
demand = np.array([300, 500, 400, 600])

try:
    with gp.Model("SupplyChain_Matrix") as model:
        # 2. Variables (Matrix Form)
        # Flow F->W and W->C
        flow_fw = model.addMVar((len(factories), len(warehouses)), name="fw")
        flow_wc = model.addMVar((len(warehouses), len(customers)), name="wc")
        
        # Binary decision: Open warehouse?
        open_w = model.addMVar(len(warehouses), vtype=GRB.BINARY, name="open")

        # 3. Objective: Minimize Transport + Fixed Costs
        fixed_cost = 5000
        obj = (transport_fw * flow_fw).sum() + \
              (transport_wc * flow_wc).sum() + \
              (fixed_cost * open_w).sum()
        model.setObjective(obj, GRB.MINIMIZE)

        # 4. Constraints
        # Factory capacity (sum rows of flow_fw <= cap)
        model.addConstr(flow_fw.sum(axis=1) <= factory_cap, name="Cap")

        # Customer demand (sum cols of flow_wc >= demand)
        model.addConstr(flow_wc.sum(axis=0) >= demand, name="Demand")

        # Flow balance: Inflow to W == Outflow from W
        model.addConstr(flow_fw.sum(axis=0) == flow_wc.sum(axis=1), name="Balance")

        # Warehouse capacity linking: Flow out <= BigM * OpenBinary
        model.addConstr(flow_wc.sum(axis=1) <= 2000 * open_w, name="Link")

        model.optimize()

        if model.Status == GRB.OPTIMAL:
            print(f"Optimal Cost: ${model.ObjVal:,.2f}")
            print(f"Open Warehouses: {open_w.X}")

except gp.GurobiError as e:
    print(f"Error: {e}")

Dieser vektorisierte Ansatz (addMVar, sum(axis=1)) kann Tausende von Variablen sofort verarbeiten und vermeidet so langsame Python-Schleifen.

Netzwerkdiagramm der Lieferkette. Bild vom Autor.

Bestandsoptimierung

Es ist echt schwierig, die Kosten für Bestellungen, Lagerhaltung und Lieferengpässe unter einen Hut zu bringen. Bei ungewisser Nachfrage wird das zu einer stochastischen Optimierung, die Gurobi über Szenario-Modellierung abdeckt.

Personaleinsatzplanung

Schichtplanung

Krankenhäuser und Callcenter müssen die Arbeitszeiten ihrer Mitarbeiter so planen, dass Personalbedarf, Arbeitsvorschriften und Präferenzen berücksichtigt werden.

Das ist reine gemischt-ganzzahlige Programmierung. Jede Aufgabe ist eine binäre Entscheidung. Ein Krankenhaus mit 100 Krankenschwestern und 50 Schichten muss 5.000 verschiedene Sachen unter einen Hut bringen.

Beispiel: Dienstplan für Krankenschwestern

import gurobipy as gp
from gurobipy import GRB

model = gp.Model("nurse_scheduling")

nurses = ['Alice', 'Bob', 'Carol', 'Dave']
shifts = ['Mon_Day', 'Mon_Night', 'Tue_Day', 'Tue_Night']
min_required = {'Mon_Day': 2, 'Mon_Night': 1, 'Tue_Day': 2, 'Tue_Night': 1}

schedule = model.addVars(nurses, shifts, vtype=GRB.BINARY, name="schedule")

model.setObjective(
    gp.quicksum(schedule[n, s] for n in nurses for s in shifts),
    GRB.MINIMIZE
)

for shift in shifts:
    model.addConstr(
        gp.quicksum(schedule[n, shift] for n in nurses) >= min_required[shift],
        name=f"min_staff_{shift}"
    )

for nurse in nurses:
    model.addConstr(
        gp.quicksum(schedule[nurse, s] for s in shifts) <= 3,
        name=f"max_shifts_{nurse}"
    )

for nurse in nurses:
    # Labor rule: 8-hour rest required between shifts
    model.addConstr(
        schedule[nurse, 'Mon_Day'] + schedule[nurse, 'Mon_Night'] <= 1,
        name=f"no_double_{nurse}_Mon"
    )
    model.addConstr(
        schedule[nurse, 'Tue_Day'] + schedule[nurse, 'Tue_Night'] <= 1,
        name=f"no_double_{nurse}_Tue"
    )

model.optimize()

print("Optimal schedule:")
for nurse in nurses:
    assigned = [s for s in shifts if schedule[nurse, s].X > 0.5]
    print(f"{nurse}: {', '.join(assigned)}")

Das modelliert das Planungsproblem mit binären Variablen. Es reduziert die Gesamtzahl der Schichten, während der Personalbedarf, die maximale Arbeitszeit und die vorgeschriebenen Ruhezeiten eingehalten werden.

Finanzportfolio-Optimierung

Risiko-Ertrags-Abwägung

Bei der Portfoliooptimierung wird die erwartete Rendite gegen das Risiko abgewogen. Das klassische Markowitz-Modell:

• maximieren: Erwartete Rendite
• Unterliegt: Risiko (Varianz) unterhalb des Schwellenwerts
• Einschränkungen: Budgetbeschränkungen, Diversifizierungsanforderungen, regulatorische Beschränkungen

Das ist quadratische Programmierung. Die Rendite hängt linear von den Portfoliogewichten ab, aber die Varianz ist quadratisch (sie beinhaltet Produkte von Gewichten).

Praktische Überlegungen

Echte Portfolio-Optimierung umfasst:

• Transaktionskosten (Kauf/Verkauf kostet Gebühren)
• Ganzzahlige Einschränkungen (man kann keine Bruchteile von bestimmten Vermögenswerten kaufen)
• Regulatorische Anforderungen (dürfen 10 % pro Wertpapier nicht überschreiten)
• Beschränkungen beim Rebalancing (das bestehende Portfolio nicht zu stark verändern)

Vermögensverwalter machen diese Optimierungen jeden Tag und verwalten dabei Milliarden an Kapital. Die Zeit, die das Modell zum Lösen braucht, beeinflusst direkt, wie die Handelsstrategie umgesetzt wird.

Fazit

Wir haben echt viel gemacht, von der Installation von Gurobi bis hin zum Aufbau komplexer Lieferkettenmodelle.

Jetzt musst du nicht mehr in einem Besprechungsraum über Meinungen diskutieren, sondern kannst den Code einfach auf den Bildschirm bringen. Hier ist der mathematisch beste Plan. Das ändert die Situation. Hör auf zu raten und fang an zu beweisen.

Probier's doch mal bei deinem nächsten kniffligen Problem aus, bei dem Terminkonflikt oder Budgetengpass, den du bisher gemieden hast. Vielleicht findest du ja die perfekte Antwort schon die ganze Zeit in deinen Daten.

Und wenn du deine Optimierungsfähigkeiten noch weiter verbessern willst, schau dir unsere Kurse „Einführung in die lineare Programmierung “ und „Einführung in die Optimierung in Python“ an, um deine Kenntnisse auszubauen.