Gurobi: Karmaşık Problemler için Matematiksel Optimizasyon

Temel çözücüler ve deneme-yanılma yöntemleri, değişkenler büyüdüğünde zorlanır. Gurobi bu karmaşıklıkları hız ve hassasiyetle yönetir; saatler sürebilecek problemleri saniyeler içinde çözer. Bu, uygulanabilir bir plan ummakla, en iyisini elde ettiğinizi matematiksel olarak kanıtlamak arasındaki farktır.

Bu eğitim, güçlü ticari çözücü Gurobi’ye rehberlik eder. Python kütüphanesini nasıl kuracağınızı, ilk modelinizi nasıl formüle edeceğinizi ve karma tamsayılı programlama gibi ileri problemler için nasıl ölçekleyeceğinizi göstereceğim.

Matematiksel Optimizasyonu Anlamak ve Gurobi'nin Rolü

Koda yazmaya başlamadan önce, optimizasyonun gerçekte ne anlama geldiğini anlamak faydalıdır. Bu bağlam, standart programlama yaklaşımları yerine ne zaman Gurobi kullanmanız gerektiğini gösterir.

Matematiksel optimizasyon nedir?

Matematiksel optimizasyon, tüm olası çözümler arasından en iyi çözümü bulur. "En iyi"nin ne olduğunu siz tanımlarsınız (maliyeti en aza indirmek, kârı en çoklamak, zamanı en aza indirmek), neyi kontrol ettiğinizi (karar değişkenleri) ve hangi sınırlara sahip olduğunuzu (kısıtlar). Çözücü, uygulanabilir çözümler arasında en iyisini arar ve bulur.

Bu, tam adımları belirlediğiniz geleneksel programlamadan farklıdır. Optimizasyonda, problemi matematiksel olarak tanımlarsınız ve çözmeyi çözücüye bırakırsınız. "Şu olursa bunu yap" mantığı yazmak yerine ilişkileri tanımlarsınız ve algoritmaların en iyi değerleri bulmasına izin verirsiniz.

Optimizasyonda Gurobi'nin önemi

Gurobi'yi öne çıkaran nedir

Gurobi, mevcut en hızlı ticari çözücülerden biri olarak sürekli üst sıralarda yer alır. Kıyaslamalar, büyük ölçekli problemler üzerinde açık kaynak alternatifleri önemli ölçüde geride bıraktığını sıklıkla gösterir. Saatlik optimizasyon çalıştırdığınızda veya sıkı zaman limitleri içinde sonuçlara ihtiyaç duyduğunuzda bu hız önemlidir.

Sektörde benimsenmesi

Lojistik, finans, enerji ve sağlık gibi sektörlerde şirketler Gurobi’yi üretim sistemlerinde kullanır. FedEx teslimat rotalarını optimize ederken, finans kuruluşları milyarlarca doları portföylerde tahsis eder. Enerji şirketleri elektrik üretimini planlar. Bunlar akademik alıştırmalar değil; gerçek para ve gerçek kısıtlarla çalışan sistemlerdir.

Çözücü yetenekleri

Gurobi doğrusal programlama (LP), karma tamsayılı programlama (MIP), kuadratik programlama (QP) ve daha fazlasını destekler. Aynı anda birden fazla çözüm yönteminin paralel çalıştırıldığı ve en hızlısının kazandığı eşzamanlı optimizasyon gibi son teknoloji algoritmalar içerir. Algoritmaları elle seçmeden güvenilirlik ve hız elde edersiniz.

Gurobi'yi Kurma

Gurobi'yi kurmak sadece birkaç adım sürer. Yapılandırıldıktan sonra Python ile sorunsuz çalışır.

Kurulum ve yapılandırma

İndir ve yükle

Gidin: Gurobi'nin web sitesi ve işletim sisteminiz için yükleyiciyi indirin. Yükleyici; çözücüyü, gurobipy arayüzünü ve dokümantasyonu içerir. Özel bir yola ihtiyacınız yoksa yükleyiciyi varsayılan ayarlarla çalıştırın.

