Python scipy.minimize: overflow encountered in double_scalars and invalid value encountered in double_scalars

I built a custom EST (Exponential Smoothing) Model. First I define a function which includes the Parameter definitions which are passed to a second function doing the computation and returning the forecasting Errors. These are then squared and summed up. The Minimizer should then optimize the Parameters so that the sum of the squared Errors is minimized.

The model works if i let the functions run with the starting values. But as soon as i put it threw minimize from scipy it gives me out the following two errors multiple times:

RuntimeWarning: overflow encountered in double_scalars

RuntimeWarning: invalid value encountered in double_scalars

I checked my data (y) and have no zero values. Thus the computation should not return any Zeros. Further I tried boundaries and other Methods for minimizing which also didn't help. (These where the ideas i got from other Questions)

Any help is greatly appreciated :)

'''

from scipy.optimize import minimize

def model(params, y):

    alpha = params[0] 
    beta = params[1]
    gamma = params[2]
    omega = params[3]
    l_init_HM = params[4]
    b_init_HM = params[5]
    s_init7_HM = params[6]
    s_init6_HM = params[7]
    s_init5_HM = params[8]
    s_init4_HM = params[9]
    s_init3_HM = params[10]
    s_init2_HM = params[11]
    s_init_HM = params[12]
    
    results = ETS_M_Ad_M(alpha,beta,gamma,omega,
          l_init_HM,b_init_HM,s_init7_HM,
          s_init6_HM,s_init5_HM,s_init4_HM,
         s_init3_HM,s_init2_HM,s_init_HM,y)
    
    error_list = results['errors_list']
    
    error_list = [number ** 2 for number in error_list]
    
    #returning the sum of squared errors
    #this is the ML estimate, or rather Adjusted Least Squared (ALS)
    #Hyndman p. 69
    error_sum = sum(error_list)
   
    return error_sum

def ETS_M_Ad_M(alpha,beta,gamma,omega,
              l_init_HM,b_init_HM,s_init7_HM, 
              s_init6_HM,s_init5_HM,s_init4_HM,
             s_init3_HM,s_init2_HM,s_init_HM,y):
        
        #computing the number of time points as the length of the forecasting vector
        t = len(y)
        errors_list = list()
        point_forecast = list()
        l_list = list()
        b_list = list()
        s_list = list()
        
        #parameter definition
    
        #Initilaisation
        l_past = l_init_HM
        b_past = b_init_HM
        s_past = s_init7_HM
        s_past7 = s_init6_HM
        s_past6 = s_init5_HM
        s_past5 = s_init4_HM
        s_past4 = s_init3_HM
        s_past3 = s_init2_HM
        s_past2 = s_init_HM
    
        mu = (l_past + omega * b_past) * s_past
        #compute forecasting error at timepoint t
        e = (y[0] - mu) / y[0]
        #compute absolute errors for ML estimation
        e_absolute = y[0] - mu
    
        #save estimation error for Likelihood computation
        errors_list.append(e_absolute)
        point_forecast.append(mu)
        l_list.append(l_past)
        b_list.append(b_past)
        s_list.append(s_past)
    
        #Updating
        #updating all state estimates for time point t
        l = (l_past + omega * b_past) * (1 + alpha * e)
        b = omega * b_past + beta * (l_past + omega * b_past) * e
        s = s_past * (1 + gamma * e)
    
    
        #computation loop:
        for i in range(1,t): #start at 1 as the first index '0' is used in the initialization
            #Prediciton
            #denote updated states from t-1 as past states for time point t
            l_past = l
            b_past = b
            s_past7 = s_past6
            s_past6 = s_past5
            s_past5 = s_past4
            s_past4 = s_past3
            s_past3 = s_past2
            s_past2 =  s
    
            #Observation
            #compute one step ahead  forecast for timepoint t
            mu = (l_past + omega * b_past) * s_past
            #compute forecasting error at timepoint t
            e = (y[i] - mu) / y[i]
            #compute absolute errors for ML estimation
            e_absolute = y[i] - mu
    
            #save estimation error for Likelihood computation
            #saving squared errors
            errors_list.append(e_absolute) 
            point_forecast.append(mu)
            l_list.append(l_past)
            b_list.append(b_past)
            s_list.append(s_past)
    
            #Updating
            #updating all state estimates for time point t
            l = (l_past + omega * b_past) * (1 + alpha * e)
            b = omega * b_past + beta * (l_past + omega * b_past) * e
            s = s_past * (1 + gamma * e)
    
        return  {'errors_list' : errors_list, 'point forecast' : point_forecast,
                 'l_list' : l_list, 'b_list' : b_list, 's_list' : s_list}

#Defining Starting Parameters
Starting_Parameters = [0.1, #alpha
                       0.01, #beta
                       0.01, #Gamma
                       0.99, #omega 
                       5556.151751807499, #l_init
                       92.90080519198762, #b_init
                       1.256185460504065, #s_init7
                       1.0317387565497154, #s_init6
                       0.8373829313978448, #s_init5
                       0.8220047728017161, #s_init4
                       0.8461049900287951, #s_init3
                       0.9412435736696254, #s_init2
                       1.2653395150482378] #s_init
# -> starting values from Hyndman 2008 p.24


    minimize(model, Starting_Parameters, args=(y), method='BFGS')

'''

The Time Series contained in y uploaded in my GitHub under the following link: https://github.com/MatthiasHerp/Public/blob/master/revenue_CA_1_FOODS_day.csv

Simply Import it and store it as y and the Code should run :)

Upvotes: 3