SciPy, വ്യവസ്ഥകളുള്ള ഒപ്റ്റിമൈസേഷൻ

SciPy (സായി പൈ എന്ന് ഉച്ചരിക്കുന്നത്) സി, ഫോർട്രാൻ ലൈബ്രറികളും ഉൾപ്പെടുന്ന ഒരു നമ്പി അടിസ്ഥാനമാക്കിയുള്ള മാത്തമാറ്റിക്സ് പാക്കേജാണ്. SciPy നിങ്ങളുടെ സംവേദനാത്മക പൈത്തൺ സെഷനെ MATLAB, IDL, Octave, R അല്ലെങ്കിൽ SciLab പോലെയുള്ള ഒരു സമ്പൂർണ്ണ ഡാറ്റാ സയൻസ് പരിതസ്ഥിതിയാക്കി മാറ്റുന്നു.

ഈ ലേഖനത്തിൽ, ഗണിത പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാന സാങ്കേതിക വിദ്യകൾ ഞങ്ങൾ പരിശോധിക്കും - scipy.optimize പാക്കേജ് ഉപയോഗിച്ച് നിരവധി വേരിയബിളുകളുടെ സ്കെയിലർ ഫംഗ്ഷനുള്ള സോപാധിക ഒപ്റ്റിമൈസേഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു. നിയന്ത്രണമില്ലാത്ത ഒപ്റ്റിമൈസേഷൻ അൽഗോരിതങ്ങൾ ഇതിനകം ചർച്ച ചെയ്തിട്ടുണ്ട് കഴിഞ്ഞ ലേഖനം. scipy ഫംഗ്‌ഷനുകളിൽ കൂടുതൽ വിശദവും കാലികവുമായ സഹായം എപ്പോഴും help() കമാൻഡ്, Shift+Tab അല്ലെങ്കിൽ ഇൻ ഉപയോഗിച്ച് ലഭിക്കും. ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ.

ആമുഖം

scipy.optimize പാക്കേജിലെ സോപാധികവും നിയന്ത്രണമില്ലാത്തതുമായ ഒപ്റ്റിമൈസേഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനുള്ള ഒരു പൊതു ഇന്റർഫേസ് ഫംഗ്ഷൻ നൽകുന്നു. minimize(). എന്നിരുന്നാലും, എല്ലാ പ്രശ്നങ്ങളും പരിഹരിക്കുന്നതിന് സാർവത്രിക രീതികളൊന്നുമില്ലെന്ന് അറിയാം, അതിനാൽ മതിയായ രീതി തിരഞ്ഞെടുക്കുന്നത് എല്ലായ്പ്പോഴും എന്നപോലെ ഗവേഷകന്റെ ചുമലിൽ പതിക്കുന്നു.
ഫംഗ്ഷൻ ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് ഉചിതമായ ഒപ്റ്റിമൈസേഷൻ അൽഗോരിതം വ്യക്തമാക്കിയിരിക്കുന്നു minimize(..., method="").
നിരവധി വേരിയബിളുകളുടെ ഒരു ഫംഗ്‌ഷന്റെ സോപാധിക ഒപ്റ്റിമൈസേഷനായി, ഇനിപ്പറയുന്ന രീതികളുടെ നടപ്പാക്കലുകൾ ലഭ്യമാണ്:

• trust-constr - കോൺഫിഡൻസ് മേഖലയിൽ ഒരു പ്രാദേശിക മിനിമം തിരയുക. വിക്കി ലേഖനം, ഹബ്രെയെക്കുറിച്ചുള്ള ലേഖനം;
• SLSQP - നിയന്ത്രണങ്ങളുള്ള സീക്വൻഷ്യൽ ക്വാഡ്രാറ്റിക് പ്രോഗ്രാമിംഗ്, ലഗ്രാഞ്ച് സിസ്റ്റം പരിഹരിക്കുന്നതിനുള്ള ന്യൂട്ടോണിയൻ രീതി. വിക്കി ലേഖനം.
• TNC - വെട്ടിച്ചുരുക്കിയ ന്യൂട്ടൺ കൺസ്ട്രെയിൻഡ്, പരിമിതമായ എണ്ണം ആവർത്തനങ്ങൾ, ധാരാളം സ്വതന്ത്ര വേരിയബിളുകളുള്ള നോൺലീനിയർ ഫംഗ്ഷനുകൾക്ക് നല്ലതാണ്. വിക്കി ലേഖനം.
• L-BFGS-B - ബ്രോയ്ഡൻ-ഫ്ലെച്ചർ-ഗോൾഡ്ഫാർബ്-ഷാനോ ടീമിൽ നിന്നുള്ള ഒരു രീതി, ഹെസ്സിയൻ മാട്രിക്സിൽ നിന്നുള്ള വെക്റ്ററുകൾ ഭാഗികമായി ലോഡുചെയ്യുന്നത് കാരണം മെമ്മറി ഉപഭോഗം കുറച്ചുകൊണ്ട് നടപ്പിലാക്കി. വിക്കി ലേഖനം, ഹബ്രെയെക്കുറിച്ചുള്ള ലേഖനം.
• COBYLA — ലീനിയർ ഏകദേശം വഴി MARE കൺസ്ട്രെയിൻഡ് ഒപ്റ്റിമൈസേഷൻ, ലീനിയർ ഏകദേശം (ഗ്രേഡിയന്റ് കണക്കുകൂട്ടൽ കൂടാതെ) ഉള്ള കൺസ്ട്രൈൻഡ് ഒപ്റ്റിമൈസേഷൻ. വിക്കി ലേഖനം.

തിരഞ്ഞെടുത്ത രീതിയെ ആശ്രയിച്ച്, പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള വ്യവസ്ഥകളും നിയന്ത്രണങ്ങളും വ്യത്യസ്തമായി സജ്ജീകരിച്ചിരിക്കുന്നു:

• ക്ലാസ് ഒബ്ജക്റ്റ് Bounds രീതികൾക്കായി L-BFGS-B, TNC, SLSQP, Trust-constr;
• പട്ടിക (min, max) ഇതേ രീതികൾക്കായി L-BFGS-B, TNC, SLSQP, Trust-constr;
• ഒരു വസ്തു അല്ലെങ്കിൽ വസ്തുക്കളുടെ ഒരു ലിസ്റ്റ് LinearConstraint, NonlinearConstraint COBYLA, SLSQP, Trust-constr രീതികൾക്കായി;
• നിഘണ്ടു അല്ലെങ്കിൽ നിഘണ്ടുക്കളുടെ പട്ടിക {'type':str, 'fun':callable, 'jac':callable,opt, 'args':sequence,opt} COBYLA, SLSQP രീതികൾക്കായി.

ലേഖനത്തിന്റെ രൂപരേഖ:
1) ഒബ്‌ജക്‌റ്റുകളായി വ്യക്തമാക്കിയ നിയന്ത്രണങ്ങളുള്ള ട്രസ്റ്റ് റീജിയണിൽ (രീതി=”ട്രസ്റ്റ്-കൺസ്‌ട്രൽ”) ഒരു സോപാധിക ഒപ്റ്റിമൈസേഷൻ അൽഗോരിതം ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക Bounds, LinearConstraint, NonlinearConstraint ;
2) ഒരു നിഘണ്ടു രൂപത്തിൽ വ്യക്തമാക്കിയ നിയന്ത്രണങ്ങളുള്ള ഏറ്റവും കുറഞ്ഞ സ്ക്വയർ രീതി (രീതി = "SLSQP") ഉപയോഗിച്ച് സീക്വൻഷ്യൽ പ്രോഗ്രാമിംഗ് പരിഗണിക്കുക {'type', 'fun', 'jac', 'args'};
3) ഒരു വെബ് സ്റ്റുഡിയോയുടെ ഉദാഹരണം ഉപയോഗിച്ച് നിർമ്മിച്ച ഉൽപ്പന്നങ്ങളുടെ ഒപ്റ്റിമൈസേഷന്റെ ഒരു ഉദാഹരണം വിശകലനം ചെയ്യുക.

സോപാധിക ഒപ്റ്റിമൈസേഷൻ രീതി="trust-constr"

