SciPy, ਸ਼ਰਤਾਂ ਦੇ ਨਾਲ ਅਨੁਕੂਲਤਾ

SciPy (ਉਚਾਰਿਆ ਸਾਈ ਪਾਈ) ਇੱਕ ਨੰਪੀ-ਆਧਾਰਿਤ ਗਣਿਤ ਪੈਕੇਜ ਹੈ ਜਿਸ ਵਿੱਚ C ਅਤੇ Fortran ਲਾਇਬ੍ਰੇਰੀਆਂ ਵੀ ਸ਼ਾਮਲ ਹਨ। SciPy ਤੁਹਾਡੇ ਇੰਟਰਐਕਟਿਵ ਪਾਈਥਨ ਸੈਸ਼ਨ ਨੂੰ MATLAB, IDL, Octave, R, ਜਾਂ SciLab ਵਰਗੇ ਸੰਪੂਰਨ ਡਾਟਾ ਵਿਗਿਆਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਗਣਿਤਿਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀਆਂ ਬੁਨਿਆਦੀ ਤਕਨੀਕਾਂ ਨੂੰ ਦੇਖਾਂਗੇ - scipy.optimize ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਈ ਵੇਰੀਏਬਲਾਂ ਦੇ ਇੱਕ ਸਕੇਲਰ ਫੰਕਸ਼ਨ ਲਈ ਕੰਡੀਸ਼ਨਲ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ। ਬੇਰੋਕ ਅਨੁਕੂਲ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਚਰਚਾ ਕੀਤੀ ਜਾ ਚੁੱਕੀ ਹੈ ਆਖਰੀ ਲੇਖ. ਸਕਾਈਪੀ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਅਤੇ ਨਵੀਨਤਮ ਮਦਦ ਹਮੇਸ਼ਾ help() ਕਮਾਂਡ, Shift+Tab ਜਾਂ ਅੰਦਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼.

ਜਾਣ ਪਛਾਣ

ਫੰਕਸ਼ਨ ਦੁਆਰਾ scipy.optimize ਪੈਕੇਜ ਵਿੱਚ ਸ਼ਰਤੀਆ ਅਤੇ ਬੇਰੋਕ ਅਨੁਕੂਲ ਅਨੁਕੂਲਨ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇੱਕ ਸਾਂਝਾ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ। minimize(). ਹਾਲਾਂਕਿ, ਇਹ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕੋਈ ਵਿਆਪਕ ਤਰੀਕਾ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਢੁਕਵੀਂ ਵਿਧੀ ਦੀ ਚੋਣ, ਹਮੇਸ਼ਾ ਵਾਂਗ, ਖੋਜਕਰਤਾ ਦੇ ਮੋਢਿਆਂ 'ਤੇ ਆਉਂਦੀ ਹੈ.
ਫੰਕਸ਼ਨ ਆਰਗੂਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਚਿਤ ਅਨੁਕੂਲਨ ਐਲਗੋਰਿਦਮ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ minimize(..., method="").
ਕਈ ਵੇਰੀਏਬਲਾਂ ਦੇ ਇੱਕ ਫੰਕਸ਼ਨ ਦੇ ਕੰਡੀਸ਼ਨਲ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕਿਆਂ ਦੇ ਲਾਗੂਕਰਨ ਉਪਲਬਧ ਹਨ:

• trust-constr - ਵਿਸ਼ਵਾਸ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਸਥਾਨਕ ਘੱਟੋ-ਘੱਟ ਦੀ ਖੋਜ ਕਰੋ। ਵਿਕੀ ਲੇਖ, Habré 'ਤੇ ਲੇਖ;
• SLSQP — ਪਾਬੰਦੀਆਂ ਦੇ ਨਾਲ ਕ੍ਰਮਵਾਰ ਚਤੁਰਭੁਜ ਪ੍ਰੋਗਰਾਮਿੰਗ, ਲੈਗਰੇਂਜ ਸਿਸਟਮ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਨਿਊਟੋਨੀਅਨ ਵਿਧੀ। ਵਿਕੀ ਲੇਖ.
• TNC - ਕੱਟਿਆ ਨਿਊਟਨ ਸੀਮਤ, ਸੀਮਤ ਸੰਖਿਆ ਦੁਹਰਾਓ, ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਸੁਤੰਤਰ ਵੇਰੀਏਬਲਾਂ ਦੇ ਨਾਲ ਗੈਰ-ਰੇਖਿਕ ਫੰਕਸ਼ਨਾਂ ਲਈ ਵਧੀਆ। ਵਿਕੀ ਲੇਖ.
• L-BFGS-B — ਬ੍ਰੋਏਡਨ–ਫਲੇਚਰ–ਗੋਲਡਫਾਰਬ–ਸ਼ੈਨੋ ਟੀਮ ਦੀ ਇੱਕ ਵਿਧੀ, ਹੈਸੀਅਨ ਮੈਟ੍ਰਿਕਸ ਤੋਂ ਵੈਕਟਰਾਂ ਦੇ ਅੰਸ਼ਕ ਲੋਡਿੰਗ ਕਾਰਨ ਘੱਟ ਮੈਮੋਰੀ ਖਪਤ ਨਾਲ ਲਾਗੂ ਕੀਤੀ ਗਈ। ਵਿਕੀ ਲੇਖ, Habré 'ਤੇ ਲੇਖ.
• COBYLA — ਰੇਖਿਕ ਅਨੁਮਾਨ ਦੁਆਰਾ MARE ਸੀਮਤ ਅਨੁਕੂਲਨ, ਲੀਨੀਅਰ ਅਨੁਮਾਨ ਦੇ ਨਾਲ ਸੀਮਤ ਅਨੁਕੂਲਨ (ਗ੍ਰੇਡੀਐਂਟ ਗਣਨਾ ਤੋਂ ਬਿਨਾਂ)। ਵਿਕੀ ਲੇਖ.

ਚੁਣੀ ਗਈ ਵਿਧੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਸ਼ਰਤਾਂ ਅਤੇ ਪਾਬੰਦੀਆਂ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ:

• ਕਲਾਸ ਆਬਜੈਕਟ Bounds ਤਰੀਕਿਆਂ ਲਈ L-BFGS-B, TNC, SLSQP, trust-constr;
• ਸੂਚੀ (min, max) ਉਸੇ ਢੰਗਾਂ ਲਈ L-BFGS-B, TNC, SLSQP, ਟਰੱਸਟ-ਕੰਟਰ;
• ਇੱਕ ਵਸਤੂ ਜਾਂ ਵਸਤੂਆਂ ਦੀ ਸੂਚੀ LinearConstraint, NonlinearConstraint COBYLA, 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"

ਵਿਧੀ ਨੂੰ ਲਾਗੂ ਕਰਨਾ trust-constr ਦੇ ਅਧਾਰ ਤੇ EQSQP ਸਮਾਨਤਾ ਅਤੇ ਚਾਲੂ ਦੇ ਰੂਪ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਲਈ ਟ੍ਰਿੱਪ ਅਸਮਾਨਤਾਵਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਰੁਕਾਵਟਾਂ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਲਈ। ਦੋਨੋਂ ਵਿਧੀਆਂ ਆਤਮਵਿਸ਼ਵਾਸ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਸਥਾਨਕ ਘੱਟੋ-ਘੱਟ ਲੱਭਣ ਲਈ ਐਲਗੋਰਿਦਮ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਵੱਡੇ ਪੈਮਾਨੇ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਲਈ ਚੰਗੀ ਤਰ੍ਹਾਂ ਅਨੁਕੂਲ ਹੁੰਦੀਆਂ ਹਨ।

ਆਮ ਰੂਪ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਲੱਭਣ ਦੀ ਸਮੱਸਿਆ ਦਾ ਗਣਿਤਿਕ ਸੂਤਰ:

ਸਖ਼ਤ ਸਮਾਨਤਾ ਸੀਮਾਵਾਂ ਲਈ, ਹੇਠਲੀ ਸੀਮਾ ਉਪਰਲੀ ਸੀਮਾ ਦੇ ਬਰਾਬਰ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ .
ਇੱਕ ਤਰਫਾ ਰੁਕਾਵਟ ਲਈ, ਉਪਰਲੀ ਜਾਂ ਹੇਠਲੀ ਸੀਮਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਹੈ np.inf ਸੰਬੰਧਿਤ ਚਿੰਨ੍ਹ ਦੇ ਨਾਲ.
ਦੋ ਵੇਰੀਏਬਲਾਂ ਦੇ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਰੋਸਨਬਰੌਕ ਫੰਕਸ਼ਨ ਦਾ ਘੱਟੋ-ਘੱਟ ਪਤਾ ਲਗਾਉਣਾ ਜ਼ਰੂਰੀ ਹੈ:

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਸਦੀ ਪਰਿਭਾਸ਼ਾ ਦੇ ਡੋਮੇਨ 'ਤੇ ਨਿਮਨਲਿਖਤ ਪਾਬੰਦੀਆਂ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ:

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਬਿੰਦੂ 'ਤੇ ਇੱਕ ਵਿਲੱਖਣ ਹੱਲ ਹੈ , ਜਿਸ ਲਈ ਸਿਰਫ ਪਹਿਲੀ ਅਤੇ ਚੌਥੀ ਪਾਬੰਦੀਆਂ ਵੈਧ ਹਨ।
ਆਉ ਅਸੀਂ ਹੇਠਾਂ ਤੋਂ ਉੱਪਰ ਤੱਕ ਪਾਬੰਦੀਆਂ ਵਿੱਚੋਂ ਲੰਘੀਏ ਅਤੇ ਵੇਖੀਏ ਕਿ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਸਕਿਪੀ ਵਿੱਚ ਕਿਵੇਂ ਲਿਖ ਸਕਦੇ ਹਾਂ।
ਪ੍ਰਤਿਬੰਧ и ਆਉ ਇਸਨੂੰ Bounds ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ।

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]

ਜੇ ਜਰੂਰੀ ਹੋਵੇ, ਹੇਸੀਅਨ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ LinearOperator ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ

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 tr ਤੋਂ.

ਸਾਡੀ ਦੋਸਤਾਨਾ ਕੰਮ ਕਰਨ ਵਾਲੀ ਟੀਮ ਵਿੱਚ ਚਾਰ ਜੂਨੀਅਰ, ਦੋ ਮਿਡਲ ਅਤੇ ਇੱਕ ਸੀਨੀਅਰ ਸ਼ਾਮਲ ਹਨ। ਉਹਨਾਂ ਦਾ ਮਹੀਨਾਵਾਰ ਕੰਮ ਕਰਨ ਦਾ ਸਮਾਂ ਫੰਡ:

• ਜੂਨ: 4 * 150 = 600 чел * час,
• ਮੱਧ: 2 * 150 = 300 чел * час,
• ਸੀਨੀਅਰ: 150 чел * час.

ਪਹਿਲੇ ਉਪਲਬਧ ਜੂਨੀਅਰ ਨੂੰ ਇੱਕ ਕਿਸਮ (x0, x1, x2), ਮੱਧ - (10, 20, 30), ਸੀਨੀਅਰ - (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. Akulich ਦੀ ਕਿਤਾਬ "ਉਦਾਹਰਨਾਂ ਅਤੇ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਗਣਿਤਕ ਪ੍ਰੋਗਰਾਮਿੰਗ" ਵਿੱਚ। ਵਧੇਰੇ ਹਾਰਡਕੋਰ ਐਪਲੀਕੇਸ਼ਨ scipy.optimize ਚਿੱਤਰਾਂ ਦੇ ਸਮੂਹ ਤੋਂ ਇੱਕ 3D ਢਾਂਚਾ ਬਣਾਉਣ ਲਈ (Habré 'ਤੇ ਲੇਖ) ਵਿੱਚ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ scipy-ਕੁੱਕਬੁੱਕ.

ਜਾਣਕਾਰੀ ਦਾ ਮੁੱਖ ਸਰੋਤ ਹੈ docs.scipy.orgਜਿਹੜੇ ਇਸ ਅਤੇ ਹੋਰ ਭਾਗਾਂ ਦੇ ਅਨੁਵਾਦ ਵਿੱਚ ਯੋਗਦਾਨ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹਨ scipy ਸਵਾਗਤ ਹੈ GitHub.

Спасибо mephistophees ਪ੍ਰਕਾਸ਼ਨ ਦੀ ਤਿਆਰੀ ਵਿੱਚ ਭਾਗ ਲੈਣ ਲਈ।

ਸਰੋਤ: www.habr.com