SciPy, ການເພີ່ມປະສິດທິພາບ

SciPy (pronounced sai pie) ແມ່ນຊຸດຄໍາຮ້ອງສະຫມັກທາງຄະນິດສາດໂດຍອີງໃສ່ການຂະຫຍາຍ Numpy Python. ດ້ວຍ SciPy, ເຊດຊັນ Python ແບບໂຕ້ຕອບຂອງເຈົ້າກາຍເປັນວິທະຍາສາດຂໍ້ມູນທີ່ສົມບູນແບບດຽວກັນ ແລະສະພາບແວດລ້ອມການສ້າງຕົວແບບລະບົບທີ່ຊັບຊ້ອນເຊັ່ນ MATLAB, IDL, Octave, R-Lab, ແລະ SciLab. ມື້ນີ້ຂ້ອຍຢາກເວົ້າສັ້ນໆກ່ຽວກັບວິທີການໃຊ້ວິທີການເພີ່ມປະສິດທິພາບທີ່ຮູ້ຈັກໃນຊຸດ scipy.optimize. ການຊ່ວຍເຫຼືອທີ່ລະອຽດກວ່າ ແລະທັນສະໃໝກວ່າໃນການນຳໃຊ້ຟັງຊັນຕ່າງໆສາມາດໄດ້ຮັບໄດ້ສະເໝີໂດຍໃຊ້ຄຳສັ່ງ help() ຫຼືໃຊ້ Shift+Tab.

ການນໍາສະເຫນີ

ເພື່ອຊ່ວຍປະຢັດຕົວທ່ານເອງແລະຜູ້ອ່ານຈາກການຄົ້ນຫາແລະການອ່ານແຫຼ່ງຕົ້ນຕໍ, ການເຊື່ອມຕໍ່ກັບຄໍາອະທິບາຍວິທີການສ່ວນໃຫຍ່ແມ່ນຢູ່ໃນ Wikipedia. ຕາມກົດລະບຽບ, ຂໍ້ມູນນີ້ແມ່ນພຽງພໍທີ່ຈະເຂົ້າໃຈວິທີການໃນຂໍ້ກໍານົດທົ່ວໄປແລະເງື່ອນໄຂສໍາລັບຄໍາຮ້ອງສະຫມັກຂອງພວກເຂົາ. ເພື່ອເຂົ້າໃຈຄວາມສໍາຄັນຂອງວິທີການທາງຄະນິດສາດ, ປະຕິບັດຕາມການເຊື່ອມຕໍ່ກັບສິ່ງພິມທີ່ມີອໍານາດຫຼາຍ, ເຊິ່ງສາມາດພົບໄດ້ໃນຕອນທ້າຍຂອງແຕ່ລະບົດຄວາມຫຼືໃນເຄື່ອງຈັກຊອກຫາທີ່ທ່ານມັກ.

ດັ່ງນັ້ນ, ໂມດູນ scipy.optimize ປະກອບມີການປະຕິບັດຂັ້ນຕອນຕໍ່ໄປນີ້:

1. ການຫຼຸດຫນ້ອຍລົງແບບມີເງື່ອນໄຂ ແລະບໍ່ມີເງື່ອນໄຂຂອງຟັງຊັນ scalar ຂອງຕົວແປຫຼາຍຕົວແປ (ໜ້ອຍສຸດ) ໂດຍໃຊ້ສູດການຄິດໄລ່ຕ່າງໆ (Nelder-Mead simplex, BFGS, Newton conjugate gradients, ໂຄບີລາ и SLSQP)
2. ການເພີ່ມປະສິດທິພາບທົ່ວໂລກ (ຕົວຢ່າງ: basinhopping, diff_evolution)
3. ຫຼຸດຜ່ອນການຕົກຄ້າງ MNC (least_squares) ແລະ​ສູດ​ການ​ປັບ​ເສັ້ນ​ໂຄ້ງ​ໂດຍ​ການ​ນໍາ​ໃຊ້​ສີ່​ຫຼ່ຽມ​ມົນ​ນ້ອຍ​ທີ່​ບໍ່​ແມ່ນ​ເສັ້ນ (curve_fit​)
4. ການຫຼຸດຜ່ອນການທໍາງານຂອງ scalar ຂອງຕົວແປຫນຶ່ງ (minim_scalar) ແລະການຊອກຫາຮາກ (root_scalar)
5. ຕົວແກ້ໄຂຫຼາຍມິຕິຂອງລະບົບສົມຜົນ (ຮາກ) ໂດຍໃຊ້ສູດການຄິດໄລ່ຕ່າງໆ (ປະສົມ Powell, Levenberg-Marquardt ຫຼືວິທີການຂະຫນາດໃຫຍ່ເຊັ່ນ: Newton-Krylov).