രീതി നടപ്പിലാക്കൽ trust-constr ഇതിനെ അടിസ്ഥാനമാക്കി EQSQP സമത്വ രൂപത്തിന്റെ പരിമിതികളുമായുള്ള പ്രശ്നങ്ങൾക്കും ഓൺ TRIP അസമത്വങ്ങളുടെ രൂപത്തിൽ നിയന്ത്രണങ്ങളുള്ള പ്രശ്നങ്ങൾക്ക്. കോൺഫിഡൻസ് റീജിയണിൽ ഒരു ലോക്കൽ മിനിമം കണ്ടെത്തുന്നതിനായി രണ്ട് രീതികളും അൽഗോരിതങ്ങൾ മുഖേന നടപ്പിലാക്കുകയും വലിയ തോതിലുള്ള പ്രശ്നങ്ങൾക്ക് അനുയോജ്യമാണ്.

പൊതുവായ രൂപത്തിൽ മിനിമം കണ്ടെത്തുന്നതിനുള്ള പ്രശ്നത്തിന്റെ ഗണിതശാസ്ത്ര രൂപീകരണം:

കർശനമായ സമത്വ നിയന്ത്രണങ്ങൾക്കായി, താഴത്തെ പരിധി മുകളിലെ പരിധിക്ക് തുല്യമായി സജ്ജീകരിച്ചിരിക്കുന്നു .
വൺ-വേ നിയന്ത്രണത്തിനായി, മുകളിലോ താഴെയോ പരിധി സജ്ജീകരിച്ചിരിക്കുന്നു np.inf അനുബന്ധ ചിഹ്നത്തോടൊപ്പം.
രണ്ട് വേരിയബിളുകളുടെ അറിയപ്പെടുന്ന Rosenbrock ഫംഗ്‌ഷന്റെ ഏറ്റവും കുറഞ്ഞത് കണ്ടെത്തേണ്ടത് ആവശ്യമായിരിക്കട്ടെ:

ഈ സാഹചര്യത്തിൽ, അതിന്റെ നിർവചനത്തിന്റെ ഡൊമെയ്‌നിൽ ഇനിപ്പറയുന്ന നിയന്ത്രണങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നു:

ഞങ്ങളുടെ കാര്യത്തിൽ, പോയിന്റിൽ ഒരു അദ്വിതീയ പരിഹാരമുണ്ട് , ആദ്യത്തേയും നാലാമത്തെയും നിയന്ത്രണങ്ങൾ മാത്രമേ സാധുതയുള്ളൂ.
നമുക്ക് താഴെ നിന്ന് മുകളിലേക്ക് നിയന്ത്രണങ്ങളിലൂടെ കടന്നുപോകാം, അവ എങ്ങനെ സ്‌കൈപ്പിയിൽ എഴുതാമെന്ന് നോക്കാം.
നിയന്ത്രണങ്ങൾ и നമുക്ക് അതിനെ ബൗണ്ട്സ് ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് നിർവ്വചിക്കാം.

from scipy.optimize import Bounds
bounds = Bounds ([0, -0.5], [1.0, 2.0])

നിയന്ത്രണങ്ങൾ и നമുക്ക് ഇത് രേഖീയ രൂപത്തിൽ എഴുതാം:

നമുക്ക് ഈ നിയന്ത്രണങ്ങളെ ഒരു LinearConstraint ഒബ്ജക്റ്റ് ആയി നിർവചിക്കാം:

import numpy as np
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint ([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])

അവസാനമായി മാട്രിക്സ് രൂപത്തിലുള്ള നോൺ-ലീനിയർ കൺസ്ട്രൈന്റ്:

ഈ പരിമിതിയ്ക്കും ഹെസ്സിയൻ മാട്രിക്സിന്റെ ഏകപക്ഷീയമായ വെക്‌ടറിന്റെ രേഖീയ സംയോജനത്തിനും വേണ്ടി ഞങ്ങൾ യാക്കോബിയൻ മാട്രിക്സ് നിർവ്വചിക്കുന്നു. :

ഇപ്പോൾ നമുക്ക് ഒരു നോൺ-ലീനിയർ കൺസ്ട്രൈന്റ് ഒരു ഒബ്ജക്റ്റായി നിർവചിക്കാം NonlinearConstraint:

from scipy.optimize import NonlinearConstraint

def cons_f(x):
     return [x[0]**2 + x[1], x[0]**2 - x[1]]

def cons_J(x):
     return [[2*x[0], 1], [2*x[0], -1]]

