SciPy၊ အခြေအနေများနှင့်အတူ ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်း။

SciPy (အသံထွက် Sai pie) သည် C နှင့် Fortran စာကြည့်တိုက်များပါ၀င်သည့် ဂဏန်းအခြေခံသင်္ချာအထုပ်တစ်ခုဖြစ်သည်။ SciPy သည် သင်၏အပြန်အလှန်အကျိုးသက်ရောက်သော Python စက်ရှင်ကို MATLAB၊ IDL၊ Octave၊ R သို့မဟုတ် SciLab ကဲ့သို့ ပြီးပြည့်စုံသော အချက်အလက်သိပ္ပံပတ်ဝန်းကျင်အဖြစ်သို့ ပြောင်းလဲပေးသည်။

ဤဆောင်းပါးတွင်၊ scipy.optimize ပက်ကေ့ချ်ကို အသုံးပြု၍ ကိန်းရှင်များစွာ၏ scalar လုပ်ဆောင်ချက်အတွက် အခြေအနေအရ ပိုမိုကောင်းမွန်အောင်လုပ်ဆောင်ခြင်းဆိုင်ရာ ပြဿနာများကို ဖြေရှင်းရာတွင် သင်္ချာပရိုဂရမ်ရေးဆွဲခြင်း၏ အခြေခံနည်းပညာများကို ကြည့်ရှုပါမည်။ အတားအဆီးမရှိ ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်းဆိုင်ရာ အယ်လဂိုရီသမ်များကို ဆွေးနွေးပြီးဖြစ်သည်။ ပြီးခဲ့သည့်ဆောင်းပါး. scipy လုပ်ဆောင်ချက်များတွင် ပိုမိုအသေးစိတ်ပြီး နောက်ဆုံးပေါ်အကူအညီကို help() command၊ Shift+Tab သို့မဟုတ် ထဲတွင် အမြဲသုံးနိုင်သည်။ တရားဝင်စာရွက်စာတမ်း.

နိဒါန်း

scipy.optimize ပက်ကေ့ခ်ျရှိ အခြေအနေအရနှင့် အတားအဆီးမရှိသော ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်းပြဿနာများကို ဖြေရှင်းရန်အတွက် ဘုံအင်တာဖေ့စ်ကို လုပ်ဆောင်ချက်က ပံ့ပိုးပေးထားသည်။ minimize(). သို့သော်လည်း ပြဿနာအားလုံးကို ဖြေရှင်းရန် universal method မရှိကြောင်း သိရှိထားသောကြောင့် လုံလောက်သောနည်းလမ်းကို ရွေးချယ်ခြင်းသည် အမြဲတမ်း သုတေသီ၏ ပခုံးပေါ်တွင် ကျရောက်နေပါသည်။
function argument ကိုအသုံးပြု၍ သင့်လျော်သော optimization algorithm ကိုသတ်မှတ်ထားသည်။ minimize(..., method="").
ကိန်းရှင်များစွာ၏ လုပ်ဆောင်ချက်တစ်ခု၏ အခြေအနေမှန်ကို ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ရန်အတွက်၊ အောက်ပါနည်းလမ်းများကို အကောင်အထည်ဖော်နိုင်သည်-