Kurulumdan sonra, çalıştığını doğrulayın:

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

Burada, sürüm numarasını yazdırarak kurulumu doğruluyoruz. Başarılı bir yazdırma, ortamınızın hazır olduğunu gösterir.

Lisanslama seçenekleri

Gurobi, küçük test problemlerinin ötesindeki her şey için lisans gerektirir. Seçenekleriniz:

• Ücretsiz deneme lisansı: 30 günlük değerlendirme. Gurobi'nin web sitesinden iş e-postanızla talep edin.
• Akademik lisans: Öğretim üyeleri ve öğrenciler için ücretsiz. Sınırsız erişim için akademik e-postanızı doğrulayın; öğrenmek için idealdir.
• Ticari lisans: İş kullanımında gereklidir. Fiyatlandırma ölçeğe göre değişir. Adlandırılmış kullanıcı lisansları bireysel veri bilimciler için uygundur; yüzer lisanslar ekiplerin kapasiteyi paylaşmasına olanak tanır.
• Bulut lisansı: Kullandığın kadar öde. Peşin maliyet yok; yalnızca kullandığınız kadar ödersiniz. Ara sıra yapılan optimizasyon görevleri için kullanışlıdır.

Öğrenme için akademik lisansı, üretimde ise ticari olanı kullanıyorum. Deneme süresi, karar vermeden önce keşfetmek için fazlasıyla zaman tanır.

Ortam yapılandırması

Python kurulumu

Gurobi, Python 3.7+ ile çalışır. Çakışmalardan kaçınmak için sanal ortam kullanmanızı öneririm:

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

Bu komutlar temiz bir çalışma alanı oluşturur ve kütüphaneyi kurar.

Jupyter Notebook entegrasyonu

Etkileşimli geliştirme için notebooklar Gurobi ile harika çalışır:

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

Bu kod parçası Jupyter’ı kurar, sunucuyu başlatır ve Gurobi’nin notebook içinde doğru şekilde yüklendiğini hızlıca kontrol eder.

Gurobi'yi KULLANMAMAnız gereken durumlar

Gurobi güçlüdür, ancak her zaman doğru seçim değildir.

• Basit problemler: 50 değişken ve temel doğrusal kısıtlara sahipseniz, ücretsiz çözücüler olan scipy.optimize.linprog veya Excel Solver yeterli olur.

• Maliyet: Ticari lisanslar pahalıdır. Kritik olmayan dahili araçlar için PuLP aracılığıyla CBC veya GLPK gibi açık kaynak seçenekler yeterli olabilir.

• Sezgisel yöntemler: Gerçek zamanlı bir oyun için milisaniyeler içinde "yeterince iyi" bir cevap gerekiyorsa, genetik algoritmalar gibi sezgisel yöntemler çoğu zaman tam çözücülerden daha iyidir.

Problemler büyük olduğunda (10 bin+ değişken) veya kuadratik kısıtlar gibi gelişmiş özelliklere ihtiyaç duyduğunuzda Gurobi’yi kullanın.

Platform uyumluluğu

Gurobi Windows, macOS ve Linux üzerinde çalışır. AWS, Azure ve Google Cloud gibi bulut ortamları, pazar yerleri üzerinden Gurobi’yi destekler. Üç büyük bulutta da platforma özgü sorunlar yaşamadan Gurobi modelleri dağıttım.

Optimizasyon Modelleri Kurma

Gurobi kurulu olduğuna göre ilk modelinizi oluşturalım. Bu temel kavramlar çözeceğiniz her problem için geçerlidir.

Bir optimizasyon modelinin temel bileşenleri

Her modelin üç temel parçası vardır:

Karar değişkenleri

Bunlar, çözücünün değer atadığı seçimlerdir. Üretim planlamasında bu, "Ürün A adedi" ve "Ürün B adedi" olabilir. Değişkenleri siz tanımlarsınız; Gurobi değerleri atar.

