אופטימיזציה עם פיימו: מדריך שלב-אחר-שלב מקיף

הגדרת 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: ווינדוארס:.
• macOS: 

brew install glpk

• לינUX: 

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 הוא מתווכה חזקה שעוצבה עבור בעיות תכנון לא-lineארי גדולות (NLP).

היא מועדיפה במיוחד לטיפול במודלים לא-lineאריים מורכבים, ולכן היא בחירה מעולה עבור בעיות מעבר לאופטימיזציה לינארית.

IPOPT יכול להיות מו Instalado דרך מנהל הערכים conda.

!conda install -c conda-forge ipopt

מפתחים מסחריים

1. CPLEX

CPLEX הוא מפתח יעיל לעיצוב שמטפל בבעיות תוכנות לינארית (LP), בעיות תוכנות מקצועיות מערבודה (MIP), ובעיות תוכנות קואקרטיות (QP).

הוא דורש רשיון מאבם אבל זמין בחינם למשתמשים אקדמיים, וזה יוצא מהכלל למטרות המחקר והחינוך.

2. Gurobi

גורביהוא פתרון מותקן מוביל שידוע במהירות ויעילות שלו בפתרון בעיות פעילויות פשוטות (LP), בעיות מיתרים בעלי משקל (MIP), בעיות משקל מערכתיות (QP), ובעיות תכנון לא-线性 (NLP).

כמו CPLEX, הוא דורש לייצרים רשיון, אך מעניק גישה חינמית למשתמשים אקדמיים. כך שהוא כלי סטנדרט בתעשייה להתאמה עדכנית.

פתרונות פתוחי מקור נגד פתרונות מסחריים

פתרונות פתוחים כמו GLPK ו CBC הם חינמיים ומספקים ברוב הדרכים הבסיסיות להתאמה מועדית. הם בחירות מעולות עבור פרוייקטים קטנים יותר ולמטרות חינוכיות.

אך פתרונות מסחריים כמו CPLEX ו Gurobi מציעים בדרך כלל ביצועים טובים יותר, בעיקר עבור בעיות גדולות יותר ומורכבות. הפתרונות האלה מקבלים תכונות מתקדמות, כולל תמיכה משנה בתוכנות קואדריטיות ולאונליניות, ומותאמים עבור יישומות תעשייתיים בקנה מידה גדול.

למרות שפתרונות פתוחים יכולים להתמודד עם הרבה מהמשימות הרגילות של התאמה מועדית, פתרונות מסחריים הם לרוב אפשרות טובה יותר כשמעבדים דרישות מורכבות יותר ועם דרישות ביצועים גבוהות.

שימו לב שלפתרונות מסחריים דרושה רשיון, אף על-פי שהם זמינים בחינם למשתמשים אקדמיים.

עכשיו, בואו נראה איך להגדיר מתמך בפייומו. אני אשתמש בGLPK במקרה זה.

3. הגדרת מתמך בפייומו

קודם כל, ודא שהיישומך של המתמך נמצא במסלול PATH של המערכת אחרי ההתקנה.

אחר כך, יצירו תוכנה פיתוח בפינגווין והוסיפו את התוכניות הבאה:

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

כדי לוודא שגם פייומו ומתמך הסולובר שלך מותקנים בצורה נכונה, בואו נפתור בעיית הבדיקה הפשוטה הבאה.

בעיית בדיקה: תוכנית לינארית פשוטה

מטרה: הקטנתZ=x+y

תחת:

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

הבעיה הזו היא למצוא את הערך הקטן ביותר שלZ, שהוא הסכם של שני משתנים,x וy. עם זאת,x וy חייבים להיות מול מספר תנאים.

ראשית, כשאתה מוסיף x ופעמים כפולות y, התוצאה חייבת להיות לפחות 4. שנית, x פחות או שווה לy. לבסוף, שני x ו y חייבים להיות אפס או מספרים חיוביים (הם לא יכולים להיות שליליים). 

המטרה היא למצוא ערכים של x וy שמותגמלים בתנאים האלה בזמן שZ מייצג סמך מינימלי.

יישום בעזרת Pyomo:

import pyomo.environ as pyo
# יצירת מודל
model = pyo.ConcreteModel()
# הגדרת משתנים
model.x = pyo.Var(within=pyo.NonNegativeReals)
model.y = pyo.Var(within=pyo.NonNegativeReals)
# הגדרת מטרה
model.obj = pyo.Objective(expr=model.x + model.y, sense=pyo.minimize)
# הגדרת הגבלות
model.con1 = pyo.Constraint(expr=model.x + 2 * model.y >= 4)
model.con2 = pyo.Constraint(expr=model.x - model.y <= 1)
# בחירת מתקnov
solver = pyo.SolverFactory('glpk')
# פתרון הבעיה
result = solver.solve(model)
# הצגת התוצאות
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, שיכולים לקבל רק ערכים לא נגative. המטרה של המודל היא למינוי את הסכמת x ו y (x + y). הקוד מגדיר את הפתרון כ glpk על מנת למצוא את הערכים האופטימליים של x ו y שמושגים את התנאים האלה בזמן שמיינות את המטרה העליונה.