• trust-constr — ယုံကြည်စိတ်ချရသောဒေသရှိ ဒေသန္တရအနိမ့်ဆုံးကို ရှာဖွေပါ။ ဝီကီဆောင်းပါး, Habre ၏ဆောင်းပါး;
• SLSQP - ကန့်သတ်ချက်များနှင့်အတူ ဆက်တိုက် လေးထောင့်ပုံစံ ပရိုဂရမ်ရေးဆွဲခြင်း၊ Lagrange စနစ်အား ဖြေရှင်းရန်အတွက် Newtonian နည်းလမ်း။ ဝီကီဆောင်းပါး.
• TNC - ဖြတ်တောက်ထားသော နယူတန်အား ကန့်သတ်ထားသော၊ ကန့်သတ်ထားသော ထပ်ခါထပ်ခါပြုလုပ်မှုများ၊ သီးခြားကိန်းရှင်များစွာရှိသည့် လိုင်းမဟုတ်သောလုပ်ဆောင်ချက်များအတွက် ကောင်းမွန်သည်။ ဝီကီဆောင်းပါး.
• L-BFGS-B — Broyden–Fletcher–Goldfarb–Shanno အဖွဲ့မှ နည်းလမ်းတစ်ခု၊ Hessian matrix မှ vector များကို တစ်စိတ်တစ်ပိုင်းတင်ပေးခြင်းကြောင့် မှတ်ဉာဏ်သုံးစွဲမှု လျှော့ချခြင်းဖြင့် အကောင်အထည်ဖော်ခဲ့သည်။ ဝီကီဆောင်းပါး, Habre ၏ဆောင်းပါး.
• COBYLA — Linear Approximation အားဖြင့် MARE ကန့်သတ်ထားသော အကောင်းဆုံးဖြစ်အောင်၊ linear approximation (gradient တွက်ချက်ခြင်းမရှိဘဲ) ဖြင့် ကန့်သတ်ထားသော optimization။ ဝီကီဆောင်းပါး.

ရွေးချယ်ထားသောနည်းလမ်းပေါ် မူတည်၍ ပြဿနာဖြေရှင်းခြင်းအတွက် အခြေအနေများနှင့် ကန့်သတ်ချက်များကို ကွဲပြားစွာ သတ်မှတ်ထားသည်-

• class object ပါ။ Bounds နည်းလမ်းများအတွက် L-BFGS-B, TNC, SLSQP, trust-constr;
• စာရင်း (min, max) တူညီသောနည်းလမ်းများအတွက် L-BFGS-B, TNC, SLSQP, trust-constr;
• အရာဝတ္ထုတစ်ခု သို့မဟုတ် အရာဝတ္ထုများစာရင်း LinearConstraint, NonlinearConstraint COBYLA၊ SLSQP၊ ယုံကြည်မှု-constr နည်းလမ်းများအတွက်၊
• အဘိဓာန် သို့မဟုတ် အဘိဓာန်စာရင်း {'type':str, 'fun':callable, 'jac':callable,opt, 'args':sequence,opt} COBYLA၊ SLSQP နည်းလမ်းများအတွက်။

ဆောင်းပါးကောက်ကြောင်း-
1) အရာဝတ္ထုများအဖြစ် သတ်မှတ်ထားသော ကန့်သတ်ချက်များဖြင့် ယုံကြည်စိတ်ချရသောဒေသ (method=”trust-constr”) တွင် အခြေအနေအလိုက် ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ထားသော အယ်လဂိုရီသမ်ကို အသုံးပြုရန် စဉ်းစားပါ။ Bounds, LinearConstraint, NonlinearConstraint ;
2) အဘိဓာန်ပုံစံဖြင့် သတ်မှတ်ထားသော ကန့်သတ်ချက်များဖြင့် အနည်းဆုံး စတုရန်းပုံနည်းလမ်း (နည်းလမ်း = "SLSQP") ကို အသုံးပြု၍ ဆက်တိုက် ပရိုဂရမ်ရေးဆွဲခြင်းကို စဉ်းစားပါ။ {'type', 'fun', 'jac', 'args'};
3) ဝဘ်စတူဒီယို၏နမူနာကို အသုံးပြု၍ ထုတ်လုပ်ထားသောထုတ်ကုန်များ၏ ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်း၏နမူနာကို ပိုင်းခြားစိတ်ဖြာပါ။

အခြေအနေအရ ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ခြင်းနည်းလမ်း = "trust-constr"