Amaç fonksiyonu

Bu, en çoklamak veya en aza indirmek istediğiniz hedeftir. Kârı en çoklamak (3*product_a + 5*product_b) veya maliyeti en aza indirmek gibi. Model başına bir amaç vardır.

Kısıtlar

Bunlar sınırlarınızdır. Fabrika kapasitesinden fazlasını üretemez veya bütçenizden fazlasını harcayamazsınız. Kısıtlar, hangi çözümlerin gerçekten mümkün olduğunu tanımlar.

Formülasyon en iyi uygulamaları

Açık değişken adları kullanın. x[1] yerine produce_product_a kullanın. Sorun giderme bölümünde açıklayacağım gibi bu, ileride saatlerce hata ayıklamaktan kurtarır.

Kısıtları sade tutun. Karmaşık mantığı daha küçük ve basit kısıtlara bölmek, modelinizi okumayı ve hata ayıklamayı kolaylaştırır.

Modern Gurobi: Matris API

Veri bilimi geçmişinden geliyorsanız, döngü tabanlı modelleme yavaş gelebilir. Gurobi 13.0+ NumPy dizilerini kullanan bir Matris API sunar ve model kurmayı 10-50 kat hızlandırır.

Bir fırın modeli, vektörler kullanılarak şu şekilde görünür:

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

Bu A @ x <= b söz dizimi daha temizdir ve üretim sistemleri için standarttır.

Basit bir doğrusal programlama modeli oluşturma

Pratik bir problemi çözelim: Bir fırının kârı maksimize etmek için kaç ekmek ve kaç pasta pişireceğine karar vermesi.

Problem kurulumu:

- Ekmek kârı: $2 | Un: 0,5 kg

- Pasta kârı: $5 | Un: 2 kg

- Mevcut un: 100 kg

- Fırın kapasitesi: 80 ürün

Model şöyle:

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

Bu kod, modeli başlatır, değişkenleri tanımlar ve kâr amacını belirler. Yukarıda tanımladığımız kısıtları uygular ve en iyi planı çözer.

Çözücü günlüklerini anlamak

model.optimize() çalıştırdığınızda, Gurobi bir günlük basar. Bunu böyle okuyun:

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

• Ön çözüm (Presolve): Gurobi, çözmeden önce probleminizi basitleştirir. "Kaldırılan satırlar" fazlalık kısıtlar bulunduğu anlamına gelir.
• Simplex iterasyonları: Algoritmanın kaç adım attığı. Küçük problemlerde yüksek sayılar formülasyon sorunlarına işaret edebilir.
• Optimal amaç: Nihai sonucunuz (ör. 280 $ kâr).
• Açık (Gap): Tamsayılı problemlerde, şimdiye kadar bulunan en iyi çözüm ile teorik en iyi arasındaki farkı gösterir.

Günlüğü izlemek, bir modelin "takılıp kalıp kalmadığını" veya sadece yoğun çalıştığını görmenize yardımcı olur.

Buradaki kavramlar doğrudan ölçeklenir. 10 değişkeniniz de olsa 10.000 de olsa, desen aynıdır.

Gurobi'nin Desteklediği İleri Problem Türleri

Doğrusal programlama sadece başlangıçtır. Gurobi, sürüm 13.0’daki yeni Dışbükey Olmayan MINLP yetenekleri de dahil olmak üzere gerçek dünya ayrıntılarını yakalayan karmaşık türleri destekler.

Karma tamsayılı doğrusal programlama

Farklı kılan nedir

Karma tamsayılı programlama (MIP), değişkenlerin tamsayı olmasına izin verir. 0,7 fabrika inşa edemezsiniz; bu nedenle tamsayı çözümlere ihtiyaç vardır.

Gerçek dünya uygulamaları

Tesis yeri: Şehir A’da bir depo aç? Evet (1) veya Hayır (0).

Üretim çizelgeleme: Parti büyüklükleri çoğu zaman tam sayı olmalıdır.

