SciPy၊ အကောင်းဆုံးဖြစ်အောင်

SciPy (အသံထွက် Sai pie) သည် Numpy Python တိုးချဲ့မှုကို အခြေခံ၍ သင်္ချာဆိုင်ရာ အပလီကေးရှင်းအထုပ်တစ်ခုဖြစ်သည်။ SciPy ဖြင့်၊ သင်၏အပြန်အလှန်အကျိုးသက်ရောက်သော Python စက်ရှင်သည် MATLAB၊ IDL၊ Octave၊ R-Lab နှင့် SciLab တို့ကဲ့သို့ ပြီးပြည့်စုံသော ဒေတာသိပ္ပံနှင့် ရှုပ်ထွေးသော စနစ်ပုံတူရိုက်ခြင်းပတ်ဝန်းကျင် ဖြစ်လာပါသည်။ ယနေ့ ကျွန်ုပ်သည် scipy.optimize ပက်ကေ့ခ်ျတွင် လူသိများသော optimization algorithms အချို့ကို မည်သို့အသုံးပြုရမည်ကို အကျဉ်းချုံးပြောပြလိုပါသည်။ လုပ်ဆောင်ချက်များကို အသုံးပြုခြင်းအတွက် ပိုမိုအသေးစိတ်ပြီး နောက်ဆုံးပေါ် အကူအညီကို help() command ကို အသုံးပြု၍ သို့မဟုတ် Shift+Tab ကို အသုံးပြု၍ အမြဲတမ်း ရယူနိုင်ပါသည်။

နိဒါန်း

သင်ကိုယ်တိုင်နှင့် မူရင်းရင်းမြစ်များကို ရှာဖွေဖတ်ရှုခြင်းမှ ကယ်တင်ရန်အတွက် နည်းလမ်းများ၏ ဖော်ပြချက်များနှင့် လင့်ခ်များကို အဓိကအားဖြင့် Wikipedia တွင်ရှိပါမည်။ စည်းမျဉ်းအရ၊ ဤအချက်အလက်သည် ယေဘုယျစည်းကမ်းချက်များနှင့် ၎င်းတို့၏လျှောက်လွှာအတွက် အခြေအနေများကို နားလည်ရန် လုံလောက်ပါသည်။ သင်္ချာနည်းလမ်းများ၏ အနှစ်သာရကို နားလည်ရန်၊ ဆောင်းပါးတစ်ခုစီ၏အဆုံးတွင် သို့မဟုတ် သင်နှစ်သက်သော ရှာဖွေရေးအင်ဂျင်တွင် တွေ့ရှိနိုင်သည့် ပိုမိုတရားဝင်သော ထုတ်ဝေမှုများ၏ လင့်ခ်များကို လိုက်နာပါ။

ထို့ကြောင့်၊ scipy.optimize module တွင် အောက်ပါလုပ်ထုံးလုပ်နည်းများကို အကောင်အထည်ဖော်ခြင်း ပါဝင်သည်။

1. အမျိုးမျိုးသော algorithms (Nelder-Mead simplex၊ BFGS၊ Newton conjugate gradients၊ COBYLA и SLSQP)
2. ကမ္ဘာလုံးဆိုင်ရာ ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်း (ဥပမာ- basinhopping, ကွဲပြားမှု_ဆင့်ကဲဖြစ်စဉ်)
3. အကြွင်းအကျန်များကို လျှော့ချခြင်း။ MNC (အနည်းဆုံး_စတုရန်းများ) နှင့် မျဉ်းကွေးလိုက်ဖက်သော အယ်လဂိုရီသမ်များ
4. variable တစ်ခု (minim_scalar) နှင့် roots (root_scalar) ကိုရှာဖွေခြင်း
5. အမျိုးမျိုးသော algorithms (hybrid Powell၊ Levenberg-Marquardt သို့မဟုတ် ကြီးမားသောနည်းလမ်းများဖြစ်သည့် Newton-Krylov).

ဤဆောင်းပါးတွင် ဤစာရင်းတစ်ခုလုံးမှ ပထမဆုံးအကြောင်းအရာကိုသာ သုံးသပ်ပါမည်။

ကိန်းရှင်များစွာ၏ စကေးလုပ်ဆောင်ချက်ကို ခြွင်းချက်မရှိ လျှော့ချခြင်း။

