Python 3.x Scipy optimize.MINIME与多参数 数据加载 参数 我们需要的功能

结果是

当前有限责任公司：-7613.70146 当前有限责任公司：-7613.70146

LLC（对数似然值）未最大化。这不是我希望使用优化器得到的结果

有什么解决办法吗

---

在R中，optim（）函数的工作原理与scipy.optimize.minimize（）类似，后者的工作原理非常好。我还有一个类似于Python代码的R代码。

如果能在开头添加一些细节，我将不胜感激。您有理由期望初始参数接近正确的解决方案吗？您可能希望更改初始猜测x0，例如使用gridsearch而不是文本文件中的初始参数；scipy不需要。寻找全球解决方案。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import linalg, optimize
%matplotlib inline

data = pd.read_csv("D:/Stat/TimeSeries/KRW_month_0617_1.csv",index_col="Date") / 100
para = open("D:/Stat/TimeSeries/KRW_month_0617_1.txt").readlines()[0:2]

data.index = pd.to_datetime(data.index)

cond = []
params = []
time = []

for i in para:
    j = i.split()
    for k in j:
        cond.append(k)
cond = cond[1:]

for i in range(len(cond)):
    cond[i] = round(float(cond[i]),4)

params = cond[0:23]
time = cond[23:]
maturity = np.array(time[1:])
timegap = 1/cond[23]

def Paramcheck(Params, checkStationary = 1):
    result = 0

    Kappa = np.array([[params[20],0,0], [0,params[21],0], [0,0,params[22]]])
    Sigma = np.array([[params[1],0,0], [params[2],params[3],0], [params[4],params[5],params[6]]])
    State = np.array([params[7], params[8], params[9]])
    Lambda = params[0]
    SigmaEps = np.identity(10)

    for i in range(10):
        SigmaEps[i][i] = params[i+10]

    for i in range(len(Sigma)):
        if Sigma[i][i] < 0:
            result = 1

    for j in SigmaEps:
        if np.any(SigmaEps) < 0:
            result = 1
    if Lambda < 0.05 or Lambda > 2:
        result = 1

    elif State[0] < 0:
        result = 1

    elif Kappa[0][0] < 0:
        result = 1

    if result == 0 and checkStationary > 0:
        if max(np.linalg.eigvals(-Kappa).real) > 0:
            result = 2

    return result

def CheckDet(x):
    if x == np.inf or x == np.nan:
        result = 1

    elif x < 0:
        result = 2

    elif abs(x) < 10**-250:
        result = 3

    else:
        result = 0

    return result

def NS_factor(lambda_val, maturity):
     col1 = np.ones(len(maturity))
     col2 = (1 - np.exp(-lambda_val*maturity))/(lambda_val*maturity)
     col3 = col2 - np.exp(-lambda_val*maturity)

     factor = np.array([col1,col2,col3]).transpose()

     return factor

