🥇SciPy, ഒപ്റ്റിമൈസേഷൻ | പ്രോഹോസ്റ്റർ

നമ്പി പൈത്തൺ വിപുലീകരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു ഗണിതശാസ്ത്ര ആപ്ലിക്കേഷൻ പാക്കേജാണ് SciPy (സായി പൈ എന്ന് ഉച്ചരിക്കുന്നത്). SciPy ഉപയോഗിച്ച്, നിങ്ങളുടെ സംവേദനാത്മക പൈത്തൺ സെഷൻ MATLAB, IDL, Octave, R-Lab, SciLab എന്നിവ പോലെ സമ്പൂർണ്ണ ഡാറ്റാ സയൻസും സങ്കീർണ്ണമായ സിസ്റ്റം പ്രോട്ടോടൈപ്പിംഗ് പരിതസ്ഥിതിയും ആയി മാറുന്നു. scipy.optimize പാക്കേജിൽ അറിയപ്പെടുന്ന ചില ഒപ്റ്റിമൈസേഷൻ അൽഗോരിതങ്ങൾ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ച് ഇന്ന് ഞാൻ ചുരുക്കമായി സംസാരിക്കാൻ ആഗ്രഹിക്കുന്നു. ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്നതിനുള്ള കൂടുതൽ വിശദവും കാലികവുമായ സഹായം എപ്പോഴും help() കമാൻഡ് ഉപയോഗിച്ചോ Shift+Tab ഉപയോഗിച്ചോ ലഭിക്കും.

ആമുഖം

പ്രാഥമിക ഉറവിടങ്ങൾ തിരയുന്നതിൽ നിന്നും വായനയിൽ നിന്നും നിങ്ങളെയും വായനക്കാരെയും രക്ഷിക്കുന്നതിനായി, രീതികളുടെ വിവരണങ്ങളിലേക്കുള്ള ലിങ്കുകൾ പ്രധാനമായും വിക്കിപീഡിയയിലായിരിക്കും. ചട്ടം പോലെ, ഈ വിവരങ്ങൾ പൊതുവായ നിബന്ധനകളും അവയുടെ പ്രയോഗത്തിനുള്ള വ്യവസ്ഥകളും മനസ്സിലാക്കാൻ പര്യാപ്തമാണ്. ഗണിതശാസ്ത്ര രീതികളുടെ സാരാംശം മനസിലാക്കാൻ, കൂടുതൽ ആധികാരിക പ്രസിദ്ധീകരണങ്ങളിലേക്കുള്ള ലിങ്കുകൾ പിന്തുടരുക, അത് ഓരോ ലേഖനത്തിന്റെയും അവസാനത്തിലോ നിങ്ങളുടെ പ്രിയപ്പെട്ട സെർച്ച് എഞ്ചിനിലോ കാണാം.

അതിനാൽ, scipy.optimize മൊഡ്യൂളിൽ ഇനിപ്പറയുന്ന നടപടിക്രമങ്ങൾ നടപ്പിലാക്കുന്നത് ഉൾപ്പെടുന്നു:

വിവിധ അൽഗോരിതങ്ങൾ (നെൽഡർ-മീഡ് സിംപ്ലക്സ്, BFGS, ന്യൂട്ടൺ കൺജഗേറ്റ് ഗ്രേഡിയന്റ്സ്, കോബില и SLSQP)
ആഗോള ഒപ്റ്റിമൈസേഷൻ (ഉദാഹരണത്തിന്: ബേസിൻഹോപ്പിംഗ്, diff_evolution)
അവശിഷ്ടങ്ങൾ ചെറുതാക്കുന്നു എം.എൻ.സി (least_squares) കൂടാതെ രേഖീയമല്ലാത്ത ഏറ്റവും കുറഞ്ഞ ചതുരങ്ങൾ (curve_fit) ഉപയോഗിക്കുന്ന കർവ് ഫിറ്റിംഗ് അൽഗോരിതങ്ങൾ
ഒരു വേരിയബിളിന്റെ (minim_scalar) സ്കെയിലർ ഫംഗ്‌ഷനുകൾ ചെറുതാക്കുകയും റൂട്ടുകൾക്കായി തിരയുകയും ചെയ്യുന്നു (root_scalar)
വിവിധ അൽഗോരിതങ്ങൾ (ഹൈബ്രിഡ് പവൽ, ലെവൻബർഗ്-മാർക്വാർഡ് അല്ലെങ്കിൽ പോലുള്ള വലിയ തോതിലുള്ള രീതികൾ ന്യൂട്ടൺ-ക്രൈലോവ്).

