Gurobi: Optimisasi Matematis untuk Masalah Kompleks

Penyelesai dasar dan metode coba-coba kewalahan saat jumlah variabel membesar. Gurobi menangani kompleksitas ini dengan cepat dan presisi, menyelesaikan masalah dalam hitungan detik yang sebaliknya bisa memakan waktu berjam-jam. Itulah bedanya antara sekadar berharap rencana Anda feasibel dan membuktikan secara matematis bahwa rencana tersebut optimal.

Tutorial ini membimbing Anda melalui penyelesai komersial yang kuat bernama Gurobi. Saya akan menunjukkan cara menginstal pustaka Python, memformulasikan model pertama Anda, dan meningkatkan skala ke masalah lanjutan seperti pemrograman campuran-bulat (mixed-integer programming).

Memahami Optimisasi Matematis dan Peran Gurobi

Sebelum menulis kode, ada baiknya memahami apa sebenarnya makna optimisasi. Konteks ini menunjukkan kapan harus menggunakan Gurobi alih-alih pendekatan pemrograman standar.

Apa itu optimisasi matematis?

Optimisasi matematis mencari solusi terbaik dari semua solusi yang mungkin. Anda mendefinisikan apa yang dimaksud dengan "terbaik" (meminimalkan biaya, memaksimalkan laba, meminimalkan waktu), apa yang Anda kendalikan (variabel keputusan), dan batasan yang dihadapi (kendala). Optimizer menelusuri solusi feasibel untuk menemukan yang optimal.

Ini berbeda dari pemrograman tradisional, di mana Anda menentukan langkah-langkah secara eksplisit. Dengan optimisasi, Anda mendeskripsikan masalahnya secara matematis dan membiarkan penyelesai mencari cara menyelesaikannya. Anda tidak menulis logika "jika ini maka itu"; Anda mendefinisikan hubungan dan membiarkan algoritme menemukan nilai terbaik.

Signifikansi Gurobi dalam optimisasi

Mengapa Gurobi menonjol

Gurobi secara konsisten menempati peringkat sebagai salah satu optimizer komersial tercepat. Benchmark sering menunjukkan kinerjanya jauh melampaui alternatif open-source pada masalah skala besar. Kecepatan ini penting saat Anda menjalankan optimisasi per jam atau membutuhkan hasil dalam batas waktu ketat.

Adopsi industri

Perusahaan di bidang logistik, keuangan, energi, dan kesehatan menggunakan Gurobi untuk sistem produksi. FedEx mengoptimalkan rute pengiriman, sementara perusahaan keuangan mengalokasikan miliaran dalam portofolio. Perusahaan energi menjadwalkan pembangkitan listrik. Ini bukan latihan akademis; ini adalah sistem yang menangani uang nyata dan kendala nyata.

Kapabilitas penyelesai

Gurobi menangani linear programming (LP), mixed-integer programming (MIP), quadratic programming (QP), dan lainnya. Ia menyertakan algoritme mutakhir seperti optimisasi konkuren, di mana beberapa metode solusi berjalan paralel dan yang tercepat menang. Anda mendapat keandalan dan kecepatan tanpa memilih algoritme secara manual.

Menyiapkan Gurobi

Menginstal Gurobi hanya beberapa langkah. Setelah dikonfigurasi, ia bekerja mulus dengan Python.

Instalasi dan penyiapan

Unduh dan instal

Kunjungi situs Gurobi dan unduh installer untuk OS Anda. Paket ini mencakup optimizer, antarmuka gurobipy , dan dokumentasi. Jalankan installer dengan pengaturan default kecuali Anda memerlukan path khusus.

Setelah instalasi, verifikasi bahwa semuanya berhasil:

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

Di sini, kita memverifikasi instalasi dengan mencetak nomor versi. Jika tercetak dengan sukses, lingkungan Anda siap digunakan.

Opsi lisensi

Gurobi memerlukan lisensi untuk penggunaan di luar masalah uji kecil. Opsi Anda:

• Lisensi uji coba gratis: evaluasi 30 hari. Minta dari situs Gurobi dengan email kerja Anda.
• Lisensi akademik: Gratis untuk dosen dan mahasiswa. Verifikasi email akademik Anda untuk akses tanpa batas, ideal untuk belajar.
• Lisensi komersial: Diperlukan untuk bisnis. Harga bervariasi menurut skala. Lisensi pengguna bernama cocok untuk data scientist individual, sedangkan lisensi floating memungkinkan tim berbagi kapasitas.
• Lisensi cloud: Bayar sesuai penggunaan. Tidak ada biaya di muka, cukup bayar yang Anda gunakan. Berguna untuk tugas optimisasi sesekali.

Saya menggunakan lisensi akademik untuk belajar dan lisensi komersial untuk produksi. Uji coba memberi Anda cukup waktu untuk mengeksplorasi sebelum berkomitmen.

Konfigurasi lingkungan

Penyiapan Python

Gurobi bekerja dengan Python 3.7+. Saya menyarankan menggunakan virtual environment untuk menghindari konflik:

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

Perintah ini menyiapkan ruang kerja yang bersih dan mengunduh pustakanya.

Integrasi Jupyter Notebook

Untuk pengembangan interaktif, notebook sangat cocok dengan Gurobi:

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

Cuplikan ini memasang Jupyter, menyalakan server, dan menjalankan cek cepat untuk memastikan Gurobi dapat dimuat dengan benar di dalam notebook.

Kapan TIDAK menggunakan Gurobi

Gurobi sangat kuat, tetapi tidak selalu menjadi pilihan yang tepat.

• Masalah sederhana: Jika Anda punya 50 variabel dan kendala linear dasar, penyelesai gratis seperti scipy.optimize.linprog atau Excel Solver cukup memadai.

• Biaya: Lisensi komersial mahal. Untuk alat internal yang tidak kritis, opsi open-source seperti CBC atau GLPK (melalui PuLP) mungkin cukup.

• Heuristik: Jika Anda butuh jawaban "cukup baik" dalam milidetik untuk gim waktu nyata, heuristik (seperti algoritme genetik) sering lebih unggul daripada penyelesai eksak.

Gunakan Gurobi saat masalahnya besar (10 ribu+ variabel) atau Anda butuh fitur lanjutan seperti kendala kuadratik.

Kompatibilitas platform

Gurobi berjalan di Windows, macOS, dan Linux. Lingkungan cloud seperti AWS, Azure, dan Google Cloud mendukung Gurobi melalui marketplace mereka. Saya telah menerapkan model Gurobi di tiga cloud besar tanpa masalah spesifik platform.

Membangun Model Optimisasi

Dengan Gurobi terpasang, mari bangun model pertama Anda. Konsep inti ini berlaku untuk setiap masalah yang akan Anda selesaikan.

Komponen utama model optimisasi

Setiap model memiliki tiga bagian esensial:

Variabel keputusan

Inilah pilihan yang dibuat optimizer. Dalam perencanaan produksi, ini bisa berupa "unit Produk A" dan "unit Produk B." Anda mendefinisikan variabelnya; Gurobi menetapkan nilainya.

Fungsi objektif

Ini adalah tujuan Anda, apa yang ingin dimaksimalkan atau diminimalkan. Memaksimalkan laba (3*product_a + 5*product_b) atau meminimalkan biaya. Anda mendapatkan satu tujuan per model.

Kendala

Inilah batasan Anda. Anda tidak bisa memproduksi melebihi kapasitas pabrik atau membelanjakan melebihi anggaran. Kendala menentukan solusi mana yang benar-benar mungkin.

Praktik terbaik formulasi

Gunakan nama variabel yang jelas. Alih-alih x[1], gunakan produce_product_a. Ini menghemat jam debugging di kemudian hari, seperti yang akan saya jelaskan di bagian pemecahan masalah.

Jaga kendala tetap sederhana. Memecah logika kompleks menjadi kendala yang lebih kecil dan sederhana membuat model Anda lebih mudah dibaca dan di-debug.

Gurobi modern: Matrix API

Jika Anda berlatar data science, pemodelan berbasis loop mungkin terasa lambat. Gurobi 13.0+ menawarkan Matrix API yang menggunakan array NumPy, membuat pembangunan model 10–50x lebih cepat.

Berikut tampilan model bakery menggunakan vektor:

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

Sintaks A @ x <= b ini lebih bersih dan standar untuk sistem produksi.