Ağ tasarımı: Yönlendirme kararları genellikle ikilidir. Trafik bir bağlantıdan geçer ya da geçmez.

Örnek: tesis yeri

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

Burada, bir depoyu açıp açmamaya karar vermek için ikili değişkenler kullanıyoruz. Model, en az iki tesisin açık kalmasını sağlarken sabit maliyetleri en aza indirir.

Kuadratik ve doğrusal olmayan programlama

Kuadratik programlama (QP)

Amaç fonksiyonunuz kare terimler veya değişken çarpımları içerdiğinde QP’niz vardır. Portföy optimizasyonu klasik bir örnektir, çünkü risk (varyans) kuadratiktir.

Kuadratik kısıtlı programlama (QCP)

Kısıtlar da kuadratik olabilir. Daireler veya eğri sınırlar içeren problemleri düşünün.

Örnek: portföy optimizasyonu

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}%")

Bu kurulum, portföy optimizasyonunu ele alır. Toplam riski (varyans) kuadratik kısıtlarla sıkı bir şekilde sınırlandırırken getirileri maksimize eder.

Ek desteklenen problem türleri

İkinci mertebe koni programlama (SOCP)

Koni veya dairesel sınır tanımlamak gibi geometrik kısıtlar içeren problemler bu kategoriye girer. Sağlam optimizasyon ve mühendislik tasarımında yaygındır.

Karma tamsayılı kuadratik programlama (MIQP)

Tamsayı değişkenleri, kuadratik amaçlar veya kısıtlarla birleştirir. Doğrusal olmayan ilişkilerin olduğu ayrık optimizasyonda kullanışlıdır.

Gurobi bu türlerin tümünü yerel olarak destekler. Problemleri belirli bir çözücüye uydurmak için yeniden formüle etmeniz gerekmez; Gurobi problem türünü otomatik olarak algılar ve uygun algoritmaları uygular.

Gurobi'nin desteklediği optimizasyon problem türleri. Görsel: Yazar.

Gurobi Algoritmaları ve Uygulamaları

Algoritma seçimi

Gurobi algoritmaları otomatik seçer, ancak seçenekleri bilmek yavaş çözümleri giderirken yardımcı olur.

Yöntem değerleri:

• -1 (varsayılan): Kararı Gurobi'ye bırak

• 0: Birincil simplex (çoğu LP için iyi)

• 1: İkili simplex (başlangıçta uygulanamaz olduğunda iyi)

• 2: Bariyer (çok büyük modeller veya QP için en iyisi)

• 3: Eşzamanlı (birden fazla yöntemi çalıştırır, en hızlıyı seçer)

• 4: Deterministik Eşzamanlı

• 5: Deterministik Eşzamanlı Simplex

• PDHG (Birinci Dereceden Yöntem): Gurobi 13.0 ayrıca, GPU’larda çalışmaya uygun, devasa LP’ler için ideal gradyan tabanlı PDHG’yi içerir.

Hangi yöntemin çalıştığını, çözücü günlüğüne bakarak kontrol edin (ör. "Barrier solved model...").

Ne zaman geçersiz kılınır: Varsayılan saatler sürerse, çok büyük modeller için Barrier’ı veya öngörülemez problemler için Eşzamanlı’yı deneyin.

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

Bu, özellikle çok büyük veya hassas veri kümeleriyle uğraşırken yardımcı olan Bariyer yöntemini açıkça seçer ve toleransı sıkılaştırır.

Gurobi'nin Gelişmiş Özelliklerinden Yararlanmak

Temelleri öğrendikten sonra, Gurobi kurumsal ölçekli problemler için güçlü araçlar sunar.

Dağıtık optimizasyon

Tek bir makinede çok uzun süren devasa modeller için işi bölebilirsiniz. Gurobi’nin dağıtık optimizasyonu, tek bir problemi daha hızlı çözmek için birden fazla bilgisayar kullanır.