ഈ ലേഖനത്തിൽ ഈ മുഴുവൻ ലിസ്റ്റിൽ നിന്നും ആദ്യ ഇനം മാത്രമേ ഞങ്ങൾ പരിഗണിക്കുകയുള്ളൂ.

നിരവധി വേരിയബിളുകളുടെ സ്കെയിലർ ഫംഗ്‌ഷന്റെ നിരുപാധികമായ ചെറുതാക്കൽ

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

ഈ ആവശ്യങ്ങൾക്ക്, N വേരിയബിളുകളുടെ Rosenbrock ഫംഗ്ഷൻ തികഞ്ഞതാണ്, അതിന് ഫോം ഉണ്ട്:

Rosenbrock ഫംഗ്ഷനും അതിന്റെ Jacobi, Hessian മെട്രിക്സുകളും (യഥാക്രമം ഒന്നും രണ്ടും ഡെറിവേറ്റീവുകൾ) scipy.optimize പാക്കേജിൽ ഇതിനകം നിർവചിച്ചിട്ടുണ്ടെങ്കിലും, ഞങ്ങൾ അത് സ്വയം നിർവ്വചിക്കും.

import numpy as np

def rosen(x):
    """The Rosenbrock function"""
    return np.sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0, axis=0)

വ്യക്തതയ്ക്കായി, രണ്ട് വേരിയബിളുകളുടെ Rosenbrock ഫംഗ്‌ഷന്റെ മൂല്യങ്ങൾ 3D-യിൽ വരയ്ക്കാം.

ഡ്രോയിംഗ് കോഡ്

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter

# Настраиваем 3D график
fig = plt.figure(figsize=[15, 10])
ax = fig.gca(projection='3d')

# Задаем угол обзора
ax.view_init(45, 30)

# Создаем данные для графика
X = np.arange(-2, 2, 0.1)
Y = np.arange(-1, 3, 0.1)
X, Y = np.meshgrid(X, Y)
Z = rosen(np.array([X,Y]))

# Рисуем поверхность
surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm)
plt.show()

മിനിമം 0 ആണ് എന്ന് മുൻകൂട്ടി അറിയുക , വിവിധ scipy.optimize നടപടിക്രമങ്ങൾ ഉപയോഗിച്ച് Rosenbrock ഫംഗ്ഷന്റെ ഏറ്റവും കുറഞ്ഞ മൂല്യം എങ്ങനെ നിർണ്ണയിക്കും എന്നതിന്റെ ഉദാഹരണങ്ങൾ നോക്കാം.

നെൽഡർ-മീഡ് സിംപ്ലക്സ് രീതി

0-ഡൈമൻഷണൽ സ്‌പെയ്‌സിൽ ഒരു പ്രാരംഭ പോയിന്റ് x5 ഉണ്ടായിരിക്കട്ടെ. അൽഗോരിതം ഉപയോഗിച്ച് റോസൻബ്രോക്ക് ഫംഗ്ഷന്റെ ഏറ്റവും കുറഞ്ഞ പോയിന്റ് കണ്ടെത്താം നെൽഡർ-മീഡ് സിംപ്ലക്സ് (അൽഗോരിതം രീതി പാരാമീറ്ററിന്റെ മൂല്യമായി വ്യക്തമാക്കിയിരിക്കുന്നു):

