Pyomo के साथ ऑप्टिमाइज़ेशन: एक संपूर्ण चरण-दर-चरण गाइड

Pyomo सेटअप करना

मॉडलिंग में जाने से पहले, हमें Pyomo इंस्टॉल करके और एक उपयुक्त सॉल्वर चुनकर अपना वातावरण सेटअप करना होगा।

1. पूर्वापेक्षाएँ

Pyomo का उपयोग करने के लिए आपके पास Python 3.6 या उससे उच्च संस्करण होना चाहिए। Pyomo को pip के माध्यम से इंस्टॉल किया जा सकता है।

pip install pyomoसंचालित द्वारा

यह ट्यूटोरियल pyomo संस्करण 6.8.0 का उपयोग करके बनाया गया है।

import pyomo
print(pyomo.__version__)संचालित द्वारा

आउटपुट:

>>> 6.8.0संचालित द्वारा

2. सही सॉल्वर चुनना और इंस्टॉल करना

ऑप्टिमाइज़ेशन में, सॉल्वर आवश्यक होते हैं क्योंकि वही एल्गोरिदम होते हैं जो आपके द्वारा परिभाषित समस्या का इष्टतम समाधान ढूंढते हैं। अलग-अलग सॉल्वर समस्या के प्रकार (जैसे, रैखिक, गैर-रैखिक, पूर्णांक) के आधार पर बेहतर अनुकूल होते हैं। Pyomo एक मॉडलिंग टूल है जो वास्तविक गणना करने के लिए बाहरी सॉल्वर्स पर निर्भर करता है।

आइए कुछ सबसे आम सॉल्वर्स की समीक्षा करें।

ओपन-सोर्स सॉल्वर

1. GLPK (GNU Linear Programming Kit)

GLPK रैखिक प्रोग्रामिंग (LP) और मिक्स्ड-इंटिजर प्रोग्रामिंग (MIP) समस्याओं को हल करने के लिए एक लोकप्रिय टूल है। 

यह बुनियादी रैखिक ऑप्टिमाइज़ेशन कार्यों के लिए उत्कृष्ट विकल्प है और अकादमिक तथा औद्योगिक अनुप्रयोगों में व्यापक रूप से उपयोग होता है।

इंस्टॉलेशन

• Windows: GLPK डाउनलोड और इंस्टॉल करें।
• macOS: 

brew install glpkसंचालित द्वारा

• Linux: 

sudo apt-get install glpk-utilsसंचालित द्वारा

2. CBC (Coin-or Branch and Cut)

CBC एक ओपन-सोर्स सॉल्वर है जो रैखिक प्रोग्रामिंग (LP) और मिक्स्ड-इंटिजर प्रोग्रामिंग (MIP) समस्याओं के लिए है। 

यह कई स्थितियों में GLPK की तुलना में उन्नत सुविधाएँ और बेहतर प्रदर्शन प्रदान करता है, जिससे यह अधिक जटिल ऑप्टिमाइज़ेशन कार्यों के लिए एक मजबूत विकल्प बनता है। 

CBC को conda पैकेज मैनेजर के माध्यम से इंस्टॉल किया जा सकता है।

conda install -c conda-forge coincbcसंचालित द्वारा

3. IPOPT (Interior Point OPTimizer)

IPOPT बड़े पैमाने की गैर-रैखिक प्रोग्रामिंग (NLP) समस्याओं के लिए डिज़ाइन किया गया एक शक्तिशाली सॉल्वर है। 

यह जटिल, गैर-रैखिक मॉडलों को संभालने के लिए विशेष रूप से उपयुक्त है, जिससे यह रैखिक ऑप्टिमाइज़ेशन से परे समस्याओं के लिए उत्कृष्ट विकल्प बनता है। 

IPOPT को conda पैकेज मैनेजर के माध्यम से इंस्टॉल किया जा सकता है।

!conda install -c conda-forge ipoptसंचालित द्वारा

कमर्शियल सॉल्वर

1. CPLEX