scipy.optimize ပက်ကေ့ချ်မှ အနိမ့်ဆုံးလုပ်ဆောင်ချက်သည် ကိန်းရှင်များစွာ၏ စကေးလုပ်ငန်းဆောင်တာများ၏ အခြေအနေဆိုင်ရာနှင့် ခြွင်းချက်မရှိ လျှော့ချခြင်းပြဿနာများကို ဖြေရှင်းရန်အတွက် ယေဘူယျမျက်နှာပြင်ကို ပေးဆောင်သည်။ ၎င်းအလုပ်လုပ်ပုံကို သရုပ်ပြရန်၊ ကျွန်ုပ်တို့သည် မတူညီသောနည်းလမ်းများဖြင့် သေးငယ်အောင်ပြုလုပ်မည့် ကိန်းရှင်များစွာ၏ သင့်လျော်သောလုပ်ဆောင်ချက်တစ်ခု လိုအပ်ပါသည်။

ဤရည်ရွယ်ချက်များအတွက်၊ N variable များ၏ 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 လုပ်ဆောင်ချက်၏ အနည်းဆုံးတန်ဖိုးကို ဆုံးဖြတ်နည်းနမူနာများကို ကြည့်ကြပါစို့။

Nelder-Mead ရိုးရှင်းသောနည်းလမ်း

0-dimensional space တွင် ကနဦးအမှတ် x5 ရှိပါစေ။ အယ်လဂိုရီသမ်ကို အသုံးပြု၍ Rosenbrock လုပ်ဆောင်ချက်၏ အနိမ့်ဆုံးအမှတ်ကို ရှာကြည့်ကြပါစို့ Nelder-Mead ရိုးရိုး (algorithm ကို method parameter ၏တန်ဖိုးအဖြစ်သတ်မှတ်ထားသည်)

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.]

ရိုးရှင်းသောနည်းလမ်းသည် ရှင်းလင်းပြတ်သားစွာသတ်မှတ်ထားပြီး မျှမျှတတချောမွေ့သောလုပ်ဆောင်ချက်ကို လျှော့ချရန် အရိုးရှင်းဆုံးနည်းလမ်းဖြစ်သည်။ လုပ်ဆောင်ချက်တစ်ခု၏ ဆင်းသက်လာမှုကို တွက်ချက်ရန် မလိုအပ်ပါ၊ ၎င်းသည် ၎င်း၏တန်ဖိုးများကိုသာ သတ်မှတ်ရန် လုံလောက်ပါသည်။ Nelder-Mead နည်းလမ်းသည် ရိုးရှင်းသော ပြဿနာများကို နည်းပါးအောင်ပြုလုပ်ရန် ရွေးချယ်မှုကောင်းတစ်ခုဖြစ်သည်။ သို့သော်၊ ၎င်းသည် gradient ခန့်မှန်းချက်များကို အသုံးမပြုသောကြောင့် အနိမ့်ဆုံးကိုရှာဖွေရန် အချိန်ပိုကြာနိုင်သည်။

Powell နည်းလမ်း

လုပ်ဆောင်ချက်တန်ဖိုးများကိုသာ တွက်ချက်သည့် အခြား optimization algorithm တစ်ခုဖြစ်သည်။ Powell ၏နည်းလမ်း. ၎င်းကိုအသုံးပြုရန်၊ အနည်းဆုံးလုပ်ဆောင်ချက်တွင် 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.]

Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm

အဖြေတစ်ခုဆီသို့ လျင်မြန်စွာပေါင်းစည်းမှုရရှိရန်၊ လုပ်ထုံးလုပ်နည်း BFGS objective function ၏ gradient ကိုအသုံးပြုသည်။ gradient ကို function တစ်ခုအဖြစ် သတ်မှတ်နိုင်သည် သို့မဟုတ် first order ခြားနားချက်များကို အသုံးပြု၍ တွက်ချက်နိုင်သည်။ မည်သို့ပင်ဆိုစေကာမူ BFGS နည်းလမ်းသည် ရိုးရှင်းသောနည်းလမ်းထက် လုပ်ဆောင်ချက်ခေါ်ဆိုမှုအနည်းငယ်သာ လိုအပ်ပါသည်။

Rosenbrock လုပ်ဆောင်ချက်၏ ဆင်းသက်လာခြင်းကို ခွဲခြမ်းစိတ်ဖြာမှုပုံစံဖြင့် ရှာဖွေကြပါစို့။

ဤစကားရပ်သည် ပထမနှင့် နောက်ဆုံးမှလွဲ၍ ကိန်းရှင်အားလုံး၏ ဆင်းသက်လာခြင်းအတွက် အကျုံးဝင်သည်၊

ဤ gradient ကိုတွက်ချက်သည့် Python လုပ်ဆောင်ချက်ကို ကြည့်ကြပါစို့။

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