Bir makineyi "yönetici", diğerlerini "işçi" olarak atarsınız. Yönetici, arama ağacının kısımlarını işçilere gönderir; işçiler bunları paralel çözer. Küçük modeller için aşırıdır; ancak küresel tedarik zinciri veya havayolu çizelgeleme problemleri için gereklidir.

Çok amaçlı optimizasyon

Gerçek hayatta nadiren tek bir hedef vardır. Kârı maksimize ederken çevresel etkiyi en aza indirmek isteyebilirsiniz.

Gurobi bunu öncelikler belirlemenize izin vererek ele alır. "Önce kârı maksimize et, sonra kârı %10’dan fazla azaltmadan atığı minimize et" diyebilirsiniz. Alternatif olarak ağırlıklandırabilirsiniz: 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")

Gerçek zamanlı etkileşim ve geri çağrılar (callback)

Bazen Gurobi çözüm ararken müdahale etmek istersiniz. Geri çağrılar, örneğin her yeni çözüm bulunduğunda, belirli noktalarda özel kod çalıştırmanıza olanak tanır.

Ben geri çağrıları, bir çözüm "yeterince iyi" olduğunda erken durdurmak veya verime özel işe yaradığını bildiğim özel sezgisel yöntemleri eklemek için kullanıyorum.

Bulut yetenekleri

Geliştirme için dizüstünüzde optimizasyon çalıştırmak iyidir; ancak üretimde çoğu zaman daha fazla güce ihtiyaç vardır. Gurobi Cloud, ağır işi AWS, Azure veya Gurobi’nin kendi Instant Cloud’una devretmenize olanak tanır. Yalnızca çözüm süresi için ödeme yaparsınız; düzensiz, ağır iş yükleri için idealdir.

Pratik Modelleme En İyi Uygulamaları

Verimli modeller yazmak strateji gerektirir. İşte kodunuzu temiz ve hızlı tutmak için ipuçları.

Model formülasyonu stratejileri

Basit başlayın, karmaşıklığı kademeli olarak ekleyin

İlk günden 50 kısıtlı bir model kurmayın. Çekirdek mantıkla başlayın, doğrulayın, sonra iyileştirin. Çoğu zaman karmaşık modellerde saatler harcayıp hatanın temelde olduğunu gördüm.

Anlamlı değişken ve kısıt adları kullanın

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

Farkı fark edin: ikinci blok iş mantığını açıkça betimler. Daha önce belirttiğim gibi, bu, hata ayıklama baş ağrılarını azaltır.

Veriyi ön işleyin

Modellemeden önce verinizi doğrulayın. Eksik değerler veya imkansız kısıtlar var mı kontrol edin. 3 saatlik bir çözümden sonra veri hatası bulmak can yakar.

Verinizi uygun şekilde ölçekleyin

Gurobi sayısal hassasiyeti iyi yönetir, ancak aşırı değerler sorun çıkarır. Maliyetler milyonlarla, miktarlar binde birlerle ölçülüyse, benzer büyüklüklere ölçekleyin:

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

Sayısal sorunlar iyi ölçeklenmiş modellerde nadir, kötü ölçeklenmişlerde yaygındır.

Sayısal kararlılık hususları

Gurobi, sonsuz olmayan kayan noktalı aritmetik kullanır. Kısıtınız x <= 1000000000 ve toleransınız 1e-6 ise, garip sonuçlar alabilirsiniz.

Şu tür "Büyük M" kısıtlarından kaçının: if y=0 then x <= 1,000,000,000. Bunun yerine, mümkün olan en küçük üst sınırı seçin (ör. toplam pazar büyüklüğü). Daha sıkı sınırlar daha hızlı ve daha kararlı çözümler demektir.

Sıcak başlangıçlar ve model değişiklikleri

Bir problemi nadiren sadece bir kez çözersiniz. Genellikle yeni veriler gelir (ör. güncellenmiş talep).