CPLEX एक अत्याधुनिक ऑप्टिमाइज़ेशन सॉल्वर है जो रैखिक प्रोग्रामिंग (LP), मिक्स्ड-इंटिजर प्रोग्रामिंग (MIP), और क्वाड्रेटिक प्रोग्रामिंग (QP) समस्याओं को कुशलतापूर्वक संभालता है। 

इसके लिए IBM से लाइसेंस की आवश्यकता होती है, लेकिन यह अकादमिक उपयोगकर्ताओं के लिए नि:शुल्क उपलब्ध है, जिससे यह शोध और शैक्षिक उद्देश्यों के लिए उत्कृष्ट विकल्प बनता है।

2. Gurobi

Gurobi एक अग्रणी कमर्शियल सॉल्वर है जो LP, MIP, QP, और गैर-रैखिक प्रोग्रामिंग (NLP) समस्याओं को हल करने में अपनी गति और दक्षता के लिए जाना जाता है। 

CPLEX की तरह, इसके लिए भी लाइसेंस की आवश्यकता होती है, लेकिन यह अकादमिक उपयोगकर्ताओं को नि:शुल्क एक्सेस देता है। इस प्रकार, यह उन्नत ऑप्टिमाइज़ेशन के लिए इंडस्ट्री-स्टैंडर्ड टूल है।

ओपन-सोर्स बनाम कमर्शियल सॉल्वर

GLPK और CBC जैसे ओपन-सोर्स सॉल्वर निःशुल्क हैं और अधिकांश बुनियादी ऑप्टिमाइज़ेशन आवश्यकताओं के लिए पर्याप्त हैं। वे छोटे पैमाने की परियोजनाओं और शैक्षिक उद्देश्यों के लिए उत्कृष्ट विकल्प हैं। 

हालाँकि, CPLEX और Gurobi जैसे कमर्शियल सॉल्वर आमतौर पर बड़े, अधिक जटिल समस्याओं के लिए बेहतर प्रदर्शन प्रदान करते हैं। इन सॉल्वर्स में उन्नत सुविधाएँ होती हैं, जिनमें उन्नत क्वाड्रेटिक और गैर-रैखिक प्रोग्रामिंग सपोर्ट शामिल है, और इन्हें बड़े पैमाने के औद्योगिक अनुप्रयोगों के लिए ऑप्टिमाइज़ किया गया है।

जहाँ ओपन-सोर्स सॉल्वर कई नियमित ऑप्टिमाइज़ेशन कार्यों को संभाल सकते हैं, वहीं अधिक जटिल, उच्च-प्रदर्शन आवश्यकताओं से निपटने पर कमर्शियल सॉल्वर अक्सर बेहतर विकल्प होते हैं। 

ध्यान रखें कि कमर्शियल सॉल्वर के लिए लाइसेंस की आवश्यकता होती है, हालांकि वे अकादमिक उपयोगकर्ताओं के लिए मुफ्त उपलब्ध हैं।

अब, देखते हैं कि Pyomo में सॉल्वर को कैसे कॉन्फ़िगर करें। मैं यहाँ GLPK का उपयोग करूँगा। 

3. Pyomo में सॉल्वर कॉन्फ़िगर करना

सबसे पहले, इंस्टॉलेशन के बाद यह सुनिश्चित करें कि सॉल्वर का एक्ज़िक्यूटेबल आपके सिस्टम PATH में हो। 

फिर, एक Python स्क्रिप्ट बनाएँ और निम्नलिखित जोड़ें:

from pyomo.environ import SolverFactory
solver = SolverFactory('glpk')संचालित द्वारा

यह पुष्टि करने के लिए कि Pyomo और आपका सॉल्वर दोनों सही ढंग से इंस्टॉल हैं, आइए एक सरल टेस्ट समस्या हल करें।

टेस्ट समस्या: सरल रैखिक प्रोग्राम

उद्देश्य: न्यूनतम करें Z = x + y

इसके अधीन:

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

