SciPy, શરતો સાથે ઓપ્ટિમાઇઝેશન

SciPy (ઉચ્ચારણ સાઈ પાઈ) એ નમ્પી-આધારિત ગણિતનું પેકેજ છે જેમાં C અને Fortran પુસ્તકાલયોનો પણ સમાવેશ થાય છે. SciPy તમારા ઇન્ટરેક્ટિવ પાયથોન સત્રને MATLAB, IDL, Octave, R, અથવા SciLab જેવા સંપૂર્ણ ડેટા વિજ્ઞાન વાતાવરણમાં ફેરવે છે.

આ લેખમાં, અમે ગાણિતિક પ્રોગ્રામિંગની મૂળભૂત તકનીકો જોઈશું - scipy.optimize પેકેજનો ઉપયોગ કરીને ઘણા ચલોના સ્કેલર કાર્ય માટે શરતી ઑપ્ટિમાઇઝેશન સમસ્યાઓનું નિરાકરણ. અનિયંત્રિત ઑપ્ટિમાઇઝેશન એલ્ગોરિધમ્સની પહેલેથી જ ચર્ચા કરવામાં આવી છે છેલ્લા લેખ. હેલ્પ() કમાન્ડ, શિફ્ટ+ટૅબ અથવા ઇનનો ઉપયોગ કરીને સ્કીપી ફંક્શન્સ પર વધુ વિગતવાર અને અદ્યતન મદદ હંમેશા મેળવી શકાય છે. સત્તાવાર દસ્તાવેજીકરણ.

પરિચય

scipy.optimize પેકેજમાં શરતી અને અનિયંત્રિત ઓપ્ટિમાઇઝેશન સમસ્યાઓ બંનેને ઉકેલવા માટેનું એક સામાન્ય ઇન્ટરફેસ ફંક્શન દ્વારા પ્રદાન કરવામાં આવે છે. minimize(). જો કે, તે જાણીતું છે કે બધી સમસ્યાઓ હલ કરવા માટે કોઈ સાર્વત્રિક પદ્ધતિ નથી, તેથી પર્યાપ્ત પદ્ધતિની પસંદગી, હંમેશની જેમ, સંશોધકના ખભા પર પડે છે.
યોગ્ય ઑપ્ટિમાઇઝેશન અલ્ગોરિધમ ફંક્શન દલીલનો ઉપયોગ કરીને ઉલ્લેખિત છે minimize(..., method="").
ઘણા ચલોના કાર્યના શરતી ઑપ્ટિમાઇઝેશન માટે, નીચેની પદ્ધતિઓના અમલીકરણો ઉપલબ્ધ છે:

• trust-constr - આત્મવિશ્વાસ ક્ષેત્રમાં સ્થાનિક લઘુત્તમ માટે શોધો. વિકિ લેખ, હેબ્રે પરનો લેખ;
• SLSQP - અવરોધો સાથે ક્રમિક ચતુર્ભુજ પ્રોગ્રામિંગ, લેગ્રેન્જ સિસ્ટમને ઉકેલવા માટે ન્યૂટોનિયન પદ્ધતિ. વિકિ લેખ.
• TNC - કપાયેલ ન્યૂટન કન્સ્ટ્રેઇન્ડ, પુનરાવૃત્તિઓની મર્યાદિત સંખ્યા, મોટી સંખ્યામાં સ્વતંત્ર ચલો સાથે બિનરેખીય કાર્યો માટે સારી. વિકિ લેખ.
• L-BFGS-B — હેસિયન મેટ્રિક્સમાંથી વેક્ટરના આંશિક લોડિંગને કારણે ઓછી મેમરી વપરાશ સાથે બ્રોયડેન-ફ્લેચર-ગોલ્ડફાર્બ-શાન્નો ટીમની પદ્ધતિ. વિકિ લેખ, હેબ્રે પરનો લેખ.
• COBYLA — રેખીય અંદાજ દ્વારા MARE મર્યાદિત ઓપ્ટિમાઇઝેશન, રેખીય અંદાજ સાથે મર્યાદિત ઓપ્ટિમાઇઝેશન (ગ્રેડિયન્ટ ગણતરી વિના). વિકિ લેખ.

પસંદ કરેલી પદ્ધતિના આધારે, સમસ્યા હલ કરવા માટેની શરતો અને નિયંત્રણો અલગ રીતે સેટ કરવામાં આવ્યા છે:

• વર્ગ પદાર્થ Bounds L-BFGS-B, TNC, SLSQP, ટ્રસ્ટ-કન્સ્ટ્રર પદ્ધતિઓ માટે;
• સૂચી (min, max) સમાન પદ્ધતિઓ માટે L-BFGS-B, TNC, SLSQP, trust-constr;
• ઑબ્જેક્ટ અથવા ઑબ્જેક્ટ્સની સૂચિ LinearConstraint, NonlinearConstraint COBYLA, SLSQP, ટ્રસ્ટ-કન્સ્ટ્રર પદ્ધતિઓ માટે;
• શબ્દકોશ અથવા શબ્દકોશોની સૂચિ {'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 સમાનતાના સ્વરૂપના અવરોધો સાથે સમસ્યાઓ માટે ટ્રીપ અસમાનતાના સ્વરૂપમાં અવરોધો સાથેની સમસ્યાઓ માટે. બંને પદ્ધતિઓ આત્મવિશ્વાસના ક્ષેત્રમાં સ્થાનિક લઘુત્તમ શોધવા માટે અલ્ગોરિધમ્સ દ્વારા લાગુ કરવામાં આવે છે અને મોટા પાયે સમસ્યાઓ માટે યોગ્ય છે.

સામાન્ય સ્વરૂપમાં ન્યૂનતમ શોધવાની સમસ્યાની ગાણિતિક રચના:

સખત સમાનતાની મર્યાદાઓ માટે, નીચલી બાઉન્ડ ઉપલા બાઉન્ડની બરાબર સેટ કરેલી છે .
એક-માર્ગીય અવરોધ માટે, ઉપલી અથવા નીચલી મર્યાદા સેટ કરવામાં આવી છે np.inf અનુરૂપ ચિહ્ન સાથે.
બે ચલોના જાણીતા રોઝેનબ્રૉક ફંક્શનનું ન્યૂનતમ શોધવા માટે તે જરૂરી છે:

આ કિસ્સામાં, નીચેના નિયંત્રણો તેની વ્યાખ્યાના ડોમેન પર સેટ છે:

અમારા કિસ્સામાં, બિંદુ પર એક અનન્ય ઉકેલ છે , જેના માટે માત્ર પ્રથમ અને ચોથા પ્રતિબંધો માન્ય છે.
ચાલો નીચેથી ઉપર સુધીના પ્રતિબંધોમાંથી પસાર થઈએ અને જોઈએ કે આપણે તેમને કેવી રીતે સ્કીપીમાં લખી શકીએ.
પ્રતિબંધો и ચાલો તેને બાઉન્ડ્સ ઑબ્જેક્ટનો ઉપયોગ કરીને વ્યાખ્યાયિત કરીએ.

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

પ્રતિબંધો и ચાલો તેને રેખીય સ્વરૂપમાં લખીએ:

ચાલો આ અવરોધોને લીનિયર કન્સ્ટ્રેંટ ઑબ્જેક્ટ તરીકે વ્યાખ્યાયિત કરીએ:

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

મર્યાદાઓ માટે જેકોબિયન મેટ્રિક્સ પણ મર્યાદિત તફાવતોનો ઉપયોગ કરીને ગણતરી કરી શકાય છે. જો કે, આ કિસ્સામાં હેસિયન મેટ્રિક્સની ગણતરી મર્યાદિત તફાવતોનો ઉપયોગ કરીને કરી શકાતી નથી. હેસિયનને ફંક્શન તરીકે અથવા 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]

જો જરૂરી હોય તો, હેસિયનની ગણતરી માટેનું કાર્ય LinearOperator વર્ગનો ઉપયોગ કરીને વ્યાખ્યાયિત કરી શકાય છે

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 tr થી.
• x1 - કોર્પોરેટ વેબસાઇટ્સ, 20 tr થી.
• x2 - ઓનલાઇન સ્ટોર્સ, 30 tr થી.

અમારી મૈત્રીપૂર્ણ કાર્યકારી ટીમમાં ચાર જુનિયર, બે મિડલ અને એક સિનિયરનો સમાવેશ થાય છે. તેમના માસિક કાર્ય સમય ભંડોળ:

• જૂન: 4 * 150 = 600 чел * час,
• મધ્યમ 2 * 150 = 300 чел * час,
• વરિષ્ઠ 150 чел * час.

પ્રથમ ઉપલબ્ધ જુનિયરને એક પ્રકારની સાઇટ (x0, x1, x2), મધ્યમ - (10, 20, 30), વરિષ્ઠ - (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 માળખું બનાવવા માટે (હેબ્રે પરનો લેખ) માં જોઈ શકાય છે મસાલેદાર-રસોઈ પુસ્તક.

માહિતીનો મુખ્ય સ્ત્રોત છે docs.scipy.orgઆ અને અન્ય વિભાગોના અનુવાદમાં યોગદાન આપવા ઈચ્છતા લોકો scipy સ્વાગત GitHub.

Спасибо મેફિસ્ટોફીસ પ્રકાશનની તૈયારીમાં ભાગ લેવા માટે.

સોર્સ: www.habr.com