from scipy.optimize import minimize
x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
res = minimize(rosen, x0, method='nelder-mead',
    options={'xtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 339
         Function evaluations: 571
[1. 1. 1. 1. 1.]

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

പാവൽ രീതി

ഫംഗ്ഷൻ മൂല്യങ്ങൾ മാത്രം കണക്കാക്കുന്ന മറ്റൊരു ഒപ്റ്റിമൈസേഷൻ അൽഗോരിതം പവലിന്റെ രീതി. ഇത് ഉപയോഗിക്കുന്നതിന്, മിനിം ഫംഗ്‌ഷനിൽ നിങ്ങൾ method = 'powell' സജ്ജീകരിക്കേണ്ടതുണ്ട്.

x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])
res = minimize(rosen, x0, method='powell',
    options={'xtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 19
         Function evaluations: 1622
[1. 1. 1. 1. 1.]

ബ്രോയ്ഡൻ-ഫ്ലെച്ചർ-ഗോൾഡ്ഫാർബ്-ഷാനോ (BFGS) അൽഗോരിതം

ഒരു പരിഹാരത്തിലേക്ക് വേഗത്തിൽ ഒത്തുചേരൽ ലഭിക്കുന്നതിന്, നടപടിക്രമം BFGS ഒബ്ജക്റ്റീവ് ഫംഗ്ഷന്റെ ഗ്രേഡിയന്റ് ഉപയോഗിക്കുന്നു. ഗ്രേഡിയന്റ് ഒരു ഫംഗ്‌ഷനായി വ്യക്തമാക്കാം അല്ലെങ്കിൽ ഫസ്റ്റ് ഓർഡർ വ്യത്യാസങ്ങൾ ഉപയോഗിച്ച് കണക്കാക്കാം. ഏത് സാഹചര്യത്തിലും, സിംപ്ലക്സ് രീതിയേക്കാൾ കുറച്ച് ഫംഗ്ഷൻ കോളുകൾ BFGS രീതിക്ക് ആവശ്യമാണ്.

നമുക്ക് റോസൻബ്രോക്ക് ഫംഗ്ഷന്റെ ഡെറിവേറ്റീവ് വിശകലന രൂപത്തിൽ കണ്ടെത്താം:

ആദ്യത്തേതും അവസാനത്തേതും ഒഴികെയുള്ള എല്ലാ വേരിയബിളുകളുടെയും ഡെറിവേറ്റീവുകൾക്ക് ഈ പദപ്രയോഗം സാധുവാണ്, അവ ഇങ്ങനെ നിർവചിച്ചിരിക്കുന്നു:

ഈ ഗ്രേഡിയന്റ് കണക്കാക്കുന്ന പൈത്തൺ ഫംഗ്‌ഷൻ നോക്കാം:

def rosen_der (x):
    xm = x [1: -1]
    xm_m1 = x [: - 2]
    xm_p1 = x [2:]
    der = np.zeros_like (x)
    der [1: -1] = 200 * (xm-xm_m1 ** 2) - 400 * (xm_p1 - xm ** 2) * xm - 2 * (1-xm)
    der [0] = -400 * x [0] * (x [1] -x [0] ** 2) - 2 * (1-x [0])
    der [-1] = 200 * (x [-1] -x [-2] ** 2)
    return der

ഗ്രേഡിയന്റ് കണക്കുകൂട്ടൽ ഫംഗ്‌ഷൻ ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ, മിനിം ഫംഗ്‌ഷന്റെ ജാക് പാരാമീറ്ററിന്റെ മൂല്യമായി വ്യക്തമാക്കുന്നു.

res = minimize(rosen, x0, method='BFGS', jac=rosen_der, options={'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 25
         Function evaluations: 30
         Gradient evaluations: 30
[1.00000004 1.0000001  1.00000021 1.00000044 1.00000092]

കോൺജുഗേറ്റ് ഗ്രേഡിയന്റ് അൽഗോരിതം (ന്യൂട്ടൺ)

അൽഗോരിതം ന്യൂട്ടന്റെ സംയോജിത ഗ്രേഡിയന്റുകൾ പരിഷ്കരിച്ച ന്യൂട്ടന്റെ രീതിയാണ്.
ന്യൂട്ടന്റെ രീതി ഒരു ലോക്കൽ ഏരിയയിലെ ഒരു ഫംഗ്‌ഷനെ രണ്ടാം ഡിഗ്രിയുടെ പോളിനോമിയൽ ഉപയോഗിച്ച് ഏകദേശിക്കുന്നതിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്:

എവിടെ രണ്ടാമത്തെ ഡെറിവേറ്റീവുകളുടെ മാട്രിക്സ് ആണ് (ഹെസിയൻ മാട്രിക്സ്, ഹെസ്സിയൻ).
ഹെസ്സിയൻ പോസിറ്റീവ് ഡെഫനിറ്റാണെങ്കിൽ, ക്വാഡ്രാറ്റിക് ഫോമിന്റെ പൂജ്യം ഗ്രേഡിയന്റ് പൂജ്യത്തിന് തുല്യമാക്കി ഈ ഫംഗ്ഷന്റെ പ്രാദേശിക മിനിമം കണ്ടെത്താനാകും. ഫലം പദപ്രയോഗമായിരിക്കും:

സംയോജിത ഗ്രേഡിയന്റ് രീതി ഉപയോഗിച്ചാണ് വിപരീത ഹെസ്സിയൻ കണക്കാക്കുന്നത്. Rosenbrock ഫംഗ്ഷൻ കുറയ്ക്കുന്നതിന് ഈ രീതി ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ചുവടെ നൽകിയിരിക്കുന്നു. ന്യൂട്ടൺ-സിജി രീതി ഉപയോഗിക്കുന്നതിന്, ഹെസ്സിയൻ കണക്കാക്കുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾ വ്യക്തമാക്കണം.
വിശകലന രൂപത്തിൽ റോസൻബ്രോക്ക് ഫംഗ്ഷന്റെ ഹെസ്സിയൻ ഇതിന് തുല്യമാണ്:

എവിടെ и , മാട്രിക്സ് നിർവ്വചിക്കുക .

മാട്രിക്സിന്റെ ശേഷിക്കുന്ന പൂജ്യമല്ലാത്ത ഘടകങ്ങൾ ഇതിന് തുല്യമാണ്:

ഉദാഹരണത്തിന്, ഒരു പഞ്ചമാന സ്പേസിൽ N = 5, റോസൻബ്രോക്ക് ഫംഗ്ഷനുള്ള ഹെസ്സിയൻ മാട്രിക്സിന് ഒരു ബാൻഡിന്റെ രൂപമുണ്ട്:

കൺജഗേറ്റ് ഗ്രേഡിയന്റ് (ന്യൂട്ടൺ) രീതി ഉപയോഗിച്ച് റോസൻബ്രോക്ക് ഫംഗ്ഷൻ ചെറുതാക്കുന്നതിനുള്ള കോഡിനൊപ്പം ഈ ഹെസ്സിയൻ കണക്കാക്കുന്ന കോഡ്:

def rosen_hess(x):
    x = np.asarray(x)
    H = np.diag(-400*x[:-1],1) - np.diag(400*x[:-1],-1)
    diagonal = np.zeros_like(x)
    diagonal[0] = 1200*x[0]**2-400*x[1]+2
    diagonal[-1] = 200
    diagonal[1:-1] = 202 + 1200*x[1:-1]**2 - 400*x[2:]
    H = H + np.diag(diagonal)
    return H

res = minimize(rosen, x0, method='Newton-CG', 
               jac=rosen_der, hess=rosen_hess,
               options={'xtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 33
         Gradient evaluations: 56
         Hessian evaluations: 24
[1.         1.         1.         0.99999999 0.99999999]

ഹെസ്സിയന്റെയും അനിയന്ത്രിതമായ വെക്റ്ററിന്റെയും ഉൽപ്പന്ന പ്രവർത്തനത്തിന്റെ നിർവചനത്തോടുകൂടിയ ഒരു ഉദാഹരണം

യഥാർത്ഥ ലോക പ്രശ്‌നങ്ങളിൽ, മുഴുവൻ ഹെസ്സിയൻ മാട്രിക്‌സും കമ്പ്യൂട്ടിംഗ് ചെയ്യുന്നതിനും സംഭരിക്കുന്നതിനും കാര്യമായ സമയവും മെമ്മറി വിഭവങ്ങളും ആവശ്യമായി വന്നേക്കാം. ഈ സാഹചര്യത്തിൽ, യഥാർത്ഥത്തിൽ ഹെസ്സിയൻ മാട്രിക്സ് തന്നെ വ്യക്തമാക്കേണ്ട ആവശ്യമില്ല, കാരണം മിനിമൈസേഷൻ നടപടിക്രമത്തിന് മറ്റൊരു അനിയന്ത്രിതമായ വെക്റ്റർ ഉള്ള ഹെസ്സിയന്റെ ഉൽപ്പന്നത്തിന് തുല്യമായ വെക്റ്റർ മാത്രമേ ആവശ്യമുള്ളൂ. അതിനാൽ, ഒരു കമ്പ്യൂട്ടേഷണൽ വീക്ഷണകോണിൽ നിന്ന്, ഒരു അനിയന്ത്രിതമായ വെക്റ്റർ ഉപയോഗിച്ച് ഹെസ്സിയന്റെ ഉൽപ്പന്നത്തിന്റെ ഫലം നൽകുന്ന ഒരു ഫംഗ്ഷൻ ഉടനടി നിർവചിക്കുന്നതാണ് നല്ലത്.

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

ഹെസ്സിയന്റെയും അനിയന്ത്രിതമായ വെക്റ്ററിന്റെയും ഉൽപ്പന്നം കണക്കാക്കുന്ന ഫംഗ്ഷൻ, ഹെസ്പ് ആർഗ്യുമെന്റിന്റെ മൂല്യമായി മിനിമൈസ് ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു:

def rosen_hess_p(x, p):
    x = np.asarray(x)
    Hp = np.zeros_like(x)
    Hp[0] = (1200*x[0]**2 - 400*x[1] + 2)*p[0] - 400*x[0]*p[1]
    Hp[1:-1] = -400*x[:-2]*p[:-2]+(202+1200*x[1:-1]**2-400*x[2:])*p[1:-1] 
    -400*x[1:-1]*p[2:]
    Hp[-1] = -400*x[-2]*p[-2] + 200*p[-1]
    return Hp

res = minimize(rosen, x0, method='Newton-CG',
               jac=rosen_der, hessp=rosen_hess_p,
               options={'xtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 24
         Function evaluations: 33
         Gradient evaluations: 56
         Hessian evaluations: 66

കോൺജുഗേറ്റ് ഗ്രേഡിയന്റ് ട്രസ്റ്റ് റീജിയൻ അൽഗോരിതം (ന്യൂട്ടൺ)

ഹെസ്സിയൻ മാട്രിക്സിന്റെ മോശം കണ്ടീഷനിംഗും തെറ്റായ തിരയൽ ദിശകളും ന്യൂട്ടന്റെ കൺജഗേറ്റ് ഗ്രേഡിയന്റ് അൽഗോരിതം ഫലപ്രദമല്ലാതാക്കും. അത്തരം സന്ദർഭങ്ങളിൽ, മുൻഗണന നൽകുന്നു വിശ്വാസ മേഖല രീതി (ട്രസ്റ്റ്-മേഖല) ന്യൂട്ടൺ ഗ്രേഡിയന്റുകളെ സംയോജിപ്പിക്കുക.

ഹെസ്സിയൻ മാട്രിക്സിന്റെ നിർവചനത്തോടുകൂടിയ ഉദാഹരണം:

res = minimize(rosen, x0, method='trust-ncg',
               jac=rosen_der, hess=rosen_hess,
               options={'gtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 20
         Function evaluations: 21
         Gradient evaluations: 20
         Hessian evaluations: 19
[1. 1. 1. 1. 1.]

ഹെസ്സിയന്റെയും ഒരു അനിയന്ത്രിതമായ വെക്റ്ററിന്റെയും ഉൽപ്പന്ന പ്രവർത്തനത്തിന്റെ ഉദാഹരണം:

res = minimize(rosen, x0, method='trust-ncg', 
                jac=rosen_der, hessp=rosen_hess_p, 
                options={'gtol': 1e-8, 'disp': True})
print(res.x)

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 20
         Function evaluations: 21
         Gradient evaluations: 20
         Hessian evaluations: 0
[1. 1. 1. 1. 1.]

ക്രൈലോവ് തരം രീതികൾ

Trust-ncg രീതി പോലെ, ക്രൈലോവ്-തരം രീതികൾ വലിയ തോതിലുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് അനുയോജ്യമാണ്, കാരണം അവർ മാട്രിക്സ്-വെക്റ്റർ ഉൽപ്പന്നങ്ങൾ മാത്രം ഉപയോഗിക്കുന്നു. വെട്ടിച്ചുരുക്കിയ ക്രൈലോവ് സബ്‌സ്‌പെയ്‌സ് പരിമിതപ്പെടുത്തിയിരിക്കുന്ന ഒരു കോൺഫിഡൻസ് റീജിയണിലെ ഒരു പ്രശ്നം പരിഹരിക്കുക എന്നതാണ് അവരുടെ സാരം. അനിശ്ചിതത്വമുള്ള പ്രശ്നങ്ങൾക്ക്, ഈ രീതി ഉപയോഗിക്കുന്നതാണ് നല്ലത്, കാരണം ട്രസ്റ്റ്-എൻസിജി രീതിയുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഓരോ ഉപപ്രശ്നത്തിനും മാട്രിക്സ്-വെക്റ്റർ ഉൽപ്പന്നങ്ങളുടെ എണ്ണം കുറവായതിനാൽ, ഇത് വളരെ കുറച്ച് ലീനിയർ ആവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു. കൂടാതെ, ട്രസ്റ്റ്-എൻസിജി രീതി ഉപയോഗിക്കുന്നതിനേക്കാൾ കൂടുതൽ കൃത്യമായി ക്വാഡ്രാറ്റിക് ഉപപ്രശ്നത്തിനുള്ള പരിഹാരം കണ്ടെത്തുന്നു.
ഹെസ്സിയൻ മാട്രിക്സിന്റെ നിർവചനത്തോടുകൂടിയ ഉദാഹരണം:

res = minimize(rosen, x0, method='trust-krylov',
               jac=rosen_der, hess=rosen_hess,
               options={'gtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 19
         Function evaluations: 20
         Gradient evaluations: 20
         Hessian evaluations: 18

print(res.x)

    [1. 1. 1. 1. 1.]

res = minimize(rosen, x0, method='trust-krylov',
               jac=rosen_der, hessp=rosen_hess_p,
               options={'gtol': 1e-8, 'disp': True})

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 19
         Function evaluations: 20
         Gradient evaluations: 20
         Hessian evaluations: 0

print(res.x)

    [1. 1. 1. 1. 1.]

ആത്മവിശ്വാസ മേഖലയിലെ ഏകദേശ പരിഹാരത്തിനുള്ള അൽഗോരിതം

എല്ലാ രീതികളും (ന്യൂട്ടൺ-സിജി, ട്രസ്റ്റ്-എൻസിജി, ട്രസ്റ്റ്-ക്രൈലോവ്) വലിയ തോതിലുള്ള പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിന് അനുയോജ്യമാണ് (ആയിരക്കണക്കിന് വേരിയബിളുകൾക്കൊപ്പം). അന്തർലീനമായ സംയോജിത ഗ്രേഡിയന്റ് അൽഗോരിതം വിപരീത ഹെസ്സിയൻ മാട്രിക്സിന്റെ ഏകദേശ നിർണ്ണയത്തെ സൂചിപ്പിക്കുന്നു എന്നതാണ് ഇതിന് കാരണം. ഹെസ്സിയന്റെ വ്യക്തമായ വികാസമില്ലാതെ, പരിഹാരം ആവർത്തിച്ച് കണ്ടെത്തുന്നു. നിങ്ങൾ ഒരു ഹെസ്സിയന്റെയും അനിയന്ത്രിതമായ വെക്റ്ററിന്റെയും ഉൽപ്പന്നത്തിന് ഒരു ഫംഗ്ഷൻ നിർവചിക്കേണ്ടതുണ്ട് എന്നതിനാൽ, വിരളമായ (ബാൻഡ് ഡയഗണൽ) മെട്രിക്സുകളിൽ പ്രവർത്തിക്കുന്നതിന് ഈ അൽഗോരിതം പ്രത്യേകിച്ചും നല്ലതാണ്. ഇത് കുറഞ്ഞ മെമ്മറി ചെലവും ഗണ്യമായ സമയ ലാഭവും നൽകുന്നു.

ഇടത്തരം പ്രശ്‌നങ്ങൾക്ക്, ഹെസ്സിയൻ സംഭരിക്കുന്നതിനും ഘടകമാക്കുന്നതിനുമുള്ള ചെലവ് നിർണായകമല്ല. ഇതിനർത്ഥം, ട്രസ്റ്റ് മേഖലയിലെ ഉപപ്രശ്നങ്ങൾ ഏതാണ്ട് കൃത്യമായി പരിഹരിച്ചുകൊണ്ട് കുറച്ച് ആവർത്തനങ്ങളിൽ ഒരു പരിഹാരം നേടാനാകും എന്നാണ്. ഇത് ചെയ്യുന്നതിന്, ഓരോ ക്വാഡ്രാറ്റിക് ഉപപ്രശ്നത്തിനും ചില നോൺലീനിയർ സമവാക്യങ്ങൾ ആവർത്തിച്ച് പരിഹരിക്കുന്നു. അത്തരമൊരു പരിഹാരത്തിന് സാധാരണയായി ഹെസ്സിയൻ മാട്രിക്സിന്റെ 3 അല്ലെങ്കിൽ 4 കോൾസ്കി വിഘടനം ആവശ്യമാണ്. തൽഫലമായി, ഈ രീതി കുറച്ച് ആവർത്തനങ്ങളിൽ കൂടിച്ചേരുകയും മറ്റ് നടപ്പിലാക്കിയ കോൺഫിഡൻസ് റീജിയൻ രീതികളേക്കാൾ കുറച്ച് ഒബ്ജക്റ്റീവ് ഫംഗ്ഷൻ കണക്കുകൂട്ടലുകൾ ആവശ്യമാണ്. ഈ അൽഗോരിതം പൂർണ്ണമായ ഹെസ്സിയൻ മാട്രിക്സ് നിർണ്ണയിക്കുന്നത് മാത്രം ഉൾക്കൊള്ളുന്നു, കൂടാതെ ഹെസ്സിയന്റെയും അനിയന്ത്രിതമായ വെക്റ്ററിന്റെയും ഉൽപ്പന്ന പ്രവർത്തനത്തെ ഉപയോഗിക്കാനുള്ള കഴിവിനെ പിന്തുണയ്ക്കുന്നില്ല.

റോസൻബ്രോക്ക് ഫംഗ്‌ഷൻ ചെറുതാക്കുന്നതിനുള്ള ഉദാഹരണം:

res = minimize(rosen, x0, method='trust-exact',
               jac=rosen_der, hess=rosen_hess,
               options={'gtol': 1e-8, 'disp': True})
res.x

Optimization terminated successfully.
         Current function value: 0.000000
         Iterations: 13
         Function evaluations: 14
         Gradient evaluations: 13
         Hessian evaluations: 14

array([1., 1., 1., 1., 1.])

ഞങ്ങൾ മിക്കവാറും അവിടെ നിർത്തും. അടുത്ത ലേഖനത്തിൽ സോപാധികമായ മിനിമൈസേഷൻ, ഏകദേശ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിൽ മിനിമൈസേഷന്റെ പ്രയോഗം, ഒരു വേരിയബിളിന്റെ ഒരു ഫംഗ്ഷൻ കുറയ്ക്കൽ, അനിയന്ത്രിതമായ മിനിമൈസറുകൾ, scipy.optimize ഉപയോഗിച്ച് സമവാക്യങ്ങളുടെ ഒരു സിസ്റ്റത്തിന്റെ വേരുകൾ കണ്ടെത്തൽ എന്നിവയെക്കുറിച്ചുള്ള ഏറ്റവും രസകരമായ കാര്യങ്ങൾ പറയാൻ ഞാൻ ശ്രമിക്കും. പാക്കേജ്.

അവലംബം: https://docs.scipy.org/doc/scipy/reference/

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

SciPy, ഒപ്റ്റിമൈസേഷൻ