यह समस्या Z का, जो दो चरों x और y का योग है, सबसे छोटा मान खोजने के बारे में है। हालांकि, x और y को कुछ शर्तें पूरी करनी होंगी। 

पहला, जब आप x और y का दुगुना जोड़ते हैं, तो परिणाम कम से कम 4 होना चाहिए। दूसरा, x माइनस y अधिकतम 1 होना चाहिए। अंत में, दोनों x और y शून्य या धनात्मक संख्याएँ होनी चाहिए (वे ऋणात्मक नहीं हो सकते)। 

उद्देश्य ऐसे x और y के मान खोजना है जो इन शर्तों को पूरा करते हों और साथ ही Z को यथासंभव छोटा बनाते हों।

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))संचालित द्वारा

यदि सब कुछ सही से काम कर रहा है, तो अपेक्षित आउटपुट यह होगा:

Status: ok
Termination Condition: optimal
Optimal x: 0.0
Optimal y: 2.0
Optimal Objective: 2.0संचालित द्वारा

ऊपर दिए गए कोड को समझें: सबसे पहले, यह दो चरों x और y को परिभाषित करता है जो केवल धनात्मक या शून्य मान ले सकते हैं। मॉडल का उद्देश्य x और y (x + y) के योग को न्यूनतम करना है। कोड सॉल्वर को glpk के रूप में परिभाषित करता है ताकि x और y के ऐसे इष्टतम मान खोजे जा सकें जो इन बाधाओं को संतुष्ट करते हुए उद्देश्य को न्यूनतम करें।

कोड चलाने के बाद, हम पाते हैं कि चरों के इष्टतम मान x = 0.0 और y = 2.0 होते हैं, जो उद्देश्य फ़ंक्शन Z = x + y को न्यूनतम करते हैं। अतः उद्देश्य फ़ंक्शन का न्यूनतम मान 2.0 है, जो दी गई बाधाओं को संतुष्ट करता है।

Pyomo के साथ मॉडलिंग की बुनियाद

Pyomo में ऑप्टिमाइज़ेशन मॉडल के बुनियादी घटकों को कैसे परिभाषित किया जाए, यह समझना, प्रभावी ढंग से ऑप्टिमाइज़ेशन समस्याओं को सेटअप और हल करने के लिए आवश्यक है।

1. वेरिएबल्स परिभाषित करना

वेरिएबल्स उन निर्णयों का प्रतिनिधित्व करते हैं जिन्हें ऑप्टिमाइज़ेशन समस्या में लिया जाना होता है। Pyomo में, वेरिएबल्स वे मात्राएँ हैं जिन्हें सॉल्वर उद्देश्य फ़ंक्शन को ऑप्टिमाइज़ करने के लिए बाधाओं को संतुष्ट करते हुए समायोजित करेगा।

स्केलर वेरिएबल्स

स्केलर वेरिएबल एक अकेला वेरिएबल है जो किसी सेट पर इंडेक्स नहीं होता। Pyomo में स्केलर वेरिएबल परिभाषित करने के लिए आप pyomo.environ मॉड्यूल की Var क्लास का उपयोग करते हैं।

from pyomo.environ import Var
model.x = Var()संचालित द्वारा

हम पहले Var इम्पोर्ट करते हैं और Var() का उपयोग करके x नामक वेरिएबल बनाते हैं। इस वेरिएबल की कोई निर्धारित सीमाएँ नहीं हैं, यानी यह तब तक कोई भी वास्तविक मान ले सकता है जब तक कि मॉडल में अन्यथा बाधित न किया गया हो।

सीमाएँ जोड़ना

आप सीमाएँ निर्दिष्ट करके किसी वेरिएबल के मानों को सीमित कर सकते हैं। सीमाएँ एक ट्यूपल (lower_bound, upper_bound) के रूप में परिभाषित की जाती हैं:

from pyomo.environ import Var
model.x = Var(bounds=(0, None))संचालित द्वारा

डोमेन निर्दिष्ट करना