Membuat model linear programming sederhana

Mari selesaikan masalah praktis: sebuah bakery memutuskan berapa banyak roti dan kue yang harus dipanggang untuk memaksimalkan laba.

Susunan masalah:

- Laba roti: $2 | Tepung: 0,5 kg

- Laba kue: $5 | Tepung: 2 kg

- Tepung tersedia: 100 kg

- Kapasitas oven: 80 item

Berikut modelnya:

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

Kode ini menginisialisasi model, mendefinisikan variabel, dan menetapkan objektif laba. Ia menerapkan kendala yang kita definisikan di atas dan menyelesaikan rencana optimalnya.

Memahami log penyelesai

Saat Anda menjalankan model.optimize(), Gurobi mencetak log. Begini cara membacanya:

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 menyederhanakan masalah Anda sebelum menyelesaikan. "Removed rows" berarti ia menemukan kendala yang berlebih.
• Iterasi Simplex: Berapa banyak langkah yang diambil algoritme. Angka tinggi pada masalah kecil bisa mengindikasikan isu formulasi.
• Optimal objective: Hasil akhir Anda (mis., laba $280).
• Gap: Untuk masalah integer, ini menunjukkan selisih antara solusi terbaik yang ditemukan sejauh ini dan yang terbaik secara teoretis.

Memantau log membantu Anda melihat apakah model "macet" atau memang sedang bekerja keras.

Konsep di sini langsung dapat diskalakan. Entah Anda punya 10 variabel atau 10.000, polanya tetap sama.

Tipe Masalah Lanjutan yang Didukung Gurobi

Linear programming hanyalah permulaan. Gurobi menangani tipe kompleks yang menangkap nuansa dunia nyata, termasuk kapabilitas Non-Convex MINLP baru di versi 13.0.

Mixed-integer linear programming

Apa yang membuatnya berbeda

Mixed-integer programming (MIP) memungkinkan variabel bernilai bilangan bulat. Anda tidak bisa membangun 0,7 pabrik, jadi Anda perlu solusi integer.

Aplikasi dunia nyata

Lokasi fasilitas: Buka gudang di Kota A? Ya (1) atau Tidak (0).

Penjadwalan produksi: Ukuran batch sering harus bilangan bulat.

Desain jaringan: Keputusan rute biasanya biner. Lalu lintas mengalir melalui tautan atau tidak.

Contoh: lokasi fasilitas

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

Di sini, kita menggunakan variabel biner untuk memutuskan apakah akan membuka gudang. Model meminimalkan biaya tetap sambil memastikan setidaknya dua fasilitas tetap buka.

Pemrograman kuadratik dan nonlinier

Quadratic programming (QP)

Saat objektif Anda mencakup suku kuadrat atau hasil kali variabel, itu adalah QP. Optimisasi portofolio adalah contoh klasik karena risiko (varians) bersifat kuadratik.

Quadratically constrained programming (QCP)

Kendala juga bisa kuadratik. Pikirkan masalah yang melibatkan lingkaran atau batasan melengkung.

Contoh: optimisasi portofolio

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

Pengaturan ini menangani optimisasi portofolio. Ia memaksimalkan imbal hasil sambil membatasi ketat total risiko (varians) menggunakan kendala kuadratik.

Tipe masalah tambahan yang didukung

Second-order cone programming (SOCP)

Masalah yang melibatkan kendala geometris, seperti mendefinisikan kerucut atau batas melingkar, masuk kategori ini. Umum dalam optimisasi robust dan desain rekayasa.

Mixed-integer quadratic programming (MIQP)

Menggabungkan variabel integer dengan objektif atau kendala kuadratik. Berguna dalam optimisasi diskret dengan hubungan nonlinier.

Gurobi mendukung semua tipe ini secara native. Anda tidak perlu memformulasi ulang masalah agar sesuai penyelesai tertentu; Gurobi mendeteksi tipe masalah secara otomatis dan menerapkan algoritme yang sesuai.

Tipe masalah optimisasi yang didukung Gurobi. Gambar oleh Penulis.

Algoritme Gurobi dan Penerapannya

Pemilihan algoritme

Gurobi memilih algoritme secara otomatis, tetapi mengetahui opsinya membantu saat menelusuri penyelesaian yang lambat.

