SciPy, நிபந்தனைகளுடன் மேம்படுத்தல்

SciPy (sai pie என உச்சரிக்கப்படுகிறது) என்பது நம்பி அடிப்படையிலான கணித தொகுப்பு ஆகும், இதில் C மற்றும் Fortran நூலகங்களும் அடங்கும். SciPy உங்கள் ஊடாடும் பைதான் அமர்வை MATLAB, IDL, Octave, R அல்லது SciLab போன்ற முழுமையான தரவு அறிவியல் சூழலாக மாற்றுகிறது.

இந்த கட்டுரையில், கணித நிரலாக்கத்தின் அடிப்படை நுட்பங்களைப் பார்ப்போம் - scipy.optimize தொகுப்பைப் பயன்படுத்தி பல மாறிகளின் அளவிடுதல் செயல்பாட்டிற்கான நிபந்தனை தேர்வுமுறை சிக்கல்களைத் தீர்ப்பது. கட்டுப்பாடற்ற தேர்வுமுறை அல்காரிதம்கள் ஏற்கனவே விவாதிக்கப்பட்டுள்ளன கடந்த கட்டுரை. உதவி() கட்டளை, Shift+Tab அல்லது in ஐப் பயன்படுத்தி scipy செயல்பாடுகள் பற்றிய விரிவான மற்றும் புதுப்பித்த உதவியை எப்போதும் பெறலாம். அதிகாரப்பூர்வ ஆவணங்கள்.

அறிமுகம்

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 சமத்துவ வடிவத்தின் கட்டுப்பாடுகள் மற்றும் மீதான பிரச்சனைகளுக்கு பயணம் ஏற்றத்தாழ்வுகள் வடிவில் உள்ள தடைகள் பிரச்சனைகளுக்கு. இரண்டு முறைகளும் நம்பிக்கைப் பகுதியில் உள்ளூர் குறைந்தபட்சத்தைக் கண்டறிவதற்கான வழிமுறைகளால் செயல்படுத்தப்படுகின்றன மற்றும் பெரிய அளவிலான சிக்கல்களுக்கு மிகவும் பொருத்தமானவை.

பொதுவான வடிவத்தில் குறைந்தபட்சத்தைக் கண்டுபிடிப்பதில் சிக்கலின் கணித உருவாக்கம்:

கடுமையான சமத்துவக் கட்டுப்பாடுகளுக்கு, கீழ் வரம்பு மேல் எல்லைக்கு சமமாக அமைக்கப்படுகிறது .
ஒரு வழி தடைக்கு, மேல் அல்லது கீழ் வரம்பு அமைக்கப்பட்டுள்ளது np.inf தொடர்புடைய அடையாளத்துடன்.
இரண்டு மாறிகளின் அறியப்பட்ட Rosenbrock செயல்பாட்டின் குறைந்தபட்சத்தைக் கண்டறிவது அவசியமாக இருக்கட்டும்:

இந்த வழக்கில், அதன் வரையறையின் களத்தில் பின்வரும் கட்டுப்பாடுகள் அமைக்கப்பட்டுள்ளன:

எங்கள் விஷயத்தில், புள்ளியில் ஒரு தனித்துவமான தீர்வு உள்ளது , முதல் மற்றும் நான்காவது கட்டுப்பாடுகள் மட்டுமே செல்லுபடியாகும்.
கீழிருந்து மேல் வரை உள்ள கட்டுப்பாடுகளை நாம் எப்படி scipyயில் எழுதலாம் என்று பார்க்கலாம்.
கட்டுப்பாடுகள் и எல்லைகள் பொருளைப் பயன்படுத்தி அதை வரையறுப்போம்.

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

ஜேக்கபியன் மேட்ரிக்ஸின் கட்டுப்பாடுகள் வரையறுக்கப்பட்ட வேறுபாடுகளைப் பயன்படுத்தி கணக்கிடப்படலாம். இருப்பினும், இந்த வழக்கில் ஹெஸியன் மேட்ரிக்ஸை வரையறுக்கப்பட்ட வேறுபாடுகளைப் பயன்படுத்தி கணக்கிட முடியாது. 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 டி.ஆர்.

எங்கள் நட்பு குழுவில் நான்கு ஜூனியர்கள், இரண்டு நடுத்தர மற்றும் ஒரு மூத்தவர்கள் உள்ளனர். அவர்களின் மாதாந்திர வேலை நேர நிதி:

• ஜூன் மாதம்: 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 முற்றிலும் கல்வி நோக்கங்களுக்காக, கொடுக்கப்பட்ட உதாரணம் அத்தகைய நகைச்சுவைத் தன்மை கொண்டது.

எடுத்துக்காட்டாக, ஐ.எல். அகுலிச் எழுதிய "எடுத்துக்காட்டுகள் மற்றும் சிக்கல்களில் கணித நிரலாக்கம்" என்ற புத்தகத்தில் நிறைய கோட்பாடு மற்றும் மெய்நிகர் எடுத்துக்காட்டுகளைக் காணலாம். மேலும் ஹார்ட்கோர் பயன்பாடு scipy.optimize படங்களின் தொகுப்பிலிருந்து ஒரு 3D கட்டமைப்பை உருவாக்க (ஹப்ரே பற்றிய கட்டுரை) இல் பார்க்கலாம் scipy-சமையல் புத்தகம்.

தகவலின் முக்கிய ஆதாரம் docs.scipy.orgஇந்த மற்றும் பிற பிரிவுகளின் மொழிபெயர்ப்புக்கு பங்களிக்க விரும்புவோர் scipy வரவேற்கிறோம் மகிழ்ச்சியா.

Спасибо மெஃபிஸ்டோபீஸ் வெளியீட்டைத் தயாரிப்பதில் பங்கேற்பதற்காக.

ஆதாரம்: www.habr.com