ໃນບົດຄວາມນີ້ພວກເຮົາຈະພິຈາລະນາພຽງແຕ່ລາຍການທໍາອິດຈາກບັນຊີລາຍຊື່ທັງຫມົດນີ້.

ການຫຼຸດຫນ້ອຍລົງແບບບໍ່ມີເງື່ອນໄຂຂອງຟັງຊັນ scalar ຂອງຕົວແປຫຼາຍອັນ

ຟັງຊັນນ້ອຍສຸດຈາກຊຸດ scipy.optimize ສະຫນອງການໂຕ້ຕອບທົ່ວໄປສໍາລັບການແກ້ໄຂບັນຫາການຫຼຸດຜ່ອນເງື່ອນໄຂແລະບໍ່ມີເງື່ອນໄຂຂອງຟັງຊັນ scalar ຂອງຫຼາຍຕົວແປ. ເພື່ອສະແດງໃຫ້ເຫັນວິທີການເຮັດວຽກ, ພວກເຮົາຈະຕ້ອງການຟັງຊັນທີ່ເຫມາະສົມຂອງຕົວແປຫຼາຍ, ເຊິ່ງພວກເຮົາຈະຫຼຸດລົງໃນວິທີຕ່າງໆ.

ສໍາລັບຈຸດປະສົງເຫຼົ່ານີ້, ຫນ້າທີ່ Rosenbrock ຂອງ N variables ແມ່ນສົມບູນແບບ, ເຊິ່ງມີຮູບແບບ:

ເຖິງວ່າຈະມີຄວາມຈິງທີ່ວ່າຟັງຊັນ Rosenbrock ແລະ Jacobi ແລະ Hessian matrices ຂອງມັນ (ອະນຸພັນທໍາອິດແລະທີສອງ, ຕາມລໍາດັບ) ຖືກກໍານົດໄວ້ໃນຊຸດ 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)

ເພື່ອຄວາມຊັດເຈນ, ໃຫ້ພວກເຮົາແຕ້ມໃນ 3D ຄ່າຂອງຟັງຊັນ Rosenbrock ຂອງສອງຕົວແປ.

ລະຫັດແຕ້ມ

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 ຢູ່ , ໃຫ້ເບິ່ງຕົວຢ່າງຂອງວິທີການກໍານົດຄ່າຕໍາ່ສຸດທີ່ຂອງຟັງຊັນ Rosenbrock ໂດຍໃຊ້ຂັ້ນຕອນຕ່າງໆຂອງ scipy.optimize.

ວິທີ Nelder-Mead simplex

ໃຫ້ມີຈຸດເລີ່ມຕົ້ນ x0 ໃນພື້ນທີ່ 5 ມິຕິ. ໃຫ້ຊອກຫາຈຸດຕໍາ່ສຸດທີ່ຂອງຟັງຊັນ Rosenbrock ທີ່ໃກ້ທີ່ສຸດກັບມັນໂດຍໃຊ້ algorithm Nelder-Mead simplex (ສູດການຄິດໄລ່ແມ່ນລະບຸເປັນຄ່າຂອງຕົວກໍານົດວິທີການ):

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