Modeli sıfırdan yeniden kurmak yerine sıcak başlangıç kullanın. Gurobi’ye önceki çözümü başlangıç noktası olarak verirsiniz. Dünkü en iyi plan muhtemelen bugünkü plana yakın olduğundan, Gurobi aramanın büyük kısmını atlayabilir.

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

Programlama Arayüzleri ve Entegrasyon

Gurobi'nin Python API'si

gurobipy kullandık çünkü Pythonik. Operatör taşmasını destekler (x + y <= 5) ve pandas ile NumPy ile doğrudan entegre olur. Veri bilimi için Gurobi’yi kullanmanın en popüler yoludur.

Diğer dillerle entegrasyon

Üretim sistemleri genellikle hız için C++, Java veya .NET üzerinde çalışır. Gurobi bunların hepsini destekler. Kavramlar (Değişkenler, Kısıtlar, Amaçlar) aynıdır; yalnızca söz dizimi değişir.

Diller arası iş akışlarında, sık sık Python’da prototip (hızlı kodlama) yapar ve C++’ta dağıtırım (hızlı yürütme); arada Gurobi’nin dosya formatlarını (.mps veya .lp) kullanırım.

Modelleme dili desteği

Gurobi, AMPL ve GAMS gibi özel modelleme dillerine, hatta Excel’e de bağlanır.

- AMPL/GAMS: Yazılım kodu yazmak istemeyen, tamamen matematiksel çalışan araştırmacılar için harikadır.

- Excel: Hızlı prototipler veya iş paydaşlarına Python kurmadan dokunabilecekleri bir model göstermek için kullanışlıdır.

Performans Optimizasyonu ve Ayarlama

Ayarlama iş akışı

Rastgele ayar yapmayın. Bu süreci izleyin:

1. Temeli ölçün: Varsayılanlarla çalıştırın, çözüm süresini not edin.

2. Önce sert sınırlar koyun: Üretim sistemleri TimeLimit gerektirir.

3. Hızı doğrulukla değiş tokuş edin: Yalnızca işletme tolere ediyorsa MIPGap’i gevşetin.

4. İş parçacığı ölçeklemeyi test edin: Daha fazla iş parçacığı ≠ daha hızlı (4-8’den sonra azalan getiri).

# 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

Performans kıyaslamaları

Kıyaslamalar, Gurobi’nin zor MIP problemlerinde açık kaynak çözücüleri katbekat geride bıraktığını gösterir. scipy küçük LP’leri gayet iyi işlerken, karmaşıklık arttığında Gurobi parıldar. Çözücü performansını bağımsız olarak takip eden Hans Mittelmann web sitesinde karşılaştırmalı kıyaslamaları bulabilirsiniz.

Hata ayıklama ve sorun giderme

Model uygulanamazlığı

Gurobi "Model is infeasible" bildirdiğinde, kısıtlarınız çakışıyor demektir. Hiçbir çözüm hepsini aynı anda sağlayamıyor.

Çakışan kısıtları bulun:

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

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

Bu, Asgari Tutarsız Alt Sistem (IIS) hesaplamasını yapar ve tam olarak hangi kısıtların birbirleriyle çatıştığını yazdırır.

Sınırsız modeller

Sınırsız bir model, amacın sonsuza dek iyileştirilebileceği anlamına gelir. Genellikle eksik kısıtları işaret eder.

Kontrol edin:

- Tüm değişkenleri sınırladınız mı? addVar(lb=0, ub=1000)

- Kısıtlar doğru formüle edildi mi?

- Amaç fonksiyonu doğru mu?

Çözücü günlüklerini kullanma

Gurobi’nin ne yaptığını görmek için ayrıntılı günlüğü etkinleştirin:

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

Bu, ayrıntılı çıktıyı etkinleştirir ve yerel bir dosyaya kopyasını kaydeder; çözüm sürecinin ayrıntılı bir geçmişini sağlar.

Veriyle çalışma

Gerçek uygulamalarda veriler dosyalardan gelir, kod içine gömülü listelerden değil.

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

