SciPy (ಸಾಯಿ ಪೈ ಎಂದು ಉಚ್ಚರಿಸಲಾಗುತ್ತದೆ) ಒಂದು ನಂಬಿ-ಆಧಾರಿತ ಗಣಿತದ ಪ್ಯಾಕೇಜ್ ಆಗಿದ್ದು ಅದು C ಮತ್ತು ಫೋರ್ಟ್ರಾನ್ ಲೈಬ್ರರಿಗಳನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ. SciPy ನಿಮ್ಮ ಸಂವಾದಾತ್ಮಕ ಪೈಥಾನ್ ಸೆಶನ್ ಅನ್ನು MATLAB, IDL, Octave, R, ಅಥವಾ SciLab ನಂತಹ ಸಂಪೂರ್ಣ ಡೇಟಾ ವಿಜ್ಞಾನ ಪರಿಸರವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಈ ಲೇಖನದಲ್ಲಿ, ಗಣಿತದ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಮೂಲ ತಂತ್ರಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ - scipy.optimize ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹಲವಾರು ವೇರಿಯಬಲ್‌ಗಳ ಸ್ಕೇಲಾರ್ ಕಾರ್ಯಕ್ಕಾಗಿ ಷರತ್ತುಬದ್ಧ ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು. ಅನಿಯಂತ್ರಿತ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಈಗಾಗಲೇ ಚರ್ಚಿಸಲಾಗಿದೆ . scipy ಕಾರ್ಯಗಳಲ್ಲಿ ಹೆಚ್ಚು ವಿವರವಾದ ಮತ್ತು ನವೀಕೃತ ಸಹಾಯವನ್ನು ಯಾವಾಗಲೂ help() ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪಡೆಯಬಹುದು, Shift+Tab ಅಥವಾ in .
ಪರಿಚಯ
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,NonlinearConstraintCOBYLA, 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 ಆಧಾರಿತ ಸಮಾನತೆಯ ಸ್ವರೂಪದ ನಿರ್ಬಂಧಗಳೊಂದಿಗಿನ ಸಮಸ್ಯೆಗಳಿಗೆ ಮತ್ತು ಆನ್ ಅಸಮಾನತೆಗಳ ರೂಪದಲ್ಲಿ ನಿರ್ಬಂಧಗಳೊಂದಿಗಿನ ಸಮಸ್ಯೆಗಳಿಗೆ. ವಿಶ್ವಾಸಾರ್ಹ ಪ್ರದೇಶದಲ್ಲಿ ಸ್ಥಳೀಯ ಕನಿಷ್ಠವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಎರಡೂ ವಿಧಾನಗಳನ್ನು ಅಲ್ಗಾರಿದಮ್‌ಗಳಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಸಮಸ್ಯೆಗಳಿಗೆ ಸೂಕ್ತವಾಗಿರುತ್ತದೆ.
ಸಾಮಾನ್ಯ ರೂಪದಲ್ಲಿ ಕನಿಷ್ಠವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಸಮಸ್ಯೆಯ ಗಣಿತದ ಸೂತ್ರೀಕರಣ:
ಕಟ್ಟುನಿಟ್ಟಾದ ಸಮಾನತೆಯ ನಿರ್ಬಂಧಗಳಿಗಾಗಿ, ಕೆಳಗಿನ ಬೌಂಡ್ ಅನ್ನು ಮೇಲಿನ ಗಡಿಗೆ ಸಮನಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ .
ಏಕಮುಖ ನಿರ್ಬಂಧಕ್ಕಾಗಿ, ಮೇಲಿನ ಅಥವಾ ಕೆಳಗಿನ ಮಿತಿಯನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ 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)ಹೆಸ್ಸಿಯನ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಾಗ ಸಾಕಷ್ಟು ಪ್ರಯತ್ನದ ಅಗತ್ಯವಿದೆ, ನೀವು ವರ್ಗವನ್ನು ಬಳಸಬಹುದು . ಕೆಳಗಿನ ತಂತ್ರಗಳು ಲಭ್ಯವಿದೆ: 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')ನಿರ್ಬಂಧಗಳಿಗೆ ಜಾಕೋಬಿಯನ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಸೀಮಿತ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಹಾಕಬಹುದು. ಆದಾಗ್ಯೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಹೆಸ್ಸಿಯನ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಸೀಮಿತ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾಗುವುದಿಲ್ಲ. ಹೆಸ್ಸಿಯನ್ ಅನ್ನು ಒಂದು ಕಾರ್ಯವೆಂದು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು ಅಥವಾ ಹೆಸ್ಸಿಯನ್ ಅಪ್‌ಡೇಟ್ ಸ್ಟ್ರಾಟಜಿ ವರ್ಗವನ್ನು ಬಳಸಬೇಕು.
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 TR ನಿಂದ.
- x1 - ಕಾರ್ಪೊರೇಟ್ ವೆಬ್‌ಸೈಟ್‌ಗಳು, 20 TR ನಿಂದ.
- 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 ಸಂಪೂರ್ಣವಾಗಿ ಶೈಕ್ಷಣಿಕ ಉದ್ದೇಶಗಳಿಗಾಗಿ, ಅದಕ್ಕಾಗಿಯೇ ನೀಡಲಾದ ಉದಾಹರಣೆಯು ಅಂತಹ ಕಾಮಿಕ್ ಸ್ವಭಾವದ್ದಾಗಿದೆ.
ಬಹಳಷ್ಟು ಸಿದ್ಧಾಂತ ಮತ್ತು ವರ್ಚುವಲ್ ಉದಾಹರಣೆಗಳನ್ನು ಕಾಣಬಹುದು, ಉದಾಹರಣೆಗೆ, I.L. ಅಕುಲಿಚ್ ಅವರ ಪುಸ್ತಕದಲ್ಲಿ "ಉದಾಹರಣೆಗಳು ಮತ್ತು ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಗಣಿತದ ಪ್ರೋಗ್ರಾಮಿಂಗ್." ಹೆಚ್ಚು ಹಾರ್ಡ್ಕೋರ್ ಅಪ್ಲಿಕೇಶನ್ scipy.optimize ಚಿತ್ರಗಳ ಗುಂಪಿನಿಂದ 3D ರಚನೆಯನ್ನು ನಿರ್ಮಿಸಲು () ನಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದು .
ಮಾಹಿತಿಯ ಮುಖ್ಯ ಮೂಲವಾಗಿದೆ ಈ ಮತ್ತು ಇತರ ವಿಭಾಗಗಳ ಅನುವಾದಕ್ಕೆ ಕೊಡುಗೆ ನೀಡಲು ಬಯಸುವವರು scipy ಸುಸ್ವಾಗತ .
ಸಪಾಕ್ಸಿ ಪ್ರಕಟಣೆಯ ತಯಾರಿಕೆಯಲ್ಲಿ ಭಾಗವಹಿಸಲು.
ಮೂಲ: www.habr.com