Pyomo पूर्वनिर्धारित डोमेन्स प्रदान करता है जिनका उपयोग आप यह निर्दिष्ट करने के लिए कर सकते हैं कि वेरिएबल किस प्रकार के मान ले सकता है, जैसे NonNegativeReals, Integers, या Binary: 

from pyomo.environ import Var, NonNegativeReals
model.x = Var(domain=NonNegativeReals)संचालित द्वारा

इंडेक्स्ड वेरिएबल्स

जब समान प्रकृति वाले कई वेरिएबल्स से निपटना हो, जैसे विभिन्न समयावधियों या वस्तुओं का प्रतिनिधित्व करने वाले वेरिएबल्स, तो इंडेक्स्ड वेरिएबल्स का उपयोग करना कुशल होता है। इंडेक्स्ड वेरिएबल्स ऐसे वेरिएबल्स होते हैं जो किसी सेट पर परिभाषित होते हैं।

import pyomo.environ as pyo
model.I = pyo.Set(initialize=[1, 2, 3])
model.y = pyo.Var(model.I, domain=pyo.NonNegativeReals)संचालित द्वारा

मान लीजिए आप तीन उत्पादों के उत्पादन मात्रा को मॉडल कर रहे हैं। आप इस प्रकार परिभाषित कर सकते हैं:

model.Products = pyo.Set(initialize=['A', 'B', 'C'])
model.production = pyo.Var(model.Products, domain=pyo.NonNegativeReals)संचालित द्वारा

अब, model.production['A'], model.production['B'], और model.production['C'] क्रमशः उत्पाद A, B, और C के उत्पादन मात्रा का प्रतिनिधित्व करते हैं।

2. उद्देश्यों को परिभाषित करना

उद्देश्य फ़ंक्शन वह है जिसे हम ऑप्टिमाइज़ (न्यूनतम या अधिकतम) करने का प्रयास कर रहे हैं। यह मॉडल के लक्ष्य को परिभाषित करता है, जैसे लागत को न्यूनतम करना या लाभ को अधिकतम करना, और आमतौर पर निर्णय वेरिएबल्स से जुड़े गणितीय समीकरण के रूप में व्यक्त किया जाता है। 

इन्हें Objective क्लास का उपयोग करके परिभाषित किया जाता है:

from pyomo.environ import ConcreteModel, Var, Objective, minimize, maximize, NonNegativeReals
# Create a model
model = ConcreteModel()
# Define variables
model.x = Var(within=NonNegativeReals)
model.y = Var(within=NonNegativeReals)
# Minimization (cost)
model.cost = Objective(expr=2 * model.x + 3 * model.y, sense=minimize)
# When Maximization profit - (can have one objective at a time)
# model.profit = Objective(expr=5 * model.x + 4 * model.y, sense=maximize)संचालित द्वारा

3. बाधाएँ जोड़ना

बाधाएँ समस्या की सीमाएँ या आवश्यकताओं को परिभाषित करती हैं:

from pyomo.environ import Constraint
model.con1 = Constraint(expr=model.x + model.y >= 10)संचालित द्वारा

ऊपर दिया गया उदाहरण Constraint क्लास का उपयोग करके Pyomo मॉडल में एक बाधा परिभाषित करता है। बाधा model.con1 यह निर्दिष्ट करती है कि वेरिएबल्स x और y का योग 10 से अधिक या बराबर होना चाहिए।

4. मॉडलों को पैरामीटराइज़ करना

पैरामीटर्स वे स्थिर मान होते हैं जिनका उपयोग मॉडल में ज्ञात मात्राओं या उन स्थिरांकों का प्रतिनिधित्व करने के लिए किया जाता है जो ऑप्टिमाइज़ेशन प्रक्रिया के दौरान नहीं बदलते। 

वे वेरिएबल्स और बाधाओं के बीच संबंधों को परिभाषित करने में मदद करते हैं, वास्तविक दुनिया के डेटा या मान्यताओं को शामिल करके मॉडल को संरचना प्रदान करते हैं:

from pyomo.environ import Param
model.p = Param(initialize=5)संचालित द्वारा