အောက်ဖော်ပြပါအတိုင်း အနိမ့်ဆုံးလုပ်ဆောင်ချက်၏ jac ဘောင်၏တန်ဖိုးအဖြစ် gradient တွက်ချက်မှုလုပ်ဆောင်ချက်ကို သတ်မှတ်ထားသည်။

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]

Conjugate gradient algorithm (နယူတန်)

algorithm ကို နယူတန်၏ ပေါင်းစပ်ထားသော gradients များ ပြုပြင်ထားသောနယူတန်၏နည်းလမ်းတစ်ခုဖြစ်သည်။
နယူတန်၏နည်းလမ်းသည် ဒေသဧရိယာတစ်ခုအတွင်း လုပ်ဆောင်ချက်တစ်ခုအား ဒုတိယဒီဂရီ၏ polynomial ဖြင့် ခန့်မှန်းခြင်းအပေါ် အခြေခံသည်။

ဘယ်မှာ ဒုတိယ ဆင်းသက်လာသော မက်ထရစ် (Hessian matrix၊ Hessian)။
Hessian သည် အပြုသဘောဆောင်သော အတိအကျဖြစ်ပါက၊ လေးထောင့်ပုံသဏ္ဍာန်၏ သုည Gradient ကို သုညမှ သုညအထိ ညီမျှခြင်းဖြင့် ဤလုပ်ဆောင်ချက်၏ ဒေသဆိုင်ရာ အနိမ့်ဆုံးကို ရှာတွေ့နိုင်ပါသည်။ ရလဒ်သည် စကားရပ်ဖြစ်သည်၊

Inverse Hessian ကို conjugate gradient method ဖြင့် တွက်ချက်သည်။ Rosenbrock လုပ်ဆောင်ချက်ကို လျှော့ချရန် ဤနည်းလမ်းကို အသုံးပြုခြင်း၏ ဥပမာကို အောက်တွင် ဖော်ပြထားသည်။ Newton-CG နည်းလမ်းကို အသုံးပြုရန်၊ သင်သည် Hessian ကို တွက်ချက်သည့် လုပ်ဆောင်ချက်ကို သတ်မှတ်ရပါမည်။
ခွဲခြမ်းစိတ်ဖြာမှုပုံစံတွင် Hessian of the Rosenbrock လုပ်ဆောင်ချက်သည် ညီမျှသည်-

ဘယ်မှာ и ၊ matrix ကိုသတ်မှတ်ပါ။ .

matrix ၏ ကျန်ရှိသော သုညမဟုတ်သောဒြပ်စင်များသည် တူညီသည်-

ဥပမာအားဖြင့်၊ ငါးဖက်မြင် အာကာသ N=5 တွင် Rosenbrock လုပ်ဆောင်ချက်အတွက် Hessian matrix သည် တီးဝိုင်းပုံစံ ရှိသည်-

ဤ Hessian ကို တွက်ချက်သော ကုဒ်နှင့်အတူ Rosenbrock လုပ်ဆောင်ချက်ကို လျှော့နည်းစေရန် ကုဒ်ဖြင့် ပေါင်းစပ်ထားသော gradient (နယူတန်) နည်းလမ်းကို အသုံးပြုသည်-

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]

Hessian ၏ ထုတ်ကုန်လုပ်ငန်းဆောင်တာ၏ အဓိပ္ပါယ်ဖွင့်ဆိုချက်နှင့် မတရားသော vector တစ်ခု

လက်တွေ့ကမ္ဘာပြဿနာများတွင် Hessian matrix တစ်ခုလုံးကို တွက်ချက်ခြင်းနှင့် သိမ်းဆည်းခြင်းသည် သိသာထင်ရှားသော အချိန်နှင့် မှတ်ဉာဏ်အရင်းအမြစ်များ လိုအပ်ပါသည်။ ဤကိစ္စတွင်၊ အဘယ်ကြောင့်ဆိုသော် Hessian matrix ကိုယ်တိုင်သတ်မှတ်ရန်မလိုအပ်ပါ။ အနိမ့်ဆုံးလုပ်ထုံးလုပ်နည်းသည် အခြားမဟုတ်သော vector ဖြင့် Hessian ၏ ထုတ်ကုန်နှင့် ညီမျှသော vector တစ်ခုသာ လိုအပ်သည်။ ထို့ကြောင့်၊ ကွန်ပြူတာရှုထောင့်မှကြည့်လျှင် Hessian ထုတ်ကုန်၏ရလဒ်ကို မထင်သလို vector ဖြင့် ပြန်ပေးသည့် လုပ်ဆောင်ချက်ကို ချက်ချင်းသတ်မှတ်ရန် ပိုမိုကောင်းမွန်ပါသည်။