def cons_H(x, v):
     return v[0]*np.array([[2, 0], [0, 0]]) + v[1]*np.array([[2, 0], [0, 0]])

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=cons_H)

വലിപ്പം വലുതാണെങ്കിൽ, മെട്രിക്സുകൾ വിരളമായ രൂപത്തിൽ സൂചിപ്പിക്കാം:

from scipy.sparse import csc_matrix

def cons_H_sparse(x, v):
     return v[0]*csc_matrix([[2, 0], [0, 0]]) + v[1]*csc_matrix([[2, 0], [0, 0]])

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1,
                                            jac=cons_J, hess=cons_H_sparse)

അല്ലെങ്കിൽ ഒരു വസ്തുവായി LinearOperator:

from scipy.sparse.linalg import LinearOperator

def cons_H_linear_operator(x, v):
    def matvec(p):
        return np.array([p[0]*2*(v[0]+v[1]), 0])
    return LinearOperator((2, 2), matvec=matvec)

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1,
                                jac=cons_J, hess=cons_H_linear_operator)

ഹെസ്സിയൻ മാട്രിക്സ് കണക്കാക്കുമ്പോൾ വളരെയധികം പരിശ്രമം ആവശ്യമാണ്, നിങ്ങൾക്ക് ഒരു ക്ലാസ് ഉപയോഗിക്കാം HessianUpdateStrategy. ഇനിപ്പറയുന്ന തന്ത്രങ്ങൾ ലഭ്യമാണ്: BFGS и SR1.

from scipy.optimize import BFGS

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())

പരിമിതമായ വ്യത്യാസങ്ങൾ ഉപയോഗിച്ചും ഹെസ്സിയൻ കണക്കാക്കാം:

nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = cons_J, hess = '2-point')

പരിമിതമായ വ്യത്യാസങ്ങൾ ഉപയോഗിച്ച് നിയന്ത്രണങ്ങൾക്കായുള്ള ജാക്കോബിയൻ മാട്രിക്സും കണക്കാക്കാം. എന്നിരുന്നാലും, ഈ സാഹചര്യത്തിൽ പരിമിതമായ വ്യത്യാസങ്ങൾ ഉപയോഗിച്ച് ഹെസ്സിയൻ മാട്രിക്സ് കണക്കാക്കാൻ കഴിയില്ല. Hessian എന്നത് ഒരു ഫംഗ്‌ഷനായി അല്ലെങ്കിൽ HessianUpdateStrategy ക്ലാസ് ഉപയോഗിച്ചിരിക്കണം.

nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = '2-point', hess = BFGS ())

ഒപ്റ്റിമൈസേഷൻ പ്രശ്നത്തിനുള്ള പരിഹാരം ഇതുപോലെ കാണപ്പെടുന്നു:

from scipy.optimize import minimize
from scipy.optimize import rosen, rosen_der, rosen_hess, rosen_hess_prod

x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hess=rosen_hess,
                constraints=[linear_constraint, nonlinear_constraint],
                options={'verbose': 1}, bounds=bounds)
print(res.x)

`gtol` termination condition is satisfied.
Number of iterations: 12, function evaluations: 8, CG iterations: 7, optimality: 2.99e-09, constraint violation: 1.11e-16, execution time: 0.033 s.
[0.41494531 0.17010937]

ആവശ്യമെങ്കിൽ, ലീനിയർ ഓപ്പറേറ്റർ ക്ലാസ് ഉപയോഗിച്ച് ഹെസ്സിയൻ കണക്കാക്കുന്നതിനുള്ള പ്രവർത്തനം നിർവചിക്കാം

def rosen_hess_linop(x):
    def matvec(p):
        return rosen_hess_prod(x, p)
    return LinearOperator((2, 2), matvec=matvec)

res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hess=rosen_hess_linop,
                 constraints=[linear_constraint, nonlinear_constraint],
                 options={'verbose': 1}, bounds=bounds)

print(res.x)

അല്ലെങ്കിൽ പരാമീറ്ററിലൂടെ ഹെസ്സിയന്റെയും ഒരു അനിയന്ത്രിതമായ വെക്റ്ററിന്റെയും ഉൽപ്പന്നം hessp:

res = minimize(rosen, x0, method='trust-constr', jac=rosen_der, hessp=rosen_hess_prod,
                constraints=[linear_constraint, nonlinear_constraint],
                options={'verbose': 1}, bounds=bounds)
print(res.x)

അല്ലെങ്കിൽ, ഒപ്റ്റിമൈസ് ചെയ്യുന്ന ഫംഗ്‌ഷന്റെ ഒന്നും രണ്ടും ഡെറിവേറ്റീവുകൾ ഏകദേശം കണക്കാക്കാം. ഉദാഹരണത്തിന്, ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഹെസ്സിയൻ ഏകദേശം കണക്കാക്കാം SR1 (അർദ്ധ-ന്യൂട്ടോണിയൻ ഏകദേശം). പരിമിതമായ വ്യത്യാസങ്ങളാൽ ഗ്രേഡിയന്റ് ഏകദേശം കണക്കാക്കാം.

from scipy.optimize import SR1
res = minimize(rosen, x0, method='trust-constr',  jac="2-point", hess=SR1(),
               constraints=[linear_constraint, nonlinear_constraint],
               options={'verbose': 1}, bounds=bounds)
print(res.x)

സോപാധിക ഒപ്റ്റിമൈസേഷൻ രീതി="SLSQP"

ഫോമിലെ ഒരു ഫംഗ്ഷൻ കുറയ്ക്കുന്നതിനുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനാണ് SLSQP രീതി രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്:

എവിടെയാണ് и - സമത്വങ്ങളുടെയോ അസമത്വങ്ങളുടെയോ രൂപത്തിൽ നിയന്ത്രണങ്ങൾ വിവരിക്കുന്ന എക്സ്പ്രഷനുകളുടെ സൂചികകളുടെ കൂട്ടം. - ഫംഗ്‌ഷന്റെ നിർവചനത്തിന്റെ ഡൊമെയ്‌നിനായി താഴ്ന്നതും മുകളിലുള്ളതുമായ പരിധികളുടെ സെറ്റുകൾ.

ലീനിയർ, നോൺലീനിയർ നിയന്ത്രണങ്ങൾ കീകളുള്ള നിഘണ്ടുക്കളുടെ രൂപത്തിൽ വിവരിച്ചിരിക്കുന്നു type, fun и jac.

ineq_cons = {'type': 'ineq',
             'fun': lambda x: np.array ([1 - x [0] - 2 * x [1],
                                          1 - x [0] ** 2 - x [1],
                                          1 - x [0] ** 2 + x [1]]),
             'jac': lambda x: np.array ([[- 1.0, -2.0],
                                          [-2 * x [0], -1.0],
                                          [-2 * x [0], 1.0]])
            }

eq_cons = {'type': 'eq',
           'fun': lambda x: np.array ([2 * x [0] + x [1] - 1]),
           'jac': lambda x: np.array ([2.0, 1.0])
          }

ഏറ്റവും കുറഞ്ഞതിനായുള്ള തിരയൽ ഇനിപ്പറയുന്ന രീതിയിൽ നടത്തുന്നു:

x0 = np.array([0.5, 0])
res = minimize(rosen, x0, method='SLSQP', jac=rosen_der,
               constraints=[eq_cons, ineq_cons], options={'ftol': 1e-9, 'disp': True},
               bounds=bounds)

print(res.x)

Optimization terminated successfully.    (Exit mode 0)
            Current function value: 0.34271757499419825
            Iterations: 4
            Function evaluations: 5
            Gradient evaluations: 4
[0.41494475 0.1701105 ]

ഒപ്റ്റിമൈസേഷൻ ഉദാഹരണം

അഞ്ചാമത്തെ സാങ്കേതിക ഘടനയിലേക്കുള്ള പരിവർത്തനവുമായി ബന്ധപ്പെട്ട്, ഒരു വെബ് സ്റ്റുഡിയോയുടെ ഉദാഹരണം ഉപയോഗിച്ച് പ്രൊഡക്ഷൻ ഒപ്റ്റിമൈസേഷൻ നോക്കാം, അത് ഞങ്ങൾക്ക് ചെറുതും എന്നാൽ സ്ഥിരതയുള്ളതുമായ വരുമാനം നൽകുന്നു. മൂന്ന് തരത്തിലുള്ള ഉൽപ്പന്നങ്ങൾ നിർമ്മിക്കുന്ന ഒരു ഗാലിയുടെ ഡയറക്ടറായി നമുക്ക് സ്വയം സങ്കൽപ്പിക്കാം:

• x0 - ലാൻഡിംഗ് പേജുകൾ വിൽക്കുന്നു, 10 ട്രിയറിൽ നിന്ന്.
• x1 - കോർപ്പറേറ്റ് വെബ്‌സൈറ്റുകൾ, 20 ട്രിൽ നിന്ന്.
• x2 - ഓൺലൈൻ സ്റ്റോറുകൾ, 30 tr മുതൽ.

ഞങ്ങളുടെ ഫ്രണ്ട്ലി വർക്കിംഗ് ടീമിൽ നാല് ജൂനിയർമാരും രണ്ട് മിഡിൽസും ഒരു സീനിയറും ഉൾപ്പെടുന്നു. അവരുടെ പ്രതിമാസ പ്രവർത്തന സമയ ഫണ്ട്:

• ജൂൺ മാസങ്ങൾ: 4 * 150 = 600 чел * час,
• മധ്യഭാഗങ്ങൾ: 2 * 150 = 300 чел * час,
• സീനിയർ: 150 чел * час.

ലഭ്യമായ ആദ്യത്തെ ജൂനിയർ (0, 1, 2) മണിക്കൂറുകൾ ഒരു സൈറ്റിന്റെ (x10, x20, x30), ഇടത്തരം - (7, 15, 20), സീനിയർ - (5, 10, 15) വികസനത്തിനും വിന്യാസത്തിനും ചെലവഴിക്കട്ടെ ) നിങ്ങളുടെ ജീവിതത്തിലെ ഏറ്റവും മികച്ച സമയത്തിന്റെ മണിക്കൂറുകൾ.

ഏതൊരു സാധാരണ സംവിധായകനെയും പോലെ, പ്രതിമാസ ലാഭം പരമാവധിയാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. വസ്തുനിഷ്ഠമായ പ്രവർത്തനം എഴുതുക എന്നതാണ് വിജയത്തിലേക്കുള്ള ആദ്യപടി value പ്രതിമാസം ഉൽപ്പാദിപ്പിക്കുന്ന ഉൽപ്പന്നങ്ങളിൽ നിന്നുള്ള വരുമാനത്തിന്റെ അളവ്:

def value(x):
    return - 10*x[0] - 20*x[1] - 30*x[2]

ഇതൊരു പിശകല്ല; പരമാവധി തിരയുമ്പോൾ, വിപരീത ചിഹ്നം ഉപയോഗിച്ച് ഒബ്ജക്റ്റീവ് ഫംഗ്ഷൻ ചെറുതാക്കുന്നു.

അടുത്ത ഘട്ടം, ഞങ്ങളുടെ ജീവനക്കാരെ അമിതമായി ജോലി ചെയ്യുന്നതിൽ നിന്ന് വിലക്കുകയും ജോലി സമയങ്ങളിൽ നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്തുകയും ചെയ്യുക എന്നതാണ്:

എന്താണ് തുല്യമായത്:

ineq_cons = {'type': 'ineq',
             'fun': lambda x: np.array ([600 - 10 * x [0] - 20 * x [1] - 30 * x[2],
                                         300 - 7  * x [0] - 15 * x [1] - 20 * x[2],
                                         150 - 5  * x [0] - 10 * x [1] - 15 * x[2]])
            }

ഉൽപ്പന്ന ഔട്ട്പുട്ട് പോസിറ്റീവ് മാത്രമായിരിക്കണം എന്നതാണ് ഒരു ഔപചാരിക നിയന്ത്രണം:

bnds = Bounds ([0, 0, 0], [np.inf, np.inf, np.inf])

അവസാനമായി, ഏറ്റവും മികച്ച അനുമാനം, കുറഞ്ഞ വിലയും ഉയർന്ന നിലവാരവും കാരണം, സംതൃപ്തരായ ഉപഭോക്താക്കളുടെ ഒരു ക്യൂ ഞങ്ങൾക്കായി നിരന്തരം അണിനിരക്കുന്നു എന്നതാണ്. പരിമിതമായ ഒപ്റ്റിമൈസേഷൻ പ്രശ്നം പരിഹരിക്കുന്നതിനെ അടിസ്ഥാനമാക്കി, പ്രതിമാസ ഉൽപ്പാദന വോള്യങ്ങൾ നമുക്ക് സ്വയം തിരഞ്ഞെടുക്കാം scipy.optimize:

x0 = np.array([10, 10, 10])
res = minimize(value, x0, method='SLSQP', constraints=ineq_cons, bounds=bnds)
print(res.x)

[7.85714286 5.71428571 3.57142857]

നമുക്ക് മുഴുവൻ സംഖ്യകളിലേക്ക് അയവായി റൗണ്ട് ചെയ്യാം, ഉൽപ്പന്നങ്ങളുടെ ഒപ്റ്റിമൽ വിതരണത്തോടെ തുഴച്ചിൽക്കാരുടെ പ്രതിമാസ ലോഡ് കണക്കാക്കാം x = (8, 6, 3) :

• ജൂൺ മാസങ്ങൾ: 8 * 10 + 6 * 20 + 3 * 30 = 290 чел * час;
• മധ്യഭാഗങ്ങൾ: 8 * 7 + 6 * 15 + 3 * 20 = 206 чел * час;
• സീനിയർ: 8 * 5 + 6 * 10 + 3 * 15 = 145 чел * час.

ഉപസംഹാരം: സംവിധായകന് അർഹമായ പരമാവധി ലഭിക്കുന്നതിന്, പ്രതിമാസം 8 ലാൻഡിംഗ് പേജുകളും 6 ഇടത്തരം സൈറ്റുകളും 3 സ്റ്റോറുകളും സൃഷ്ടിക്കുന്നത് ഉചിതമാണ്. ഈ സാഹചര്യത്തിൽ, സീനിയർ മെഷീനിൽ നിന്ന് നോക്കാതെ ഉഴുതുമറിച്ചിരിക്കണം, മധ്യഭാഗങ്ങളുടെ ലോഡ് ഏകദേശം 2/3 ആയിരിക്കും, ജൂനിയർ പകുതിയിൽ താഴെയാണ്.

തീരുമാനം

പാക്കേജിനൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള അടിസ്ഥാന സാങ്കേതിക വിദ്യകൾ ലേഖനം വിവരിക്കുന്നു scipy.optimize, സോപാധികമായ മിനിമൈസേഷൻ പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ഉപയോഗിക്കുന്നു. വ്യക്തിപരമായി ഞാൻ ഉപയോഗിക്കുന്നു scipy കേവലം അക്കാദമിക് ആവശ്യങ്ങൾക്കായി, അതിനാലാണ് നൽകിയിരിക്കുന്ന ഉദാഹരണം അത്തരമൊരു കോമിക് സ്വഭാവമുള്ളത്.

ധാരാളം സിദ്ധാന്തങ്ങളും വെർച്വൽ ഉദാഹരണങ്ങളും കണ്ടെത്താൻ കഴിയും, ഉദാഹരണത്തിന്, I.L. Akulich ന്റെ പുസ്തകത്തിൽ "ഉദാഹരണങ്ങളിലും പ്രശ്നങ്ങളിലും ഗണിതശാസ്ത്ര പ്രോഗ്രാമിംഗ്". കൂടുതൽ ഹാർഡ്‌കോർ ആപ്ലിക്കേഷൻ scipy.optimize ഒരു കൂട്ടം ചിത്രങ്ങളിൽ നിന്ന് ഒരു 3D ഘടന നിർമ്മിക്കാൻ (ഹബ്രെയെക്കുറിച്ചുള്ള ലേഖനം) ൽ കാണാൻ കഴിയും scipy-പാചകപുസ്തകം.

വിവരങ്ങളുടെ പ്രധാന ഉറവിടം docs.scipy.orgഇതിന്റെയും മറ്റ് വിഭാഗങ്ങളുടെയും വിവർത്തനത്തിലേക്ക് സംഭാവന നൽകാൻ ആഗ്രഹിക്കുന്നവർ scipy സ്വാഗതം സാമൂഹികം.

Спасибо മെഫിസ്റ്റോഫീസ് പ്രസിദ്ധീകരണം തയ്യാറാക്കുന്നതിൽ പങ്കാളിത്തത്തിനായി.

അവലംബം: www.habr.com