ऊपर का कोड Pyomo मॉडल में Param क्लास का उपयोग करके पैरामीटर p परिभाषित करता है और इसे 5 के स्थिर मान से इनिशियलाइज़ करता है। पैरामीटर p अब मॉडल में उस स्थिर मान का प्रतिनिधित्व करने के लिए उपयोग किया जा सकता है जो ऑप्टिमाइज़ेशन प्रक्रिया के दौरान नहीं बदलता।

अब, एक एंड-टू-एंड ऑप्टिमाइज़ेशन समस्या पर काम करते हैं!

Pyomo एंड-टू-एंड उदाहरण

आइए Pyomo का उपयोग करके ऑप्टिमाइज़ेशन समस्या को हल करने का एक एंड-टू-एंड उदाहरण देखें। हम एक वास्तविक परिदृश्य का मॉडल बनाएँगे जहाँ एक फैक्ट्री दो उत्पाद बनाती है, और लक्ष्य मशीन समय सीमाओं को ध्यान में रखते हुए लाभ को अधिकतम करना है। 

1. समस्या विवरण

एक फैक्ट्री दो उत्पाद, P1 और P2, बनाती है। प्रति यूनिट लाभ:

• P1: $40
• P2: $50

उपलब्ध मशीन समय:

• Machine A: 100 घंटे
• Machine B: 80 घंटे
• Machine C: 90 घंटे

प्रति यूनिट आवश्यक समय:

उद्देश्य: लाभ को अधिकतम करना।

निर्णय वेरिएबल्स:

• x₁: बनाने के लिए P1 की यूनिट्स।
• x₂: बनाने के लिए P2 की यूनिट्स।

2. गणितीय फॉर्म्युलेशन

उद्देश्य फ़ंक्शन:

अधिकतम करें Z = 40x₁ + 50x₂

बाधाएँ:

1. मशीन A क्षमता: 1x₁ + 2x₂ ≤ 100
2. मशीन B क्षमता: 2x₁ + 1x₂ ≤ 80
3. मशीन C क्षमता: 3x₂ ≤ 90
4. गैर-ऋणात्मकता: x₁, x₂ ≥ 0

3. कार्यान्वयन

समस्या के उद्देश्य और बाधाओं के आधार पर, यहाँ GLPK का उपयोग करते हुए इसे मॉडल करने के लिए Python कोड दिया गया है।

# 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}')संचालित द्वारा

आउटपुट:

>>> Solver Status: ok
>>> Termination Condition: optimal
>>> Optimal production of P1 (x1): 25.0
>>> Optimal production of P2 (x2): 30.0
>>> Maximum Profit: $2500.0संचालित द्वारा

ऊपर के कोड में, हम दो उत्पादों (P1 और P2) के उत्पादन से लाभ को अधिकतम करने के लिए एक रैखिक ऑप्टिमाइज़ेशन मॉडल परिभाषित करते हैं। उद्देश्य फ़ंक्शन लाभ को अधिकतम करने के लिए सेट है, जहाँ P1 की प्रत्येक यूनिट $40 और P2 की प्रत्येक यूनिट $50 का योगदान देती है।

हमने मशीन A, B, और C के मशीन समय सीमा का प्रतिनिधित्व करने वाली तीन बाधाएँ लगाई हैं। 

अंत में, हम समस्या को हल करने के लिए GLPK सॉल्वर का उपयोग करते हैं। 

अंतिम उत्तर यह है कि P1 की 25 यूनिट और P2 की 30 यूनिट का उत्पादन करें, जहाँ हमारा अधिकतम लाभ $2,500 होगा।

Pyomo में उन्नत विशेषताएँ

पिछले सेक्शन में, हमने देखा कि Pyomo के साथ एंड-टू-एंड ऑप्टिमाइज़ेशन समस्या को लागू करना कितना आसान है। हालांकि, अधिकांश वास्तविक जीवन की समस्याएँ सीधे हल नहीं होतीं।