ပထမအငြင်းအခုံအဖြစ် minimization vector ကိုယူဆောင်သည့် hess function နှင့် ဒုတိယအငြင်းအခုံအဖြစ် arbitrary vector ( minimized လုပ်ရန် function ၏အခြား argument များနှင့်အတူ) ။ ကျွန်ုပ်တို့၏အခြေအနေတွင်၊ Hessian of the Rosenbrock လုပ်ဆောင်ချက်၏ ထုတ်ကုန်ကို မှားယွင်းသော vector ဖြင့် တွက်ချက်ရန်မှာ အလွန်ခက်ခဲသည်မဟုတ်ပါ။ အကယ်လို့ p မတရားသော vector တစ်ခုဖြစ်ပြီး၊ ထို့နောက် ထုတ်ကုန်ဖြစ်သည်။ ပုံသည်-

Hessian ၏ ထုတ်ကုန်ကို တွက်ချက်သော လုပ်ဆောင်ချက်နှင့် မထင်မှတ်ထားသော vector တစ်ခုကို အနိမ့်ဆုံး လုပ်ဆောင်မှုသို့ hessp အကြောင်းပြချက်၏ တန်ဖိုးအဖြစ် ဖြတ်သွားသည်-

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

Conjugate gradient trust region algorithm (Newton)

Hessian matrix ၏ ညံ့ဖျင်းသောအေးစက်မှုနှင့် မှားယွင်းသောရှာဖွေမှုလမ်းညွှန်ချက်များသည် Newton ၏ conjugate gradient algorithm ကို ထိရောက်မှုမရှိစေပါ။ ထိုသို့သော အခြေအနေမျိုးတွင် ဦးစားပေးသည်။ ဒေသနည်းလမ်းကို ယုံကြည်ပါ။ (trust-region) နယူတန် gradients များကို ပေါင်းစပ်ထားသည်။

Hessian matrix ၏အဓိပ္ပါယ်ဖွင့်ဆိုချက်နှင့် ဥပမာ-

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.]

Hessian ၏ ထုတ်ကုန်လုပ်ဆောင်ချက်နှင့် မတရားသော vector နှင့် ဥပမာ-

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.]

Krylov အမျိုးအစားနည်းလမ်းများ

ယုံကြည်စိတ်ချရသော ncg နည်းလမ်းကဲ့သို့ပင်၊ Krylov-type နည်းလမ်းများသည် matrix-vector ထုတ်ကုန်များကိုသာ အသုံးပြုသောကြောင့် ကြီးမားသောပြဿနာများကို ဖြေရှင်းရန်အတွက် ကောင်းမွန်သင့်လျော်ပါသည်။ ၎င်းတို့၏ အနှစ်သာရမှာ ဖြတ်တောက်ထားသော Krylov နေရာခွဲမှ ကန့်သတ်ထားသော ယုံကြည်မှုနယ်မြေတစ်ခုတွင် ပြဿနာတစ်ခုကို ဖြေရှင်းရန်ဖြစ်သည်။ မသေချာသောပြဿနာများအတွက်၊ ယုံကြည်စိတ်ချရသော-ncg နည်းလမ်းနှင့် နှိုင်းယှဉ်ပါက ပြဿနာခွဲတစ်ခုအတွက် matrix-vector ထုတ်ကုန်အရေအတွက် နည်းပါးခြင်းကြောင့် ၎င်းသည် လိုင်းမဟုတ်သော ထပ်ခြင်းအရေအတွက် နည်းပါးသောကြောင့် ဤနည်းလမ်းကို အသုံးပြုခြင်းက ပိုကောင်းပါသည်။ ထို့အပြင်၊ quadratic subproblem ၏အဖြေသည် trust-ncg method ကိုအသုံးပြုခြင်းထက်ပိုမိုတိကျစွာတွေ့ရှိရသည်။
Hessian matrix ၏အဓိပ္ပါယ်ဖွင့်ဆိုချက်နှင့် ဥပမာ-

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.]

Hessian ၏ ထုတ်ကုန်လုပ်ဆောင်ချက်နှင့် မတရားသော vector နှင့် ဥပမာ-

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.]

ယုံကြည်မှုနယ်မြေရှိ အနီးစပ်ဆုံးအဖြေအတွက် အယ်လဂိုရီသမ်