def DNS_Kalman_filter(Params, *args):
    N = Paramcheck(Params)

    if N == 0:
        Kappa = np.array([[params[20],0,0], [0,params[21],0], [0,0,params[22]]])
        Sigma = np.array([[params[1],0,0], [params[2],params[3],0], 
                [params[4],params[5],params[6]]])
        State = np.array([params[7], params[8], params[9]])
        Lambda = params[0]
        SigmaEps = np.identity(10)

        for i in range(10):
            SigmaEps[i][i] = params[i+10]

        Obs_Yield = args[0]
        Obs_Date = args[1] 
        Timegap = args[2] 
        Obs_Mty = args[3] 
        Finalstate = args[4]

        Mty_length = len(Obs_Mty)

        B = NS_factor(lambda_val = Lambda,maturity = Obs_Mty)

        H_large = SigmaEps **2
        N_obs = len(Obs_Date)

        LLH_vec = np.zeros(N_obs)

        phi1 = linalg.expm(-Kappa*Timegap)
        phi0 = (np.identity(3)-phi1) @ State

        Eigenvalues = np.linalg.eig(Kappa)[0]
        Eigen_vec = np.linalg.eig(Kappa)[1]
        Eigen_vec_inv = np.linalg.inv(Eigen_vec)

        S = Eigen_vec_inv @ Sigma @ Sigma.transpose() @ Eigen_vec_inv.transpose()

        Atilde = np.dot(Sigma[0], Sigma[0])
        Btilde = np.dot(Sigma[1], Sigma[1])
        Ctilde = np.dot(Sigma[2], Sigma[2])
        Dtilde = np.dot(Sigma[0], Sigma[1])
        Etilde = np.dot(Sigma[0], Sigma[2])
        Ftilde = np.dot(Sigma[1], Sigma[2])

        res1= Atilde* Obs_Mty* Obs_Mty/6 
        res2= Btilde*(1/(2*Lambda**2) - (1-np.exp(-Lambda*Obs_Mty))/(Lambda**3*Obs_Mty) + (1- 
              np.exp(-2*Lambda*Obs_Mty))/(4*Lambda**3*Obs_Mty)) 
        res3= Ctilde*(1/(2*Lambda**2) + np.exp(-Lambda*Obs_Mty)/(Lambda**2)- 
              Obs_Mty*np.exp(-2*Lambda*Obs_Mty)/(4*Lambda) - 
              3*np.exp(-2*Lambda*Obs_Mty)/(4*Lambda**2) - 2*(1-np.exp(- 
              Lambda*Obs_Mty))/(Lambda**3*Obs_Mty) + 5*(1- 
              np.exp(-2*Lambda*Obs_Mty))/(8*Lambda**3*Obs_Mty)) 
        res4= Dtilde*(Obs_Mty/(2*Lambda) + np.exp(-Lambda*Obs_Mty)/(Lambda**2) - (1-np.exp(- 
              Lambda*Obs_Mty))/(Lambda**3*Obs_Mty)) 
        res5= Etilde*(3*np.exp(-Lambda*Obs_Mty)/(Lambda**2) + Obs_Mty/(2*Lambda)+Obs_Mty*np.exp(- 
              Lambda*Obs_Mty)/(Lambda) - 3*(1-np.exp(-Lambda*Obs_Mty))/(Lambda**3*Obs_Mty)) 
        res6= Ftilde*(1/(Lambda**2) + np.exp(-Lambda*Obs_Mty)/(Lambda**2) - 
              np.exp(-2*Lambda*Obs_Mty)/(2*Lambda**2) - 3*(1-np.exp(- 
              Lambda*Obs_Mty))/(Lambda**3*Obs_Mty) + 3*(1- 
              np.exp(-2*Lambda*Obs_Mty))/(4*Lambda**3*Obs_Mty)) 
        val = res1 + res2 + res3 + res4 + res5 + res6

        V_mat = np.zeros([3,3])
        V_lim = np.zeros([3,3])

    for i in range(3):
        for j in range(3):
            V_mat[i][j] = S[i][j]*(1-np.exp(-(Eigenvalues[i] + 
                         Eigenvalues[j])*Timegap))/(Eigenvalues[i] + Eigenvalues[j])
            V_lim[i][j] = S[i][j]/(Eigenvalues[i] + Eigenvalues[j])

         Q = (Eigen_vec @ V_mat @ Eigen_vec.transpose()).real
         Sigma_lim = (Eigen_vec @ V_lim @ Eigen_vec.transpose()).real

    for i in range(N_obs):
        y = Obs_Yield[i]
        xhat = phi0 + phi1 @ State
        y_implied = B @ xhat
        v = y - y_implied + val

        Sigmahat = phi1 @ Sigma_lim @ phi1.transpose() + Q
        F = B @ Sigmahat @ B.transpose() + H_large
        detF = np.linalg.det(F)

        if CheckDet(detF) > 0:
            N = 3
            break

        Finv = np.linalg.inv(F)
        State = xhat + Sigmahat @ B.transpose() @ Finv @ v
        Sigma_lim = Sigmahat - Sigmahat @ B.transpose() @ Finv @ B @ Sigmahat
        LLH_vec[i] = np.log(detF) + v.transpose() @ Finv @ v


    if N == 0:
        if Finalstate:
            yDate = Obs_Date[-1]
           result = np.array([yDate,State])
        else:
            result = 0.5 * (sum(LLH_vec) + Mty_length*N_obs*np.log(2*np.pi))

    else:
        result = 7000000

    return result

LLC_new = 0

while True:
    LLC_old = LLC_new
    OPT = optimize.minimize(x0=params,fun=DNS_Kalman_filter, args= 
         (data.values,data.index,timegap,maturity,0))
    params = OPT.x
    LLC_new = round(OPT.fun,5)
    print("Current LLC: %0.5f" %LLC_new)

    if LLC_old == LLC_new:
        OPT_para = params
        FinalState = DNS_Kalman_filter(params,data.values,data.index,timegap,maturity,True)
     break