אחרי שהקוד נרץ, אנחנו מוצאים שהערכים האופטימליים למשתנים הם x = 0.0 וy = 2.0, שמיינמים את הפונקצייה המטרתית Z = x + y. לכן, הערך המינימלי של הפונקצייה המטרתית הוא 2.0, שמשמש את הדברים הנתונים הנתונים האלה.

בסיסים של מודלים ב Pyomo

נדרשת הבנה על איך להגדיר את הרכיבים הבסיסיים של מודל אופטימציה ב Pyomo על מנת להגדיר ולפתור בצורה יעילה בעיות אופטימציה.

1. הגדרת משתנים

משתנים מייצגים את ההחלטות הנדרשות במערכת האופטימציה. ב Pyomo, הם המספרים שהמתקן ישנה כדי להאטות את הפעילות המטרתית בעוד שהוא ממשיך למלא את כל התורות.

משתנים סקלאריים

משתנים סקלאריים הם משתנים יחידים שאינם מודורכים על קבוצה כלשהי. כדי להגדיר משתנה סקלארי ב Pyomo, אתה משתמש במודול Var ממודול pyomo.environ.

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

אנחנו ראשית מיישמים Var ויוצרים משתנה x בעזרת Var(). המשתנה הזה לא מקבל גבולות מסוימים, אז הוא יכול לקבל את כל מספר הערך האמיתי אלא אם יוצא מהתורה המסוימת במודל.

הוספת גבולות

ניתן להגביל את הערכים של משתנה על-ידי ספציפיות מגבלות. מגבלות מוגדרות בצורה של קבוצה (lower_bound, upper_bound):

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

ספציפיות מידות

פייומו מספק ספציפיות מוגדלות שניתן להשתמש בהן על מנת לספק את הסוגים האפשריים של ערכים שהמשתנה יכולה לקבל, כמו 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
# יצירת מודל
model = ConcreteModel()
# הגדרת משתנים
model.x = Var(within=NonNegativeReals)
model.y = Var(within=NonNegativeReals)
# המיטבות (עלויות)
model.cost = Objective(expr=2 * model.x + 3 * model.y, sense=minimize)
# כשרווחים הגבירות - (ניתן להיות מטרה אחת בזמן אחד)
# 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)

הדוגמה העליונה מגדירה מגבלה במודל Pyomo בעזרת המיקום הConstraint.המגבלהmodel.con1מספקת שסך המשתניםx וy צריך להיות גדול או שווה ל10.

4. מודלים מורכבים

משתנים הם ערכים קבועים שמשתמשים במודל כדי לייצג מספרים ידועים או קבועים שלא משתנים בזמן תהליך האופטימציה.

הם עוזרים להגדיר את היחסים בין המשתנים והמגבלות, מספקים מבנה למודל על-ידי הכנת מידע מהעולם האמיתי או הנחות:

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

הקוד העליון מגדיר משתנה p במודל Pyomo בעזרת מחלקת Param ומרגע אותו עם ערך קבוע של 5. המשתנה p עכשיו יכול להיות משמש במודל כדי לייצג ערך קבוע שלא משתנה בזמן האופטימציה.

עכשיו, בואו נעבוד על בעיית העיצוב הברירית המושלמת!

דוגמא מולבלת לקריאת Pyomo

בואו נראה דוגמא מולבלת לפתרון בעיית העיצוב הברירית בעזרת Pyomo. אנחנו נעצב מודל למצב משמעותי בעולם האמיתי, בו מפעל מייצר שני מוצרים, P1 ו P2, והמטרה היא להגביר רווח בעוד שנשקל את המגבלות של זמנת המכונות.

1. הצעת הבעיה

מפעל מייצר שני מוצרים, P1 ו P2. הרווח ליחידה הוא:

• P1: $40
• P2: 50 דולר

זמן מכונה זמין:

• מכונת A: 100 שעות
• מכונת B: 80 שעות
• מכונת המעבדה השלישית: 90 שעות

הזמן הדרוש לייצור של יחידה:

מטרה: להגביר את הרווח.

משתנים החלטתיים:

• x₁: יחידות של P1 לייצור.
• חלקים של 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.