ວິທີການ simplex ແມ່ນວິທີທີ່ງ່າຍທີ່ສຸດທີ່ຈະຫຼຸດຜ່ອນການທໍາງານທີ່ຖືກກໍານົດຢ່າງຊັດເຈນແລະລຽບງ່າຍ. ມັນບໍ່ໄດ້ຮຽກຮ້ອງໃຫ້ມີການຄິດໄລ່ອະນຸພັນຂອງຟັງຊັນ; ມັນພຽງພໍທີ່ຈະລະບຸຄ່າຂອງມັນເທົ່ານັ້ນ. ວິທີການ Nelder-Mead ເປັນທາງເລືອກທີ່ດີສໍາລັບບັນຫາການຫຼຸດຜ່ອນງ່າຍດາຍ. ຢ່າງໃດກໍ່ຕາມ, ເນື່ອງຈາກມັນບໍ່ໄດ້ໃຊ້ການປະເມີນລະດັບສີ, ມັນອາດໃຊ້ເວລາດົນກວ່າເພື່ອຊອກຫາຕໍາ່ສຸດທີ່.

ວິ​ທີ​ການ Powell

ສູດການຄິດໄລ່ການເພີ່ມປະສິດທິພາບອີກອັນໜຶ່ງທີ່ພຽງແຕ່ຄ່າຟັງຊັນຖືກຄຳນວນເທົ່ານັ້ນ ວິທີການຂອງ 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

ເພື່ອ​ໃຫ້​ໄດ້​ຮັບ convergence ໄວ​ຂຶ້ນ​ກັບ​ການ​ແກ້​ໄຂ​, ຂັ້ນ​ຕອນ​ການ​ BFGS ໃຊ້ gradient ຂອງຟັງຊັນຈຸດປະສົງ. gradient ສາມາດຖືກກໍານົດເປັນຟັງຊັນຫຼືຄິດໄລ່ໂດຍໃຊ້ຄວາມແຕກຕ່າງຄໍາສັ່ງທໍາອິດ. ໃນກໍລະນີໃດກໍ່ຕາມ, ວິທີການ BFGS ໂດຍປົກກະຕິຮຽກຮ້ອງໃຫ້ມີການໂທຫາຫນ້າທີ່ຫນ້ອຍກວ່າວິທີການ simplex.

ໃຫ້ພວກເຮົາຊອກຫາຕົວພັນຂອງຟັງຊັນ Rosenbrock ໃນຮູບແບບການວິເຄາະ:

ການສະແດງອອກນີ້ແມ່ນຖືກຕ້ອງສໍາລັບຕົວແປຂອງຕົວແປທັງຫມົດຍົກເວັ້ນຕົວທໍາອິດແລະສຸດທ້າຍ, ເຊິ່ງຖືກກໍານົດເປັນ:

ລອງເບິ່ງຟັງຊັນ Python ທີ່ຄິດໄລ່ gradient ນີ້:

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

ຟັງຊັນການຄິດໄລ່ gradient ແມ່ນລະບຸເປັນຄ່າຂອງ jac ພາລາມິເຕີຂອງຟັງຊັນຂັ້ນຕໍ່າ, ດັ່ງທີ່ສະແດງຢູ່ຂ້າງລຸ່ມ.

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 (ນິວຕັນ)

ລະບົບວິເຄາະ ລະດັບການເຊື່ອມຂອງນິວຕັນ ແມ່ນວິທີການຂອງນິວຕັນທີ່ຖືກດັດແປງ.
ວິທີການຂອງ Newton ແມ່ນອີງໃສ່ການປະມານການທໍາງານໃນພື້ນທີ່ທ້ອງຖິ່ນໂດຍ polynomial ຂອງລະດັບທີສອງ:

ບ່ອນທີ່ ແມ່ນເມທຣິກຂອງອະນຸພັນທີສອງ (Hessian matrix, Hessian).
ຖ້າ Hessian ມີຄວາມແນ່ນອນດ້ານບວກ, ຫຼັງຈາກນັ້ນ, ຕໍາ່ສຸດທີ່ໃນທ້ອງຖິ່ນຂອງຟັງຊັນນີ້ສາມາດພົບໄດ້ໂດຍການສົມຜົນຂອງ gradient ສູນຂອງຮູບແບບສີ່ຫລ່ຽມເປັນສູນ. ຜົນໄດ້ຮັບຈະເປັນການສະແດງອອກ:

ການປີ້ນ Hessian ຖືກຄິດໄລ່ໂດຍໃຊ້ວິທີການ gradient conjugate. ຕົວຢ່າງຂອງການໃຊ້ວິທີນີ້ເພື່ອຫຼຸດຜ່ອນການທໍາງານ Rosenbrock ແມ່ນໃຫ້ຂ້າງລຸ່ມນີ້. ເພື່ອໃຊ້ວິທີການ Newton-CG, ທ່ານຕ້ອງລະບຸຟັງຊັນທີ່ຄິດໄລ່ Hessian.
ຟັງຊັນ Hessian ຂອງ Rosenbrock ໃນຮູບແບບການວິເຄາະແມ່ນເທົ່າກັບ:

ບ່ອນທີ່ и , ກໍານົດ matrix ໄດ້ .

ອົງປະກອບທີ່ບໍ່ແມ່ນສູນທີ່ຍັງເຫຼືອຂອງ matrix ແມ່ນເທົ່າກັບ:

ຕົວຢ່າງ, ໃນຊ່ອງຫ້າມິຕິ N = 5, Hessian matrix ສໍາລັບຟັງຊັນ Rosenbrock ມີຮູບແບບຂອງແຖບ:

ລະຫັດທີ່ຄິດໄລ່ Hessian ນີ້ພ້ອມກັບລະຫັດສໍາລັບການຫຼຸດຜ່ອນການທໍາງານຂອງ Rosenbrock ໂດຍໃຊ້ວິທີການ conjugate gradient (Newton):

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 arbitrary

ໃນບັນຫາທີ່ແທ້ຈິງ, ຄອມພິວເຕີ້ແລະເກັບຮັກສາ Hessian matrix ທັງຫມົດສາມາດຕ້ອງການເວລາແລະຄວາມຊົງຈໍາທີ່ສໍາຄັນ. ໃນກໍລະນີນີ້, ຕົວຈິງແລ້ວບໍ່ຈໍາເປັນຕ້ອງລະບຸ Matrix Hessian ຕົວຂອງມັນເອງ, ເພາະວ່າ ຂັ້ນ​ຕອນ​ການ​ຫຼຸດ​ຜ່ອນ​ຮຽກ​ຮ້ອງ​ໃຫ້​ມີ​ພຽງ​ແຕ່ vector ເທົ່າ​ກັບ​ຜະ​ລິດ​ຕະ​ພັນ​ຂອງ Hessian ທີ່​ມີ vector ທີ່​ຕົນ​ເອງ​ອື່ນ​. ດັ່ງນັ້ນ, ຈາກມຸມເບິ່ງການຄິດໄລ່, ມັນດີກວ່າທີ່ຈະກໍານົດຟັງຊັນທີ່ສົ່ງຄືນຜົນໄດ້ຮັບຂອງຜະລິດຕະພັນຂອງ Hessian ດ້ວຍ vector arbitrary.

ພິຈາລະນາຟັງຊັນ hess, ເຊິ່ງໃຊ້ເວລາ vector ການຫຼຸດຜ່ອນເປັນ argument ທໍາອິດ, ແລະ vector arbitrary ເປັນ argument ທີສອງ (ຄຽງຄູ່ກັບການ argument ອື່ນໆຂອງຟັງຊັນທີ່ຈະ minimized). ໃນກໍລະນີຂອງພວກເຮົາ, ການຄິດໄລ່ຜະລິດຕະພັນຂອງ Hessian ຂອງຟັງຊັນ Rosenbrock ດ້ວຍ vector arbitrary ບໍ່ແມ່ນເລື່ອງຍາກຫຼາຍ. ຖ້າ p ເປັນ vector arbitrary, ຫຼັງຈາກນັ້ນຜະລິດຕະພັນ ເບິ່ງ​ຄື:

ຟັງຊັນທີ່ຄຳນວນຜະລິດຕະພັນຂອງ Hessian ແລະ vector arbitrary ຖືກສົ່ງຜ່ານເປັນຄ່າຂອງ hessp argument ໄປຫາຟັງຊັນ minimize:

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 ແລະທິດທາງການຄົ້ນຫາທີ່ບໍ່ຖືກຕ້ອງສາມາດເຮັດໃຫ້ລະບົບ gradient algorithm ຂອງ Newton ບໍ່ມີປະສິດທິພາບ. ໃນກໍລະນີດັ່ງກ່າວ, ຄວາມຕ້ອງການແມ່ນໃຫ້ ວິ​ທີ​ພາກ​ພື້ນ​ເຊື່ອ​ຖື​ (trust-region) conjugate Newton 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 arbitrary:

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

ເຊັ່ນດຽວກັນກັບວິທີການ trust-ncg, ວິທີການປະເພດ Krylov ແມ່ນເຫມາະສົມດີສໍາລັບການແກ້ໄຂບັນຫາຂະຫນາດໃຫຍ່ເພາະວ່າພວກເຂົາໃຊ້ພຽງແຕ່ຜະລິດຕະພັນ matrix-vector. ໂດຍເນື້ອແທ້ແລ້ວຂອງພວກມັນແມ່ນເພື່ອແກ້ໄຂບັນຫາໃນພາກພື້ນທີ່ມີຄວາມເຊື່ອຫມັ້ນທີ່ຈໍາກັດໂດຍພື້ນທີ່ຍ່ອຍ Krylov ທີ່ຖືກຕັດອອກ. ສໍາລັບບັນຫາທີ່ບໍ່ແນ່ນອນ, ມັນກໍ່ດີກວ່າທີ່ຈະໃຊ້ວິທີນີ້, ເພາະວ່າມັນໃຊ້ຈໍານວນຫນ້ອຍຂອງ nonlinear iterations ເນື່ອງຈາກຈໍານວນຜະລິດຕະພັນ matrix-vector ຫນ້ອຍລົງຕໍ່ບັນຫາຍ່ອຍ, ເມື່ອທຽບກັບວິທີການ trust-ncg. ນອກຈາກນັ້ນ, ການແກ້ໄຂບັນຫາຍ່ອຍ quadratic ແມ່ນພົບເຫັນຢ່າງຖືກຕ້ອງກວ່າການໃຊ້ວິທີການ trust-ncg.
ຕົວຢ່າງກັບຄໍານິຍາມຂອງ 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 arbitrary:

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) ແມ່ນເຫມາະສົມດີສໍາລັບການແກ້ໄຂບັນຫາຂະຫນາດໃຫຍ່ (ມີຕົວແປຫຼາຍພັນຕົວ). ນີ້ແມ່ນເນື່ອງມາຈາກຄວາມຈິງທີ່ວ່າ algorithm gradient conjugate ທີ່ຢູ່ເບື້ອງຕົ້ນຫມາຍເຖິງການກໍານົດໂດຍປະມານຂອງ matrix Hessian inverse. ການ​ແກ້​ໄຂ​ແມ່ນ​ໄດ້​ພົບ​ເຫັນ​ຊ​້​ໍາ​, ໂດຍ​ບໍ່​ມີ​ການ​ຂະ​ຫຍາຍ​ຕົວ​ຢ່າງ​ຊັດ​ເຈນ​ຂອງ Hessian ໄດ້​. ເນື່ອງຈາກທ່ານພຽງແຕ່ຕ້ອງການກໍານົດຫນ້າທີ່ສໍາລັບຜະລິດຕະພັນຂອງ Hessian ແລະ vector arbitrary, ສູດການຄິດໄລ່ນີ້ແມ່ນດີໂດຍສະເພາະສໍາລັບການເຮັດວຽກກັບ matrices sparse (ແຖບເສັ້ນຂວາງ). ນີ້ສະຫນອງຄ່າໃຊ້ຈ່າຍຫນ່ວຍຄວາມຈໍາຕ່ໍາແລະການປະຫຍັດເວລາທີ່ສໍາຄັນ.