နည်းလမ်းကို အကောင်အထည်ဖော်ခြင်း။ trust-constr ပေါ်အခြေခံကာ EQSQP တန်းတူညီမျှမှုပုံစံနှင့် ကန့်သတ်ချက်များရှိသော ပြဿနာများအတွက် ခရီးစဉ် မညီမျှမှုပုံစံဖြင့် အတားအဆီးများနှင့် ပြဿနာများအတွက်။ နည်းလမ်းနှစ်ခုလုံးကို ယုံကြည်စိတ်ချရသောဒေသရှိ ဒေသန္တရအနိမ့်ဆုံးကိုရှာဖွေရန်အတွက် အယ်လဂိုရီသမ်များဖြင့် အကောင်အထည်ဖော်ပြီး အကြီးစားပြဿနာများအတွက် ကောင်းမွန်သင့်လျော်ပါသည်။

ယေဘူယျပုံစံတွင် အနိမ့်ဆုံးရှာဖွေခြင်းပြဿနာ၏ သင်္ချာဖော်မြူလာ

တင်းကျပ်သော တန်းတူညီမျှမှုဆိုင်ရာ ကန့်သတ်ချက်များအတွက်၊ အောက်ဘောင်ကို အထက်ဘောင်နှင့် ညီစေသည်။ .
တစ်လမ်းမောင်းကန့်သတ်ချက်အတွက်၊ အပေါ် သို့မဟုတ် အောက် ကန့်သတ်ချက်ကို သတ်မှတ်သည်။ np.inf သက်ဆိုင်သောလက္ခဏာနှင့်အတူ။
ကိန်းရှင်နှစ်ခု၏ လူသိများသော Rosenbrock လုပ်ဆောင်ချက်၏ အနည်းဆုံးကို ရှာဖွေရန် လိုအပ်ပါစေ-

ဤကိစ္စတွင်၊ ၎င်း၏ အဓိပ္ပါယ်ဖွင့်ဆိုချက်တွင် အောက်ပါကန့်သတ်ချက်များကို သတ်မှတ်ထားသည်-

ကျွန်ုပ်တို့၏အခြေအနေတွင်၊ ထူးထူးခြားခြားဖြေရှင်းချက်တစ်ခုရှိသည်။ ပထမနှင့် စတုတ္ထကန့်သတ်ချက်များသာ အကျုံးဝင်သည်။
အောက်ခြေကနေ အပေါ်ကနေ ကန့်သတ်ချက်တွေကို ဖြတ်ပြီး အဲဒါတွေကို scipy နဲ့ ဘယ်လိုရေးနိုင်မလဲဆိုတာ ကြည့်ကြရအောင်။
ကန့်သတ် и Bounds object ကို အသုံးပြု၍ ၎င်းကို သတ်မှတ်ကြပါစို့။

from scipy.optimize import Bounds
bounds = Bounds ([0, -0.5], [1.0, 2.0])

ကန့်သတ် и အဲဒါကို linear form နဲ့ရေးကြည့်ရအောင်။

ဤကန့်သတ်ချက်များကို LinearConstraint object အဖြစ် သတ်မှတ်ကြပါစို့။

import numpy as np
from scipy.optimize import LinearConstraint
linear_constraint = LinearConstraint ([[1, 2], [2, 1]], [-np.inf, 1], [1, 1])

နောက်ဆုံးတွင် matrix ပုံစံဖြင့် linear မဟုတ်သော ကန့်သတ်ချက်

ဤကန့်သတ်ချက်အတွက် Jacobi matrix နှင့် Hessian matrix ၏ linear ပေါင်းစပ်မှုကို မတရားသော vector တစ်ခုဖြင့် သတ်မှတ်သည် :

ယခု ကျွန်ုပ်တို့သည် လိုင်းမဟုတ်သော ကန့်သတ်ချက်ကို အရာဝတ္ထုတစ်ခုအဖြစ် သတ်မှတ်နိုင်ပါပြီ။ 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)

Hessian matrix ကို တွက်ချက်သောအခါ ကြိုးစားအားထုတ်မှုများစွာလိုအပ်သည်၊ သင်သည်အတန်းကိုသုံးနိုင်သည်။ HessianUpdateStrategy. အောက်ပါဗျူဟာများကို ရရှိနိုင်ပါသည်။ BFGS и SR1.