# שלב 1: ייבאו ספקנים
import pyomo.environ as pyo
# שלב 2: יצירת מודל מוצק
model = pyo.ConcreteModel()
# שלב 3: הגדרת משתנים החלטה (יחידות P1 וP2 לייצור)
model.x1 = pyo.Var(within=pyo.NonNegativeReals)
model.x2 = pyo.Var(within=pyo.NonNegativeReals)
# שלב 4: הגדרת הפעלה המטרתית (הגדרת רווח מירבי)
model.profit = pyo.Objective(expr=40 * model.x1 + 50 * model.x2, sense=pyo.maximize)
# שלב 5: הגדרת המגבלות
# מגבלת המכונת A: 1x1 + 2x2 <= 100
model.machine_a = pyo.Constraint(expr=1 * model.x1 + 2 * model.x2 <= 100)
# מגבלת המכונת B: 2x1 + 1x2 <= 80
model.machine_b = pyo.Constraint(expr=2 * model.x1 + 1 * model.x2 <= 80)
# מגבלת המכונת C: 3x2 <= 90
model.machine_c = pyo.Constraint(expr=3 * model.x2 <= 90)
# שלב 6: פתרון המודל בעזרת מתקנת GLPK
solver = pyo.SolverFactory('glpk')
result = solver.solve(model)
# שלב 7: ניתוח התוצאות
# הצגת מצב הפתרון ותנאי הסיימון
print('Solver Status:', result.solver.status)
print('Termination Condition:', result.solver.termination_condition)
# השלמת והצגת הערכים האופטימליים עבור x1, x2, והרווח המירבי
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 כדי לפתור את הבעיה.

התשובה הסופית היא לייצר 25 יחידות של P1 ו30 יחידות של P2 בהם הרווח המירבי יהיה $2,500.

תכונות מתקדמות בPyomo

בסECTION הקודמת, ראינו כמה קל להשתמש בPyomo ליישם בעיה של אופטימיזציה סוף-לסוף. אך רוב הבעיות בחיים המציאות אינן פשוטות לפתרון.

בסECTION הזו, אני מציג כמה תכונות מתקדמות שאתה יכול להשתמש בהן לפתור סיטואציות מורכבות יותר.

1. אופטימיזציית לא-לינארית

אופטימיזציית לא-לינארית מיינמית או מגבירה פונקציית מטרה לא-לינארית בהתנגדות להגבלות לא-לינאריות. בואו נסתכל על דוגמה בה אנחנו מיינמים את השונית העליונה של ההבדלים העומדים בקיר בהתנגדות להגבלה עיגולית.

משפט הבעיה

מינימיze את המטרה: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()
# הגדרת משתנים עם מינומים למטה
model.x = pyo.Var(bounds=(0, None))
model.y = pyo.Var(bounds=(0, None))
# פונקציית המטרה: הפחתת (x - 1)² + (y - 2)²
model.obj = pyo.Objective(expr=(model.x - 1)**2 + (model.y - 2)**2, sense=pyo.minimize)
# המגבלה: x² + y² ≤ 4 (מעגל עם רדיוס 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()
# משתנה בינארי: 1 אם המחסן פתוח, אחרת 0
model.y = pyo.Var(locations, domain=pyo.Binary)
# משתנה ממוצע: מספר הטעמים שמעברים
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
)
# מגבלה על הדרישה
model.demand = pyo.Constraint(expr=sum(model.x[i] for i in locations) >= Demand)
# מגבלות הכפיה
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) לקריאה ושימוש במידע מקורים חיצוניים.

אנחנו יכולים לקרוא קבץ CSV בעזרת פאנדס ולהשתמש במידע כדי להתחיל סטים ופרמטרים במודל שלנו:

import pandas as pd
data = pd.read_csv('parameters.csv')
# הגדרה של מערך מהמידע בקבץ CSV
model.I = pyo.Set(initialize=data['index'].unique())
# הגדרה של פרמטר שמתחיל מהמידע בקבץ CSV
param_dict = data.set_index('index')['value'].to_dict()
model.param = pyo.Param(model.I, initialize=param_dict)

עידודים ומיטב המידע לשימוש בפייומו

בעבדה עם פייומו, חשוב לשמור על המודלים שלך יעילים, מודעים וקלים לבדיקה.

1. בדיקה וטיפול בבעיות

בעת בניית מודלים אופטימיזציה בפייומו, זה שגיא להתמודד עם בעיות כמו פיתרונות בלתי אפשריים, כשלים במתקן החיצון או תוצאות שגויות. הנה כמה עידודים המתאימים עבור בדיקה:

• בחינוך מגבלות:הסתכלו על המגבלות שלכם אם המודל שלכם אינו מפיק פתרון מתאים. מגבלות צרות יכולות להפוך בעיה לבעיה בלתי-מתאימה. השתמשו בשיטת Pyomo בשיטה .display() כדי להדפיס את הערכים של המשתנים והמגבלות כדי לוודא שהם מתנהגים כפי שצפוי.
• פלט ממתכנן:הפעילו מסמכים מפורטים מאוד של המתכנן על-ידי עבירת tee=True בזמן הקריאה לשימוש בשיטה solve(). זה עשוי לספק תובנות על המקומות בהם המתכנן עשוי להתקשות, כמו משתנים בלתי-מגבלים או בלתי-מתאימות.
• בואו נבדוק מודלים פשוטים ראשונה: כשמתמודדים עם מודלים מורכבים, בואו נבדוק גרסה פשוטה. זה יכול לעזור להביד את הבעיות הפוטנציאליות בלי העומס העליון של מודל מסובך לחלוטין.

הדיקה הוא הרבה יותר קלה אם תגיעו אליה באופן שיטתי, באנליזה של המגבלות, הפעילויות המטרתית והמשובים מהמפעיל.

2. יעילות בעיצוב

בעיות האופטימיזציה יכולות להיות מוניטניות מבחינת המחשבה כשהגודל של המודל גדלה. כדי לוודא שיהיה עיצוב יעיל, בואו נחשוב על הטיפוסים הבאים:

• משתמשים ברעיון החלקיות: המנעות מהליוויין באינדקסים לא נחוצים בזמן הגדרת הדחיפות או המטרות. השימוש בחלקיות בבעיה שלך מצמצם את זמת החישוב.
• מטרה בינרית או מטרה מתמשכת: במקום אפשרי, מפחית את מספר המטרות הבינריות או המספרות. מטרות מתמשכות קלות יותר למתפעלים, מובילה לפתרונות מהרים יותר.
• הגדרת דחיפות: שמרו על הדחיפות פשוטות ככל האפשר, בצורה מתמטית ובייצוג. אינטראקציות לא נחוצות ופרקו את הדחיפות המורכבות לאחדים קטנים וניהלבלים.

מודלים יעילים פתרון מהר יותר וקל יותר לבדוק ולשמר.

3. תיעוד ושימור

שימור של מודלים Pyomo שמעוררים בתיעוד טוב הוא המסגרת טובה לשימוש ארוך טווח ושיתוף פעולה. תיעוד טוב גם קל יותר לחזור עליו ולעדכן את המודלים במהלך הזמן:

• השתמש בתיווך תיעוד: תמיד תוסף תיעוד כדי להסביר את המטרה של משתנים, המגבלות והפעלת המטרה. זה מאוד חשוב במודלים של התאמה בהם ההגיון עשוי לא להיות ברור במקרה אחד.
• מודולריזה את הקוד שלך:פרק את המודל שלך לחלקים הגיוניים או אפילו לפונקציות נפרדות. הגישה המודולרית הזו יכולה לשפר את קריאת הקוד ולהקל על התייחסות ושינויים ספציפיים בחלקים מסויימים של המודל.
• עדיפו על היסטוריית שינויים במודל:שמהגידול בהיסטוריית הגיונית של המודל שלך, בעיקר אם הוא מתפתח. השתמש בכלים לשינויים ובקידוד גיט, כדי לעקוב אחר השינויים ולהבטיח שכל העדכונים או השיפורים יוכלו להיות עוקבים אחורה.

תעודה מתאימה וקוד מבנה יהפוך את המודלים שלך בפייומו לנגישים יותר לשיתף פעולה בעתיד ויהפוך את העבודה בהם לקלה יותר בעוד הדרישות שלך מתפתחות.

סיכום

פיאומו הוא כלי עוצמתי וגמיש לבניית ופתרון מודלים של אופטימיזציה בפייתון. throughout this tutorial, בדקנו כיצד פיאומו מאפשר למשתמשים לדגם בעיות אופטימיזציה שונות, מתכנות ליניארית ועד לתכנות לא ליניארי ולתכנות עם מספרים שלמים.

עם הסינטקס הידידותי למשתמש ואינטגרציה עם פתרונות, פיאומו מקנה גישה לנוסחאות ולפתרון בעיות אופטימיזציה מעשיות עבור מתחילים ומשתמשים מתקדמים כאחד.

אם אתם מעוניינים ללמוד עוד על פתרון בעיות מעשיות באמצעות אופטימיזציה, בדקו את מבוא לאופטימיזציה בפייתון הקורס החינמי ב-DataCamp!