ສໍາລັບບັນຫາຂະຫນາດກາງ, ຄ່າໃຊ້ຈ່າຍໃນການເກັບຮັກສາແລະປັດໄຈ Hessian ແມ່ນບໍ່ສໍາຄັນ. ນີ້ຫມາຍຄວາມວ່າມັນເປັນໄປໄດ້ທີ່ຈະໄດ້ຮັບການແກ້ໄຂໃນການແກ້ໄຂຫນ້ອຍລົງ, ແກ້ໄຂບັນຫາຍ່ອຍຂອງພາກພື້ນທີ່ເຊື່ອຖືໄດ້ເກືອບແນ່ນອນ. ເພື່ອເຮັດສິ່ງນີ້, ບາງສົມຜົນທີ່ບໍ່ແມ່ນເສັ້ນຖືກແກ້ໄຂຊໍ້າຄືນສໍາລັບແຕ່ລະບັນຫາຍ່ອຍສີ່ຫລ່ຽມ. ການແກ້ໄຂດັ່ງກ່າວປົກກະຕິແລ້ວຕ້ອງການ 3 ຫຼື 4 ການ decompositions Cholesky ຂອງ Hessian matrix. ດັ່ງນັ້ນ, ວິທີການ converges ໃນ iterations ຫນ້ອຍລົງແລະຮຽກຮ້ອງໃຫ້ມີການຄິດໄລ່ຫນ້າທີ່ຈຸດປະສົງຫນ້ອຍກ່ວາວິທີການພາກພື້ນຄວາມຫມັ້ນໃຈອື່ນໆປະຕິບັດ. ສູດການຄິດໄລ່ນີ້ພຽງແຕ່ຫມາຍເຖິງການກໍານົດຂອງ Hessian matrix ຄົບຖ້ວນສົມບູນແລະບໍ່ສະຫນັບສະຫນູນຄວາມສາມາດໃນການນໍາໃຊ້ຫນ້າທີ່ຜະລິດຕະພັນຂອງ Hessian ແລະ vector arbitrary.

ຕົວຢ່າງທີ່ມີການຫຼຸດຜ່ອນການທໍາງານ 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.])

ພວກເຮົາອາດຈະຢຸດຢູ່ທີ່ນັ້ນ. ໃນບົດຄວາມຕໍ່ໄປຂ້າພະເຈົ້າຈະພະຍາຍາມບອກສິ່ງທີ່ຫນ້າສົນໃຈຫຼາຍທີ່ສຸດກ່ຽວກັບການຫຼຸດຜ່ອນເງື່ອນໄຂ, ຄໍາຮ້ອງສະຫມັກຂອງການຫຼຸດຜ່ອນການແກ້ໄຂບັນຫາໂດຍປະມານ, ການຫຼຸດຜ່ອນການທໍາງານຂອງຕົວແປຫນຶ່ງ, ຕົວຫຍໍ້ທີ່ມັກ, ແລະຊອກຫາຮາກຂອງລະບົບສົມຜົນໂດຍໃຊ້ scipy.optimize. ຊຸດ.

ແຫຼ່ງຂໍ້ມູນ: https://docs.scipy.org/doc/scipy/reference/

ແຫຼ່ງຂໍ້ມູນ: www.habr.com