from scipy.optimize import BFGS

nonlinear_constraint = NonlinearConstraint(cons_f, -np.inf, 1, jac=cons_J, hess=BFGS())

Hessian ကို အကန့်အသတ်ဖြင့် တွက်ချက်နိုင်သည်။

nonlinear_constraint = NonlinearConstraint (cons_f, -np.inf, 1, jac = cons_J, hess = '2-point')

အကန့်အသတ်များအတွက် Jacobian matrix ကို အကန့်အသတ်များ အကန့်အသတ်များကို အသုံးပြု၍ တွက်ချက်နိုင်သည်။ သို့သော်လည်း ဤကိစ္စတွင်၊ Hessian matrix ကို အကန့်အသတ်ဖြင့် တွက်ချက်၍မရပါ။ Hessian ကို function တစ်ခုအဖြစ် သို့မဟုတ် 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]

လိုအပ်ပါက၊ Hessian တွက်ချက်ခြင်းအတွက် function ကို LinearOperator class ကိုအသုံးပြု၍ သတ်မှတ်နိုင်သည်။

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)

သို့မဟုတ် Hessian ၏ ထုတ်ကုန်နှင့် ကန့်သတ်ဘောင်မှတဆင့် မတရားသော vector တစ်ခု 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)

တနည်းအားဖြင့် ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ထားသော လုပ်ဆောင်ချက်၏ ပထမနှင့် ဒုတိယဆင့်ပွားများကို အနီးစပ်ဆုံး ခန့်မှန်းနိုင်ပါသည်။ ဥပမာအားဖြင့်၊ Hessian သည် လုပ်ဆောင်ချက်ကို အသုံးပြု၍ ခန့်မှန်းနိုင်သည်။ 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 ]

အကောင်းဆုံးဖြစ်အောင် ဥပမာ

ပဉ္စမနည်းပညာဖွဲ့စည်းပုံသို့ ကူးပြောင်းခြင်းနှင့်ပတ်သက်၍၊ ကျွန်ုပ်တို့အား သေးငယ်သော်လည်း တည်ငြိမ်သော ၀င်ငွေရရှိစေသည့် ဝဘ်စတူဒီယိုတစ်ခု၏ နမူနာကို အသုံးပြု၍ ထုတ်လုပ်မှု ပိုမိုကောင်းမွန်အောင် လုပ်ဆောင်ခြင်းကို ကြည့်ကြပါစို့။ ထုတ်ကုန်သုံးမျိုးထုတ်လုပ်သည့် Galley ၏ဒါရိုက်တာအဖြစ် ကျွန်ုပ်တို့ကို စိတ်ကူးကြည့်ကြပါစို့။

• x0 - 10 tr မှဆင်းသက်သောစာမျက်နှာများကိုရောင်းချသည်။
• x1 - 20 tr မှ ကော်ပိုရိတ်ဝက်ဘ်ဆိုဒ်များ။
• x2 - 30 tr မှ အွန်လိုင်းစတိုးများ။

ကျွန်ုပ်တို့၏ ဖော်ရွေသော အလုပ်အဖွဲ့တွင် အငယ်တန်းလေးဦး၊ အလယ်တန်း နှစ်ဦးနှင့် အကြီးတန်းတစ်ဦးတို့ ပါဝင်သည်။ ၎င်းတို့၏ လစဉ် အလုပ်ချိန်ရန်ပုံငွေ-

• ဇွန်လများ 4 * 150 = 600 чел * час,
• အလယ်- 2 * 150 = 300 чел * час,
• Senor- 150 чел * час.