နည်းလမ်းအားလုံး (Newton-CG၊ trust-ncg နှင့် trust-krylov) သည် ကြီးမားသောပြဿနာများ (ကိန်းရှင်ပေါင်း ထောင်ချီရှိသော) ကိုဖြေရှင်းရန်အတွက် ကောင်းမွန်သင့်လျော်ပါသည်။ ၎င်းသည် အရင်းခံပေါင်းစပ်ထားသော gradient algorithm သည် ပြောင်းပြန် Hessian matrix ၏ အနီးစပ်ဆုံး အဆုံးအဖြတ်ကို အဓိပ္ပာယ်သက်ရောက်စေသောကြောင့်ဖြစ်သည်။ Hessian ၏ ရှင်းလင်းပြတ်သားစွာ ချဲ့ထွင်ခြင်းမရှိဘဲ အထပ်ထပ်အခါခါ ဖြေရှင်းချက်ကို တွေ့ရှိရသည်။ Hessian နှင့် မတရားသော vector ၏ ထုတ်ကုန်အတွက် လုပ်ဆောင်ချက်တစ်ခုကို သင်သတ်မှတ်ရန်သာ လိုအပ်သောကြောင့်၊ ဤ algorithm သည် sparse (band diagonal) matrices နှင့် လုပ်ဆောင်ရန်အတွက် အထူးကောင်းမွန်ပါသည်။ ၎င်းသည် မှတ်ဉာဏ်ကုန်ကျစရိတ်နည်းပါးပြီး အချိန်ကုန်သက်သာစေသည်။

အလတ်စား ပြဿနာများအတွက်၊ Hessian ကို သိုလှောင်ခြင်းနှင့် တပ်ဆင်ခြင်းအတွက် ကုန်ကျစရိတ်သည် မစိုးရိမ်ရပါ။ ဆိုလိုသည်မှာ ယုံကြည်မှုနယ်မြေ၏ ပြဿနာခွဲများကို အတိအကျနီးပါး အတိအကျနီးပါး အကြိမ်ရေ အနည်းငယ်မျှဖြင့် ဖြေရှင်းနိုင်သည်ဟု ဆိုလိုသည်။ ဒါကိုလုပ်ဖို့၊ အချို့သော မျဉ်းမညီမျှခြင်းများကို လေးထောင့်ပုံပြဿနာတစ်ခုစီအတွက် ထပ်ခါတလဲလဲ ဖြေရှင်းသည်။ ထိုသို့သောအဖြေတစ်ခုသည် များသောအားဖြင့် Hessian matrix ၏ Cholesky ပြိုကွဲမှု 3 သို့မဟုတ် 4 လိုအပ်သည်။ ရလဒ်အနေဖြင့်၊ နည်းလမ်းသည် ထပ်ခါထပ်ခါပြုလုပ်မှုနည်းပါးပြီး ပေါင်းစပ်လုပ်ဆောင်ပြီး အခြားယုံကြည်စိတ်ချရသောဒေသနည်းလမ်းများထက် ရည်မှန်းချက်ဆိုင်ရာလုပ်ဆောင်မှုတွက်ချက်မှုများကို အနည်းငယ်လိုအပ်သည်။ ဤအယ်လဂိုရီသမ်တွင် ပြီးပြည့်စုံသော Hessian မက်ထရစ်ကို ဆုံးဖြတ်ခြင်းတွင်သာ ပါဝင်ပြီး Hessian ၏ ထုတ်ကုန်လုပ်ဆောင်ချက်နှင့် မတရားသော vector ကို အသုံးပြုနိုင်စွမ်းကို မပံ့ပိုးပါ။

Rosenbrock လုပ်ဆောင်ချက်ကို လျှော့ချခြင်းဖြင့် ဥပမာ-

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.])

ငါတို့အဲဒီမှာရပ်နေလိမ့်မယ်။ နောက်ဆောင်းပါးတွင် အခြေအနေအလိုက် လျှော့ချခြင်းဆိုင်ရာ စိတ်ဝင်စားစရာအကောင်းဆုံးအရာများ၊ အနီးစပ်ဆုံးပြဿနာများကိုဖြေရှင်းရာတွင် နည်းပါးအောင်အသုံးချခြင်း၊ ကိန်းရှင်တစ်ခု၏လုပ်ဆောင်ချက်ကို နည်းပါးအောင်ပြုလုပ်ခြင်း၊ မထင်သလို minimizer များနှင့် scipy.optimize ကိုအသုံးပြု၍ ညီမျှခြင်းစနစ်၏အမြစ်များကိုရှာဖွေခြင်းအကြောင်း နောက်ဆောင်းပါးတွင် ကျွန်ုပ်ပြောပြပါမည်။ အထုပ်။

source: https://docs.scipy.org/doc/scipy/reference/

source: www.habr.com