Nilai metode:

• -1 (default): Biarkan Gurobi memutuskan

• 0: Primal simplex (bagus untuk sebagian besar LP)

• 1: Dual simplex (bagus saat mulai dari infeasible)

• 2: Barrier (terbaik untuk model masif atau QP)

• 3: Concurrent (menjalankan beberapa metode, memilih yang tercepat)

• 4: Deterministic Concurrent

• 5: Deterministic Concurrent Simplex

• PDHG (Metode Orde Pertama: Gurobi 13.0 juga menyertakan PDHG, metode berbasis gradien yang ideal untuk LP masif dan dapat berjalan di GPU.

Periksa metode yang berjalan dengan melihat log penyelesai (mis., "Barrier solved model...").

Kapan menimpa default: Jika default memakan waktu berjam-jam, coba Barrier untuk model besar atau Concurrent untuk masalah yang tidak terduga.

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

Ini secara eksplisit memilih metode Barrier dan memperketat toleransi, yang membantu saat menangani dataset yang masif atau sensitif.

Memanfaatkan Fitur Lanjutan Gurobi

Setelah menguasai dasar-dasar, Gurobi menawarkan alat yang kuat untuk masalah berskala perusahaan.

Optimisasi terdistribusi

Untuk model yang sangat besar yang terlalu lama di satu mesin, Anda dapat membagi pekerjaan. Optimisasi terdistribusi Gurobi menggunakan banyak komputer untuk menyelesaikan satu masalah lebih cepat.

Anda menetapkan satu mesin sebagai "manajer" dan lainnya sebagai "pekerja." Manajer mengirim bagian pohon pencarian ke pekerja, yang menyelesaikannya secara paralel. Ini berlebihan untuk model kecil tetapi esensial untuk masalah rantai pasok global atau penjadwalan maskapai.

Optimisasi multi-objektif

Kehidupan nyata jarang hanya punya satu tujuan. Anda mungkin ingin memaksimalkan laba dan meminimalkan dampak lingkungan.

Gurobi menanganinya dengan membiarkan Anda menetapkan prioritas. Anda bisa mengatakan "maksimalkan laba dulu, lalu minimalkan limbah tanpa mengurangi laba lebih dari 10%." Atau, Anda bisa memberi bobot: 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")

Interaksi waktu nyata dan callback

Kadang Anda ingin campur tangan saat Gurobi sedang menyelesaikan. Callback memungkinkan Anda menjalankan kode kustom pada titik tertentu, misalnya setiap kali solusi baru ditemukan.

Saya menggunakan callback untuk berhenti lebih awal jika solusi sudah "cukup baik" atau menyuntikkan heuristik kustom yang saya tahu bekerja untuk data saya.

Kapabilitas cloud

Menjalankan optimisasi di laptop Anda baik untuk pengembangan, tetapi produksi sering butuh daya lebih. Gurobi Cloud memungkinkan Anda memindahkan komputasi berat ke AWS, Azure, atau Instant Cloud milik Gurobi. Anda hanya membayar waktu penyelesaian, cocok untuk beban kerja berat yang sporadis.

Praktik Terbaik Pemodelan yang Praktis

Menulis model yang efisien memerlukan strategi. Berikut kiat untuk menjaga kode Anda bersih dan cepat.

Strategi formulasi model

Mulai sederhana, tambah kompleksitas secara bertahap

Jangan membangun model dengan 50 kendala di hari pertama. Mulailah dari logika inti, verifikasi, lalu perbaiki. Saya terlalu sering menghabiskan waktu men-debug model kompleks hanya untuk menemukan kesalahan ada pada hal dasar.

Gunakan nama variabel dan kendala yang bermakna

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

Perhatikan bedanya: blok kedua jelas menggambarkan logika bisnis. Seperti saya sebutkan sebelumnya, ini menghemat sakit kepala saat debugging.

Pra-proses data

Validasi data Anda sebelum memodelkan. Periksa nilai hilang atau kendala yang tidak mungkin. Menemukan kesalahan data setelah penyelesaian 3 jam itu menyakitkan.

Skalakan data Anda dengan tepat

Gurobi menangani presisi numerik dengan baik, tetapi nilai ekstrem menyebabkan masalah. Jika biaya dalam jutaan dan kuantitas dalam seperseribu, skalakan ke magnitudo serupa:

# Alih-alih cost = 10000000 dan quantity = 0.0001
# Skala ke cost = 10 (dalam jutaan) dan quantity = 100 (dalam satuan 1/1000)

Masalah numerik jarang terjadi pada model yang diskalakan dengan baik, dan umum pada model yang diskalakan buruk.

Pertimbangan stabilitas numerik

Gurobi menggunakan aritmetika floating-point, yang tidak tak terhingga. Jika kendala Anda mengatakan x <= 1000000000 dan toleransi Anda 1e-6, Anda bisa mendapat hasil yang aneh.

Hindari kendala "Big M" seperti if y=0 then x <= 1,000,000,000. Sebagai gantinya, pilih batas atas terkecil yang valid (mis., ukuran pasar total). Batas yang lebih ketat berarti penyelesaian lebih cepat dan lebih stabil.

Warm start dan modifikasi model

Anda jarang menyelesaikan masalah hanya sekali. Biasanya, data baru datang (mis., permintaan diperbarui).

Alih-alih membangun ulang model dari nol, gunakan warm start. Anda memberikan Gurobi solusi sebelumnya sebagai titik awal. Karena rencana optimal kemarin kemungkinan dekat dengan hari ini, Gurobi bisa melewati banyak pekerjaan pencarian.

# Warm start example
bread.Start = 40  # Mulai pencarian dengan asumsi memanggang 40 roti

Antarmuka Pemrograman dan Integrasi

Python API Gurobi

Kita menggunakan gurobipy karena bersifat Pythonic. Ia mendukung operator overloading (x + y <= 5) dan terintegrasi langsung dengan pandas dan NumPy. Ini adalah cara paling populer menggunakan Gurobi untuk data science.

Integrasi dengan bahasa lain

Sistem produksi sering berjalan di C++, Java, atau .NET untuk kecepatan. Gurobi mendukung semuanya. Konsepnya (Variabel, Kendala, Objektif) identik; hanya sintaksnya yang berubah.

Untuk alur kerja lintas bahasa, saya sering membuat prototipe di Python (coding cepat) dan melakukan deploy di C++ (eksekusi cepat), menggunakan format file Gurobi (.mps atau .lp) untuk memindahkan model di antara keduanya.

Dukungan bahasa pemodelan

Gurobi juga terhubung ke bahasa pemodelan khusus seperti AMPL dan GAMS, atau bahkan Excel.

- AMPL/GAMS: Cocok untuk peneliti matematis murni yang tidak ingin menulis kode perangkat lunak.

- Excel: Berguna untuk prototipe cepat atau menunjukkan model kepada pemangku kepentingan bisnis tanpa memasang Python.

Optimisasi Performa dan Tuning

Alur kerja tuning

Jangan melakukan tuning secara acak. Ikuti proses ini:

1. Ukur baseline: Jalankan dengan default, catat waktu penyelesaian.

2. Tetapkan batas keras terlebih dahulu: Sistem produksi membutuhkan TimeLimit.

3. Tukar akurasi dengan kecepatan: Hanya longgarkan MIPGap jika bisnis mentoleransinya.

4. Uji skala thread: Lebih banyak thread ≠ lebih cepat (imbal hasil menurun setelah 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

Benchmark performa

Benchmark menunjukkan Gurobi secara konsisten melampaui penyelesai open-source dengan selisih besar pada masalah MIP yang sulit. Sementara scipy menangani LP kecil dengan baik, Gurobi bersinar saat kompleksitas meningkat. Anda dapat menemukan benchmark perbandingan di situs Hans Mittelmann, yang melacak performa penyelesai secara independen.

Debugging dan pemecahan masalah

Ketidaklayakan model

Saat Gurobi melaporkan "Model is infeasible," kendala Anda saling bertentangan. Tidak ada solusi yang memenuhi semuanya sekaligus.

Temukan kendala yang bertentangan:

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

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

Ini menghitung Irreducible Inconsistent Subsystem (IIS) dan mencetak secara tepat kendala mana yang saling bertabrakan.

Model tak berbatas

Model tak berbatas berarti objektif dapat ditingkatkan tanpa batas. Biasanya mengindikasikan kendala yang hilang.

Periksa:

- Apakah Anda membatasi semua variabel? addVar(lb=0, ub=1000)

- Apakah kendalanya terformulasi dengan benar?

- Apakah fungsi objektifnya benar?

Menggunakan log penyelesai

Aktifkan logging terperinci untuk melihat apa yang dilakukan Gurobi:

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

Ini mengaktifkan keluaran verbose dan menyimpan salinannya ke file lokal, memberi Anda riwayat rinci proses penyelesaian.

Menangani data

Dalam aplikasi nyata, data berasal dari berkas, bukan daftar hardcode.

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

Pola ini, Muat-Validasi-Model, mencegah kesalahan sunyi.

Aplikasi Dunia Nyata Gurobi

Teori itu bagus, tetapi mari lihat bagaimana industri benar-benar menggunakannya.

Optimisasi rantai pasok

Desain jaringan distribusi

FedEx, UPS, dan Amazon menggunakan konsep dari kursus Supply Chain Analytics in Python untuk meminimalkan biaya sambil memenuhi jaminan pengiriman.

Kita akan menggunakan Matrix API untuk contoh ini agar efisien menangani skala.

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

Pendekatan vektorisasi ini (addMVar, sum(axis=1)) menangani ribuan variabel seketika, menghindari loop Python yang lambat.

Graf jaringan rantai pasok. Gambar oleh Penulis.

Optimisasi persediaan

Menyeimbangkan biaya pemesanan, penyimpanan, dan kekurangan itu rumit. Dengan permintaan yang tidak pasti, ini menjadi optimisasi stokastik, yang ditangani Gurobi melalui pemodelan skenario.

Penjadwalan tenaga kerja

Perencanaan shift

Rumah sakit dan pusat panggilan harus menjadwalkan pekerja sambil menghormati kebutuhan staf, aturan ketenagakerjaan, dan preferensi.

Ini murni mixed-integer programming. Setiap penugasan adalah pilihan biner. Sebuah rumah sakit dengan 100 perawat dan 50 shift memiliki 5.000 variabel untuk diatur.

Contoh: penjadwalan perawat

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

Ini memodelkan masalah penjadwalan menggunakan variabel biner. Ia meminimalkan total shift sambil memenuhi kebutuhan staf, jam maksimal, dan periode istirahat wajib.

Optimisasi portofolio keuangan

Pertukaran risiko-imbal hasil

Optimisasi portofolio menyeimbangkan ekspektasi imbal hasil terhadap risiko. Model Markowitz klasik:

• Maksimalkan: Imbal hasil yang diharapkan
• Dengan syarat: Risiko (varians) di bawah ambang
• Kendala: Kendala anggaran, persyaratan diversifikasi, batas regulasi

Ini adalah pemrograman kuadratik. Imbal hasil linear terhadap bobot portofolio, tetapi varians kuadratik (melibatkan hasil kali bobot).

Pertimbangan praktis

Optimisasi portofolio nyata mencakup:

• Biaya transaksi (beli/jual menimbulkan biaya)
• Kendala integer (tidak bisa membeli pecahan saham untuk beberapa aset)
• Persyaratan regulasi (tidak boleh melebihi 10% di satu sekuritas)
• Kendala rebalancing (jangan mengubah portofolio yang ada terlalu drastis)

Manajer aset menjalankan optimisasi ini setiap hari, mengelola miliaran modal. Waktu penyelesaian model berdampak langsung pada eksekusi strategi perdagangan.

Kesimpulan

Kita telah membahas banyak hal, dari menginstal Gurobi hingga membangun model rantai pasok yang kompleks.

Sekarang, alih-alih berdebat opini di ruang rapat, Anda bisa menampilkan kode di layar. "Inilah rencana yang optimal secara matematis." Itu mengubah percakapan. Anda berhenti menebak dan mulai membuktikan.

Silakan coba pada masalah berantakan berikutnya, konflik jadwal atau himpitan anggaran yang Anda hindari. Bisa jadi jawaban sempurna selama ini tersembunyi di data Anda.

Dan jika Anda ingin mempertajam keterampilan optimisasi lebih jauh, lihat tutorial Pengantar Linear Programming dan kursus Introduction to Optimization in Python untuk terus membangun kemampuan.