ပထမဆုံးရရှိနိုင်သော အငယ်တန်းသည် အမျိုးအစား (x0၊ x1၊ x2)၊ အလယ်တန်း - (10၊ 20၊ 30)၊ အကြီးတန်း - (7၊ 15၊ 20) အမျိုးအစားဆိုက်တစ်ခု၏ ဖွံ့ဖြိုးတိုးတက်မှုနှင့် ဖြန့်ကျက်မှုတွင် (၁၀၊ ၂၀၊ ၃၀) နာရီကို သုံးစွဲခွင့်ပြုပါ။ ) မင်းဘဝရဲ့ အကောင်းဆုံးအချိန်နာရီ။

သာမာန်ဒါရိုက်တာများကဲ့သို့ပင် ကျွန်ုပ်တို့သည် လစဉ်အမြတ်အစွန်းများကို အများဆုံးရယူလိုပါသည်။ အောင်မြင်မှု၏ ပထမခြေလှမ်းမှာ ရည်မှန်းချက်လုပ်ဆောင်ချက်ကို ချရေးရန်ဖြစ်သည်။ 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 чел * час;
• Senor- 8 * 5 + 6 * 10 + 3 * 15 = 145 чел * час.

နိဂုံးချုပ်- ဒါရိုက်တာသည် ၎င်း၏ ထိုက်တန်သော အမြင့်ဆုံးကို လက်ခံရရှိရန်အတွက် ဆင်းသက်သည့်စာမျက်နှာ ၈ ခု၊ အလတ်စားဆိုက် ၆ ခုနှင့် တစ်လလျှင် စတိုးဆိုင် ၃ ခု ဖန်တီးရန် အကောင်းဆုံးဖြစ်သည်။ ဤကိစ္စတွင်၊ အကြီးတန်းသည်စက်ကိုမမျှော်ဘဲထယ်ထိုးရမည်ဖြစ်ပြီး၊ အလယ်တန်းများ၏ဝန်သည်ခန့်မှန်းခြေအားဖြင့် 8/6 ဖြစ်လိမ့်မည်၊ ငယ်ငယ်များထက်ဝက်ထက်နည်းသည်။

ကောက်ချက်

ဆောင်းပါးတွင် ပက်ကေ့ဂျ်ဖြင့်လုပ်ဆောင်ရန် အခြေခံနည်းပညာများကို အကျဉ်းချုပ်ဖော်ပြထားသည်။ scipy.optimizeအခြေအနေအရ နည်းပါးမှုပြဿနာများကို ဖြေရှင်းရန် အသုံးပြုသည်။ ကိုယ်တိုင်ကိုယ်ကျ သုံးပါတယ်။ scipy ပညာရပ်ဆိုင်ရာ ရည်ရွယ်ချက်အတွက် သက်သက်ဖြစ်သောကြောင့် ပေးထားသော ဥပမာသည် ရယ်စရာကောင်းသော သဘောသဘာဝဖြစ်သည်။

ဥပမာအားဖြင့် I.L. Akulich ၏ “ဥပမာများနှင့် ပြဿနာများတွင် သင်္ချာပရိုဂရမ်ရေးဆွဲခြင်း” စာအုပ်တွင် သီအိုရီနှင့် အတုအယောင်ဥပမာများစွာကို တွေ့ရှိနိုင်သည်။ ပိုမိုပြင်းထန်သောလျှောက်လွှာ scipy.optimize ပုံအစုံမှ 3D ဖွဲ့စည်းပုံကို တည်ဆောက်ရန် (Habre ၏ဆောင်းပါး) တွင် ကြည့်ရှုနိုင်ပါသည်။ scipy-ချက်ပြုတ်စာအုပ်.

သတင်းအချက်အလက်၏အဓိကအရင်းအမြစ်မှာ docs.scipy.orgဤဘာသာပြန်နှင့် အခြားကဏ္ဍများကို ပံ့ပိုးကူညီလိုသူများ scipy မှကြိုဆိုပါတယ်။ GitHub.

Спасибо mephistophees ထုတ်ဝေမှု ပြင်ဆင်မှုတွင် ပါဝင်ရန်။

source: www.habr.com