इस सेक्शन में, मैं कुछ उन्नत विशेषताएँ प्रस्तुत कर रहा हूँ जिनका उपयोग आप अधिक जटिल परिदृश्यों को हल करने के लिए कर सकते हैं।

1. गैर-रैखिक ऑप्टिमाइज़ेशन

गैर-रैखिक ऑप्टिमाइज़ेशन गैर-रैखिक बाधाओं के अधीन किसी गैर-रैखिक उद्देश्य फ़ंक्शन को न्यूनतम या अधिकतम करती है। आइए एक उदाहरण देखें जहाँ हम एक वृत्ताकार बाधा के अधीन वर्गांतरों (squared differences) के योग को न्यूनतम करते हैं।

समस्या विवरण

उद्देश्य न्यूनतम करें: Z = (x - 1)² + (y - 2)²

बाधाएँ:

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

Pyomo में, हम निर्णय वेरिएबल्स x और y को 0 की निम्न सीमा के साथ परिभाषित कर सकते हैं ताकि गैर-ऋणात्मकता सुनिश्चित हो। उद्देश्य फ़ंक्शन को विशिष्ट बिंदुओं से वर्गांतरों के योग के रूप में लिखा जाता है, और बाधा यह सुनिश्चित करती है कि समाधान त्रिज्या 2 वाले वृत्त के भीतर स्थित हो।

इस मामले में, इसकी गैर-रैखिक ऑप्टिमाइज़ेशन समस्या-समाधान क्षमता के लिए IPOPT सॉल्वर उपयुक्त है:

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. मिक्स्ड-इंटिजर प्रोग्रामिंग (MIP)

मिक्स्ड-इंटिजर प्रोग्रामिंग तब उपयोग होती है जब कुछ निर्णय वेरिएबल्स पूर्णांक (अक्सर बाइनरी) होते हैं जबकि अन्य सतत होते हैं। यह फैसिलिटी लोकेशन और प्रोडक्शन प्लानिंग जैसे निर्णय-निर्धारण समस्याओं के लिए मूल्यवान है।

समस्या विवरण

किसी कंपनी को स्थान A, B, और C में वेयरहाउस खोलने का निर्णय लेना है। उद्देश्य कुल लागत को न्यूनतम करना है, जिसमें वेयरहाउस खोलने की स्थिर लागत और परिवहन लागत शामिल हैं।

हम डेटा को इनिशियलाइज़ करके शुरू करते हैं, जिसमें वेयरहाउस खोलने की स्थिर लागत, परिवहन लागत, क्षमता सीमाएँ, और कुल मांग शामिल है: 

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))संचालित द्वारा

मॉडल में दो प्रकार के निर्णय वेरिएबल्स शामिल हैं: एक बाइनरी वेरिएबल y जो यह दर्शाता है कि वेयरहाउस खुला है या नहीं (खुला होने पर 1, अन्यथा 0), और एक सतत वेरिएबल x जो प्रत्येक वेयरहाउस से परिवहन की गई वस्तुओं की मात्रा का प्रतिनिधित्व करता है। 

उद्देश्य फ़ंक्शन प्रत्येक वेयरहाउस की स्थिर लागत और परिवहन लागत का योग करता है और कुल को न्यूनतम करता है। बाधाएँ सुनिश्चित करती हैं कि कुल परिवहन की गई वस्तुएँ मांग को पूरा करें और यदि वेयरहाउस खुला है तो उसकी क्षमता से अधिक न हों। 

3. एकाधिक उद्देश्यों को संभालना

कभी-कभी, ऑप्टिमाइज़ेशन समस्याओं में कई उद्देश्य शामिल होते हैं जो परस्पर-विरोधी हो सकते हैं, जैसे लाभ को अधिकतम करना और पर्यावरणीय प्रभाव को न्यूनतम करना। एक सामान्य तरीका है वेटेड सम मेथड, जहाँ प्रत्येक उद्देश्य को उसकी महत्त्वता के अनुसार वेट दिया जाता है।

समस्या विवरण

हम लाभ को अधिकतम करते हुए पर्यावरणीय प्रभाव को न्यूनतम करना चाहते हैं:

• लाभ: Z₁ = 3x + 5y
• पर्यावरणीय प्रभाव: Z₂ = 2x + y

हम इन उद्देश्यों को वेट w1=0.6, w2=0.4 का उपयोग करके संयोजित कर सकते हैं, जहाँ कुल उद्देश्य एक वेटेड सम बन जाता है:

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
)संचालित द्वारा

इस संयोजित उद्देश्य में, हम वेट्स को समायोजित करके लाभ को अधिकतम करते हुए पर्यावरणीय प्रभाव को न्यूनतम करते हैं।

4. बाहरी डेटा स्रोतों का उपयोग

बड़े डेटासेट्स से निपटते समय, CSV फ़ाइलों जैसे बाहरी स्रोतों से डेटा आयात करना उपयोगी होता है। Pyomo, बाहरी डेटा पढ़ने और उपयोग करने के लिए Pandas के साथ अच्छी तरह काम करता है।

हम Pandas का उपयोग करके CSV फ़ाइल पढ़ सकते हैं और डेटा का उपयोग अपने मॉडल में सेट्स और पैरामीटर्स को इनिशियलाइज़ करने के लिए कर सकते हैं:

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)संचालित द्वारा

Pyomo के उपयोग के लिए टिप्स और सर्वोत्तम अभ्यास

Pyomo के साथ काम करते समय, यह महत्वपूर्ण है कि आपके मॉडल कुशल, अच्छी तरह से प्रलेखित, और आसानी से ट्रबलशूट होने योग्य हों। 

1. डिबगिंग और ट्रबलशूटिंग

Pyomo में ऑप्टिमाइज़ेशन मॉडल बनाते समय, अव्यवहार्य (infeasible) समाधान, सॉल्वर विफलताएँ, या गलत परिणाम जैसी समस्याओं का सामना करना आम है। डिबगिंग के लिए कुछ सर्वोत्तम अभ्यास यहाँ दिए गए हैं:

• बाधाएँ जाँचें: यदि आपका मॉडल व्यवहार्य समाधान नहीं दे रहा है, तो अपनी बाधाओं की समीक्षा करें। बहुत सख्त बाधाएँ समस्या को अव्यवहार्य बना सकती हैं। वेरिएबल्स और बाधाओं के मान प्रिंट करने के लिए Pyomo की .display() विधि का उपयोग करें ताकि यह सत्यापित किया जा सके कि वे अपेक्षा के अनुसार व्यवहार कर रहे हैं।
• सॉल्वर आउटपुट: solve() मेथड कॉल करते समय tee=True पास करके विस्तृत सॉल्वर लॉग सक्षम करें। इससे यह समझने में मदद मिल सकती है कि सॉल्वर कहाँ संघर्ष कर रहा है, जैसे अनबाउंडेड वेरिएबल्स या अव्यवहार्यता।
• सबसे पहले सरल मॉडल टेस्ट करें: जटिल मॉडलों से निपटते समय, एक सरलीकृत संस्करण का परीक्षण करें। इससे बिना पूरी तरह निर्दिष्ट मॉडल के ओवरहेड के संभावित समस्याओं को अलग करने में मदद मिलती है।

यदि आप व्यवस्थित रूप से आगे बढ़ते हैं—बाधाओं, उद्देश्य फ़ंक्शन, और सॉल्वर फीडबैक का विश्लेषण करते हुए—तो ट्रबलशूटिंग कहीं आसान हो जाती है।

2. मॉडलिंग दक्षता

जैसे-जैसे मॉडल का आकार बढ़ता है, ऑप्टिमाइज़ेशन समस्याएँ कम्प्यूटेशनली महंगी हो सकती हैं। कुशल मॉडलिंग सुनिश्चित करने के लिए, निम्नलिखित सुझावों पर विचार करें:

• स्पार्सिटी का उपयोग करें: बाधाओं या उद्देश्यों को परिभाषित करते समय अनावश्यक इंडेक्स पर लूपिंग से बचें। अपने समस्या में स्पार्सिटी का लाभ उठाने से कम्प्यूटेशन समय कम होता है।
• बाइनरी बनाम सतत वेरिएबल्स: जहाँ संभव हो, बाइनरी या पूर्णांक वेरिएबल्स की संख्या कम करें। सतत वेरिएबल्स सॉल्वर के लिए संभालना आसान होते हैं, जिससे तेज़ समाधान मिलते हैं।
• बाधा फॉर्म्युलेशन: बाधाओं को गणितीय रूप से और इम्प्लीमेंटेशन में यथासंभव सरल रखें। अनावश्यक गैर-रैखिकताओं से बचें और जटिल बाधाओं को छोटे, प्रबंधनीय हिस्सों में विभाजित करें।

कुशल मॉडल तेज़ी से हल होते हैं और डिबग और मेंटेन करना आसान होता है।

3. प्रलेखन और रखरखाव

दीर्घकालिक उपयोग और सहयोग के लिए अच्छी तरह से प्रलेखित Pyomo मॉडल बनाए रखना एक अच्छा अभ्यास है। अच्छा प्रलेखन मॉडलों को समय-समय पर फिर से देखने और अपडेट करना भी आसान बनाता है:

• इनलाइन टिप्पणियाँ उपयोग करें: वेरिएबल्स, बाधाओं, और उद्देश्य फ़ंक्शन के उद्देश्य को समझाने के लिए हमेशा टिप्पणियाँ जोड़ें। यह विशेष रूप से ऑप्टिमाइज़ेशन मॉडलों में महत्वपूर्ण है, जहाँ तर्क तुरंत स्पष्ट नहीं हो सकता।
• अपने कोड को मॉड्यूलर बनाएं: अपने मॉडल को तार्किक सेक्शनों या अलग-अलग फ़ंक्शनों में विभाजित करें। यह मॉड्यूलर दृष्टिकोण पठनीयता में सुधार कर सकता है और मॉडल के विशिष्ट हिस्सों को डिबग और संशोधित करना आसान बना सकता है।
• मॉडल परिवर्तनों का ट्रैक रखें: यदि आपका मॉडल विकसित हो रहा है, तो उसका वर्शन इतिहास रखें। परिवर्तनों को ट्रैक करने और यह सुनिश्चित करने के लिए कि कोई भी अपडेट या सुधार ट्रेस किए जा सकें, Git जैसे वर्शन कंट्रोल टूल्स का उपयोग करें।

उचित प्रलेखन और संरचित कोड आपके Pyomo मॉडलों को भविष्य के सहयोगियों के लिए अधिक सुलभ बनाएगा और आपकी आवश्यकताओं के विकसित होने के साथ उन्हें स्केल या संशोधित करना आसान करेगा।

निष्कर्ष

Pyomo Python में ऑप्टिमाइज़ेशन मॉडल बनाने और हल करने के लिए एक शक्तिशाली और लचीला टूल है। इस ट्यूटोरियल के दौरान, हमने देखा कि Pyomo उपयोगकर्ताओं को रैखिक प्रोग्रामिंग से लेकर गैर-रैखिक और मिक्स्ड-इंटिजर प्रोग्रामिंग तक विभिन्न ऑप्टिमाइज़ेशन समस्याओं को मॉडल करने की अनुमति कैसे देता है। 

अपनी यूज़र-फ्रेंडली सिंटेक्स और सॉल्वर्स के साथ इंटीग्रेशन के साथ, Pyomo वास्तविक दुनिया की ऑप्टिमाइज़ेशन समस्याओं को फॉर्म्युलेट और हल करना शुरुआती और उन्नत दोनों उपयोगकर्ताओं के लिए सुलभ बनाता है।

यदि आप ऑप्टिमाइज़ेशन के साथ वास्तविक दुनिया की समस्याओं को हल करने के बारे में अधिक सीखने में रुचि रखते हैं, तो DataCamp पर Introduction to Optimization in Python निःशुल्क कोर्स देखें!