Bu desen, Yükle-Doğrula-Modelle, sessiz hataları önler.

Gurobi'nin Gerçek Dünya Uygulamaları

Teori harika, fakat endüstriler bunu gerçekte nasıl kullanıyor bir bakalım.

Tedarik zinciri optimizasyonu

Dağıtım ağı tasarımı

FedEx, UPS ve Amazon, teslimat garantilerini karşılarken maliyetleri en aza indirmek için Python ile Tedarik Zinciri Analitiği dersindeki kavramları kullanır.

Bu örnekte ölçeği verimli şekilde ele almak için Matris API’yi kullanacağız.

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

Bu vektörleştirilmiş yaklaşım (addMVar, sum(axis=1)) binlerce değişkeni anında işler ve yavaş Python döngülerinden kaçınır.

Tedarik zinciri ağ grafiği. Görsel: Yazar.

Envanter optimizasyonu

Sipariş, elde tutma ve yoksatma maliyetlerini dengelemek zordur. Talebin belirsiz olduğu durumlarda bu, Gurobi’nin senaryo modelleme yoluyla ele aldığı stokastik optimizasyona dönüşür.

İşgücü çizelgeleme

Vardiya planlama

Hastaneler ve çağrı merkezleri, personel ihtiyaçlarına, iş kanunlarına ve tercihlere saygı gösterirken çalışanları planlamak zorundadır.

Bu, saf karma tamsayılı programlamadır. Her atama ikili bir tercihtir. 100 hemşire ve 50 vardiyası olan bir hastanenin yönetmesi gereken 5.000 değişkeni vardır.

Örnek: hemşire çizelgeleme

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

Bu, vardiya planlamasını ikili değişkenlerle modeller. Toplam vardiya sayısını en aza indirirken personel gereksinimlerine, maksimum saatlere ve zorunlu dinlenme sürelerine uyar.

Finansal portföy optimizasyonu

Risk-getiri dengesi

Portföy optimizasyonu, beklenen getirileri riskle dengeler. Klasik Markowitz modeli:

• Maksimize et: Beklenen getiri
• Şuna tabi: Risk (varyans) eşik altında
• Kısıtlar: Bütçe kısıtları, çeşitlendirme gereksinimleri, düzenleyici sınırlamalar

Bu, kuadratik programlamadır. Getiri, portföy ağırlıklarında doğrusaldır; ancak varyans kuadratiktir (ağırlıkların çarpımlarını içerir).

Pratik hususlar

Gerçek portföy optimizasyonu şunları içerir:

• İşlem maliyetleri (alım/satım ücret doğurur)
• Tamsayı kısıtlar (bazı varlıklarda kesirli pay alınamaz)
• Düzenleyici gereksinimler (tek bir menkul kıymette %10’u aşamaz)
• Yeniden dengeleme kısıtları (mevcut portföyü aşırı derecede değiştirmeyin)

Varlık yöneticileri bu optimizasyonları günlük olarak çalıştırır ve milyarları yönetir. Model çözüm süresi, alım satım stratejisinin uygulanmasını doğrudan etkiler.

Sonuç

Kurulumdan Gurobi ile karmaşık tedarik zinciri modelleri kurmaya kadar çok şey ele aldık.

Artık toplantı odasında fikir tartışmak yerine kodu ekrana koyabilirsiniz. "İşte matematiksel olarak en iyi plan." Bu, konuşmayı değiştirir. Tahmin etmeyi bırakır, kanıtlamaya başlarsınız.

Gidin ve bir sonraki karmaşık probleminizde, ertelediğiniz o çizelgeleme çatışması veya bütçe sıkışıklığında deneyin. Mükemmel cevabın verilerinizde saklandığını keşfedebilirsiniz.

Ve optimizasyon becerilerinizi daha da keskinleştirmek isterseniz, öğrenmeye devam etmek için Doğrusal Programlamaya Giriş eğitimimize ve Python ile Optimizasyona Giriş kurslarımıza göz atın.