def forecast_holt(lista_datos, num_fut): lista_puntos = np.arange(0, len(lista_datos), 1) df = pd.DataFrame() df['puntos'] = lista_puntos df['valores'] = lista_datos df.set_index('puntos', inplace=True) stepwise_model = ExponentialSmoothing(df, seasonal_periods=len(df), seasonal='add') fit_stepwise_model = stepwise_model.fit() fit_forecast_pred = fit_stepwise_model.fittedvalues future_forecast_pred = fit_stepwise_model.forecast(num_fut) df_result = pd.DataFrame({ 'puntos': future_forecast_pred.index, 'valores': future_forecast_pred.values }) df_result.set_index('puntos', inplace=True) return (df_result)
def estimate_HW(dataframe, name, number_seasons, sizeestimate): array = np.asarray(dataframe[name]) size = len(array) model = ExponentialSmoothing(array, seasonal_periods=number_seasons ,trend='add', seasonal='add') fit = model.fit() forecast = fit.forecast(sizeestimate) for index in range ( len(forecast) ): forecast[index] = round(forecast[index], 4) return forecast
def convolve_single_exponential(time_constant, dt, cystoplasmic_data): alpha = 1 - np.exp((-dt) / time_constant) exp = ExponentialSmoothing(cystoplasmic_data) exp_model = exp.fit(smoothing_level=alpha) result = exp_model.fittedvalues return result
def holt_winter_f(self, df, trend, seasonal): try: holt_w = ExponentialSmoothing(np.array(df['Actual']), trend=trend, seasonal=seasonal, seasonal_periods=4) fit_holt_w = holt_w.fit(use_boxcox=True, disp=0) forecast = fit_holt_w.forecast()[0] Cluster, Warehouse, WF, YF = generate_attrib(df) self.df_forecast.append({'Cluster':Cluster, 'Warehouse':Warehouse, 'Year':YF, "Week": WF, "Forecast":forecast}) return print(f'DEBUG:Forecast:{Cluster}:{Warehouse}:{YF}:{WF}:{forecast}') except: return print("ERROR:FORECAST-HOLT_WINTER")
def test_exponentialSmoothing_01(self): ts_data = self.statsmodels_data_helper.get_data_with_trend_and_seasonality() f_name='exponential_smoothing1.pmml' model_obj = ExponentialSmoothing(ts_data, trend='add', damped=True, seasonal='add', seasonal_periods=2) results_obj = model_obj.fit(optimized=True) ExponentialSmoothingToPMML(results_obj, f_name) self.assertEqual(self.schema.is_valid(f_name),True)
def test_exponentialSmoothing_01(self): ts_data = self.getData1() f_name='exponential_smoothing1.pmml' model_obj = ExponentialSmoothing(ts_data, trend='add', damped=True, seasonal='add', seasonal_periods=2) results_obj = model_obj.fit(optimized=True) ExponentialSmoothingToPMML(results_obj, f_name, model_name="Test2", description="test model") self.assertEqual(os.path.isfile(f_name),True)
def predict(self, array_X, array_Y): predictions = numpy.empty(0) for t in range(0, array_Y.shape[0]): array = numpy.hstack((self.train_Y, array_Y[:t])) model = ExponentialSmoothing( array, seasonal_periods=self.seasonal_periods, trend='add', seasonal='add') fit = model.fit() predictions = numpy.append(predictions, fit.forecast(1)[0]) return predictions
def estimate_HW(dataframe, name, number_seasons, sizeestimate): # ES/HW requires an array to work with, so we convert the column into an array array = np.asarray(dataframe[name]) size = len(array) # Model below _assumes_ additive trend and additive seasonality. # This should work OK for the oil data set in the midterm but for other datasets # you should check. model = ExponentialSmoothing(array, seasonal_periods=number_seasons ,trend='add', seasonal='add') fit = model.fit() forecast = fit.forecast(sizeestimate) for index in range ( len(forecast) ): forecast[index] = round(forecast[index], 4) return forecast
def forecast(self, prediction_length): if len(self.known_history ) < 10: # More than 10 point are needed for DES prediction self.history = np.append( self.known_history, np.tile(self.known_history[-1], (prediction_length, 1))) else: model = ExponentialSmoothing(self.known_history, initialization_method='estimated', trend='add', damped_trend=False, seasonal=None) forecast = model.fit().forecast(prediction_length) self.history = np.append(self.known_history, forecast) # Room for optimization
def forecast(data, train_hours, test_hours, in_place=True): train = data.iloc[:train_hours] # Create the Holt-Winters model model = ExponentialSmoothing(np.asarray(train['total load actual']), seasonal_periods=24, seasonal='mul') model._index = pd.to_datetime(train.index) # Fit the model, and forecast fit = model.fit() pred = fit.forecast(test_hours) fcst = pd.Series(list(fit.fittedvalues) + list(pred)) if in_place: data['holtWinters'] = fcst else: return fcst
class TS_Holt_Winter_Seasonal(object): def __init__(self, folder_debug=None, filename_weights=None): self.name = 'TS_Holt_Winter_Seasonal' self.model = [] self.folder_debug = folder_debug self.seasonal_periods = 6 self.train_X = [] self.train_Y = [] return # ---------------------------------------------------------------------------------------------------------------- def train(self, array_X, array_Y): self.train_X = array_X self.train_Y = array_Y self.model = ExponentialSmoothing( array_Y, seasonal_periods=self.seasonal_periods, trend='add', seasonal='add') self.fit = self.model.fit() res = self.fit.fittedvalues return res # ---------------------------------------------------------------------------------------------------------------------- def predict_n_steps_ahead(self, n_steps): res = self.fit.forecast(n_steps)[0] return res # ---------------------------------------------------------------------------------------------------------------------- def predict(self, array_X, array_Y): predictions = numpy.empty(0) for t in range(0, array_Y.shape[0]): array = numpy.hstack((self.train_Y, array_Y[:t])) model = ExponentialSmoothing( array, seasonal_periods=self.seasonal_periods, trend='add', seasonal='add') fit = model.fit() predictions = numpy.append(predictions, fit.forecast(1)[0]) return predictions
class HoltWinters: def __init__(self, data): data = data.astype(float) self.__data = data self._firstTime = True self.model = {} self.results = [] print(self.__data.head()) plt.plot(self.__data) # self.__data.plot() plt.show() def fit(self): self.model = ExponentialSmoothing( self.__data['BW'], seasonal_periods=7, trend='add', seasonal='add', ) self.results = self.model.fit() def show_and_save(self, forecast): pd.concat([self.__data, forecast], axis=1).plot() plt.savefig('graph-{}.pdf'.format(forecast.index[0])) plt.show() def predict(self, horizon, sample_frequency): future_forecast = self.results.predict(n_periods=horizon) future_ts = [ v + pd.to_timedelta(sample_frequency * (i + 1), unit='s') for i, v in enumerate([self.__data.index[-1]] * horizon) ] # This returns an array of predictions: future_forecast = pd.DataFrame(future_forecast, index=future_ts, columns=['Prediction']) self.show_and_save(future_forecast) return future_forecast
def holt_winter(train, validate, target_var, eval_df): model_type = "Holt Winter" model = ExponentialSmoothing( np.asarray(train[target_var]), seasonal_periods=12, trend='add', seasonal='add', ) model = model.fit() yhat = pd.DataFrame({target_var: '1'}, index=validate.index) yhat_items = model.forecast(len(yhat)) yhat[target_var] = yhat_items rmse = plot_and_eval(train, validate, yhat, target_var, model_type) eval_df = append(model_type, target_var, rmse, eval_df) return eval_df
fit2 = SimpleExpSmoothing(np.asarray(data)).fit(smoothing_level=0.6,optimized=False) data.tail(6) fit2.forecast(5) np.vstack([data.tail(10), fit2.forecast(10)]) #%%% fit3 = ExponentialSmoothing(np.asarray(data) ,seasonal_periods=7 , trend='add', seasonal='add',).fit() fit3.forecast(5) #### from statsmodels.tsa.api import ExponentialSmoothing exp = ExponentialSmoothing(data) exp_model = exp.fit(smoothing_level=0.1) result = exp_model.fittedvalues dir(exp_model) data exp_model.predict(30) result result.plot() #%%%% import pmdarima.datasets as pm wine = pm.load_wineind(True) wine.head() wine.tail() wine.head().append(wine.tail()) wine.shape
print("TEST Box-Ljung P-Values : ", acorr_ljungbox(hw.resid)[1]) # ### Controle Holt-Winters sur Entrainement 12 derniers mois VS realité # In[29]: # Split Dataset en Data Train / Test train = ara2.iloc[:-12, :][['conso_ctp']] test = ara2.iloc[-12:, :][['conso_ctp']] pred = test.copy() # Appliquer Modéle Holt-Winters sur Série "train" (-12mois mois) hw_model = ExponentialSmoothing(train, trend="add", seasonal="add", seasonal_periods=12) hw_fit = hw_model.fit() hw_pred = hw_fit.forecast(12) # Récupérer Estimateurs hw_rmse = round(np.sqrt(np.mean(np.square(test.values - hw_pred.values))), 2) hw_mape = round(np.mean(np.abs(1 - hw_pred.values / test.values)) * 100, 2) hw_aic = round(hw_fit.aic, 2) hw_bic = round(hw_fit.bic, 2) dfhw = hw_fit.params_formatted float(dfhw[dfhw.name == 'alpha']['param'].values) hw_α = float(dfhw[dfhw.name == 'alpha']['param'].values) hw_β = float(dfhw[dfhw.name == 'beta']['param'].values) hw_γ = float(dfhw[dfhw.name == 'gamma']['param'].values) # Afficher Prédiction et Résultats Estimtateurs sns.set_style('ticks')
plt.plot(train['Thousands of Passengers'], label='Train') plt.plot(test['Thousands of Passengers'], label='Test') plt.plot(y_hat['Holt'], label='Simple Exp Smoothing') # 트렌드는 반영된 것을 확인할 수 있음 # %% rmse_holt = np.sqrt(mean_squared_error(test['Thousands of Passengers'],y_hat['Holt']) ) #ses보다 줄어들었음을 확인 # %% # Holt_winters from statsmodels.tsa.api import ExponentialSmoothing # %% winter_model = ExponentialSmoothing(train['Thousands of Passengers'],seasonal_periods=12,trend="add",seasonal="add") # %% winter_result = winter_model.fit() # %% y_hat['Winter'] = winter_result.forecast(len(train)) # %% plt.plot(train['Thousands of Passengers']) plt.plot(test['Thousands of Passengers']) plt.plot(y_hat['Winter']) # 거의 유사한걸 확인할 수 있음 # %% rmse_winter = np.sqrt(mean_squared_error(test['Thousands of Passengers'], y_hat['Winter'])) # 아주 많이 줄어든 것을 확인할 수 있음 # %% # ARIMA # Holt와 Winter's에 비해서 이해하기 어려움
def hwm(self, hi, lo, input_period, train_period, output_period, pct_require): input_time = self.extract_time_type(input_period) train_time = self.extract_time_type(train_period) # extract column from data using column_no data = self.data.iloc[:, self.column_no - 1].dropna() data = pd.DataFrame(data) # convert from month to year if self.frequency[input_time[0]] >= self.frequency[train_time[0]]: data_check = data.copy() if train_period == 'week': previous_period = 'week' if train_period == 'month': previous_period = 'day' if train_period == 'quarter': previous_period = 'quarter' if train_period == 'year': previous_period = 'month' last_time = getattr(data.index[len(data) - 1], previous_period) # cutting data if it's less than 6 if last_time > self.frequency[input_period] / 2: data = self.arima_to_fill(data, last_time, self.frequency[previous_period], input_period) else: data = self.remove(data, last_time) data_info = self.data_info(data) # get portion if train_period == 'month' or train_period == 'year': percent_portion = self.percentage_type1( data_info, input_time[0], train_time[0]).reset_index() else: percent_portion = self.percentage_type2( data_info, input_time[0], train_time[0]).reset_index() else: print(input_time, ' cannot be converted to ', train_time, ' as it is smaller') # if(train_period=='week'): if train_period == 'week': data = self.resemble_week(data_info[self.name]) data = data[self.name].resample(self.time[train_period]).sum() if pct_require: data = self.percent_change(data, train_period).dropna() train = self.outlier(data, lower=lo, upper=hi) train = train.interpolate(method='cubic', order=3, s=0).ffill().bfill() model = ExponentialSmoothing( train, seasonal_periods=self.frequency[train_period], trend='add', seasonal='mul') model_fit = model.fit() future_forecast = model_fit.predict( len(train), len(train) + self.no_of_forecast_month - 1).reset_index() future_forecast = future_forecast.rename(columns={ 'index': 'Date', 0: self.name }) train = train.reset_index() train = train.append(future_forecast) train = train[len(train) - self.no_of_forecast_month:len(train)].reset_index( drop=True) time_add = train_period + 's' if time_add == 'quarters': last_date = train['Date'][len(train) - 1] + relativedelta(months=4) else: last_date = train['Date'][len(train) - 1] + relativedelta(**{time_add: 1}) dummy_data = pd.DataFrame(columns=['Date', self.name]) dummy_data.loc[0] = [last_date, 0] train = train.append(dummy_data) train = train.set_index('Date') train_converted = train[self.name].resample(self.time[input_period], fill_method='ffill') train_converted = train_converted[:-1].reset_index() portion = percent_portion if self.frequency[input_time[0]] == self.frequency[train_time[0]]: portion[self.name] = 1 train_converted['Date'] = pd.to_datetime(train_converted['Date']) train_converted['month'] = pd.DatetimeIndex( train_converted['Date']).month join_data = train_converted.merge(percent_portion, left_on=input_period, right_on=input_period) join_data[self.name] = join_data[self.name + '_x'] * join_data[self.name + '_y'] join_data = join_data.sort_values(by=['Date']).set_index('Date') forecast_value = pd.Series(join_data[self.name], index=join_data.index) final = forecast_value.resample( self.time[output_period]).sum().reset_index() final = pd.melt(final, id_vars=[final.columns[0]], value_vars=[final.columns[1]]) print(final)
def anomaly_holt(lista_datos, desv_mse=0): lista_puntos = np.arange(0, len(lista_datos), 1) df, df_train, df_test = h.create_train_test(lista_puntos, lista_datos) engine_output = {} ####################ENGINE START stepwise_model = ExponentialSmoothing(df_train['valores'], seasonal_periods=1) fit_stepwise_model = stepwise_model.fit() fit_forecast_pred_full = fit_stepwise_model.fittedvalues future_forecast_pred = fit_stepwise_model.forecast(len(df_test['valores'])) ###### sliding windows #ventanas=h.windows(lista_datos,10) #print(ventanas[0]) #training_data=[] #count=0 #forecast_pred10 =[] #real_pred10=[] #for slot in ventanas: #if count != 0: #stepwise_model = ExponentialSmoothing(training_data,seasonal_periods=1 ) #fit_stepwise_model = stepwise_model.fit() #future_forecast_pred = fit_stepwise_model.forecast(len(slot)) #forecast_pred10.extend(future_forecast_pred) #real_pred10.extend(slot) #training_data.extend(slot) #else: #training_data.extend(slot) #forecast_pred10.extend(slot) #real_pred10.extend(slot) #count=1 #print ('Wndows prediction') ##print ( forecast_pred10) ##print ( real_pred10) #print ('Wndows mae ' + str(mean_absolute_error(forecast_pred10, real_pred10))) ####################ENGINE START ##########GRID to find seasonal n_periods mae_period = 99999999 best_period = 0 for period in range(2, 20): print("Period: " + str(period)) stepwise_model = ExponentialSmoothing( df_train['valores'], seasonal_periods=period, trend='add', seasonal='add', ) fit_stepwise_model = stepwise_model.fit() future_forecast_pred = fit_stepwise_model.forecast( len(df_test['valores'])) #print ("valores") #print future_forecast_pred mae_temp = mean_absolute_error(future_forecast_pred.values, df_test['valores'].values) if mae_temp < mae_period: best_period = period mae_period = mae_temp else: print("mae:" + str(mae_temp)) print("######best mae is " + str(mae_period) + " with the period " + str(best_period)) stepwise_model = ExponentialSmoothing( df_train['valores'], seasonal_periods=best_period, trend='add', seasonal='add', ) fit_stepwise_model = stepwise_model.fit() future_forecast_pred = fit_stepwise_model.forecast(len(df_test['valores'])) print(future_forecast_pred.values) list_test = df_test['valores'].values mse_test = (future_forecast_pred - list_test) test_values = pd.DataFrame(future_forecast_pred, index=df_test.index, columns=['expected value']) print(list_test) mse = mean_squared_error(future_forecast_pred.values, list_test) print('Model_test mean error: {}'.format(mse)) rmse = np.sqrt(mse) print('Model_test root error: {}'.format(rmse)) mse_abs_test = abs(mse_test) df_aler = pd.DataFrame(future_forecast_pred, index=df.index, columns=['expected value']) df_aler['step'] = df['puntos'] df_aler['real_value'] = df_test['valores'] df_aler['mse'] = mse df_aler['rmse'] = rmse df_aler['mae'] = mean_absolute_error(list_test, future_forecast_pred) df_aler['anomaly_score'] = abs(df_aler['expected value'] - df_aler['real_value']) / df_aler['mae'] df_aler_ult = df_aler[:5] df_aler_ult = df_aler_ult[ (df_aler_ult.index == df_aler.index.max()) | (df_aler_ult.index == ((df_aler.index.max()) - 1)) | (df_aler_ult.index == ((df_aler.index.max()) - 2)) | (df_aler_ult.index == ((df_aler.index.max()) - 3)) | (df_aler_ult.index == ((df_aler.index.max()) - 4))] if len(df_aler_ult) == 0: exists_anom_last_5 = 'FALSE' else: exists_anom_last_5 = 'TRUE' df_aler = df_aler[(df_aler['anomaly_score'] > 2)] max = df_aler['anomaly_score'].max() min = df_aler['anomaly_score'].min() df_aler['anomaly_score'] = (df_aler['anomaly_score'] - min) / (max - min) max = df_aler_ult['anomaly_score'].max() min = df_aler_ult['anomaly_score'].min() df_aler_ult['anomaly_score'] = (df_aler_ult['anomaly_score'] - min) / (max - min) print("Anomaly finished. Start forecasting") stepwise_model1 = ExponentialSmoothing(df['valores'], seasonal_periods=best_period, seasonal='add') print("Pass the training") fit_stepwise_model1 = stepwise_model1.fit() future_forecast_pred1 = fit_stepwise_model1.forecast(5) print("Pass the forecast") engine_output['rmse'] = rmse engine_output['mse'] = mse engine_output['mae'] = mean_absolute_error(list_test, future_forecast_pred) engine_output['present_status'] = exists_anom_last_5 engine_output['present_alerts'] = df_aler_ult.fillna(0).to_dict( orient='record') engine_output['past'] = df_aler.fillna(0).to_dict(orient='record') engine_output['engine'] = 'Holtwinters' print("Only for future") df_future = pd.DataFrame(future_forecast_pred1, columns=['value']) df_future['value'] = df_future.value.astype("float32") df_future['step'] = np.arange(len(lista_datos), len(lista_datos) + 5, 1) engine_output['future'] = df_future.to_dict(orient='record') test_values['step'] = test_values.index print("debug de Holtwinters") print(test_values) engine_output['debug'] = test_values.to_dict(orient='record') print("la prediccion es") print df_future return engine_output
ax.get_yaxis().set_major_formatter( matplotlib.ticker.FuncFormatter(lambda x, p: format(int(x), ','))) ax.plot(y, marker='', linestyle='-', color='#4089F9', linewidth=1, label='observed') ax.fill_between(df.index, y, facecolor='#4089F9', alpha=0.4) model = ExponentialSmoothing(y, seasonal_periods=52, trend='add', seasonal='add', damped_trend=True) #model = SimpleExpSmoothing(y, trend='add', seasonal='add', damped_trend=True) fit = model.fit() fcast = fit.forecast(40) ax.plot(fcast, marker='', linestyle='-', color='#23B55E', linewidth=1, label='predicted') logger.debug(fcast) ax.fill_between(fcast.index, fcast, facecolor='#23B55E', alpha=0.4) # Minor ticks every month. fmt_month = mdates.MonthLocator() ax.xaxis.set_minor_locator(fmt_month) ax.legend() saveplt(plt, file_output)
def anomaly_holt(lista_datos,num_fut,desv_mse=0,name='NA'): lista_puntos = np.arange(0, len(lista_datos),1) df, df_train, df_test = create_train_test(lista_puntos, lista_datos) engine_output={} ####################ENGINE START stepwise_model = ExponentialSmoothing(df_train['valores'],seasonal_periods=1 ) fit_stepwise_model = stepwise_model.fit() fit_forecast_pred_full = fit_stepwise_model.fittedvalues future_forecast_pred = fit_stepwise_model.forecast(len(df_test['valores'])) ###### sliding windows #ventanas=h.windows(lista_datos,10) #print(ventanas[0]) #training_data=[] #count=0 #forecast_pred10 =[] #real_pred10=[] #for slot in ventanas: #if count != 0: #stepwise_model = ExponentialSmoothing(training_data,seasonal_periods=1 ) #fit_stepwise_model = stepwise_model.fit() #future_forecast_pred = fit_stepwise_model.forecast(len(slot)) #forecast_pred10.extend(future_forecast_pred) #real_pred10.extend(slot) #training_data.extend(slot) #else: #training_data.extend(slot) #forecast_pred10.extend(slot) #real_pred10.extend(slot) #count=1 #print ('Wndows prediction') ##print ( forecast_pred10) ##print ( real_pred10) #print ('Wndows mae ' + str(mean_absolute_error(forecast_pred10, real_pred10))) ####################ENGINE START ##########GRID to find seasonal n_periods mae_period = 99999999 best_period=0 best_trend='null' #list_trend=['add','mul','additive','multiplicative'] list_trend=['add'] for trend in list_trend: for period in range(4,18): print ('Periodo', period) list_forecast_camb = [] tam_train = int(len(df)*0.7) df_test = df[tam_train:] for i in range(0,len(df_test)): print ('Prediccion punto ', i) df_train_camb = df[:tam_train+i] stepwise_model_camb = ExponentialSmoothing(df_train_camb['valores'],seasonal_periods=period ,trend=trend, seasonal='add', ) fit_stepwise_model_camb = stepwise_model_camb.fit() forecast_camb = fit_stepwise_model_camb.forecast(1) list_forecast_camb.append(forecast_camb.values[0]) mae_temp = mean_absolute_error(list_forecast_camb,df_test['valores'].values) if mae_temp < mae_period: best_period = period best_trend = trend print ('best_period',best_period) print ('best_trend', best_trend) print ('mae_temp', mae_temp) mae_period = mae_temp else: print ('aa') print ("######best mae is " + str(mae_period) + " with the period " + str(best_period)+ " trend " + best_trend) stepwise_model = ExponentialSmoothing(df_train['valores'],seasonal_periods=best_period ,trend=best_trend, seasonal='add', ) fit_stepwise_model = stepwise_model.fit() future_forecast_pred = fit_stepwise_model.forecast(len(df_test['valores'])) print (future_forecast_pred.values) list_test = df_test['valores'].values mse_test = (future_forecast_pred - list_test) test_values = pd.DataFrame(future_forecast_pred,index = df_test.index,columns=['expected value']) print(list_test) mse = mean_squared_error(future_forecast_pred.values,list_test) print('Model_test mean error: {}'.format(mse)) rmse = np.sqrt(mse) print('Model_test root error: {}'.format(rmse)) mse_abs_test = abs(mse_test) df_aler = pd.DataFrame(future_forecast_pred,index = df.index,columns=['expected value']) df_aler['step'] = df['puntos'] df_aler['real_value'] = df_test['valores'] df_aler['mse'] = mse df_aler['rmse'] = rmse df_aler['mae'] = mean_absolute_error(list_test, future_forecast_pred) df_aler['anomaly_score'] = abs(df_aler['expected value'] - df_aler['real_value']) / df_aler['mae'] df_aler_ult = df_aler[:5] df_aler_ult = df_aler_ult[(df_aler_ult.index==df_aler.index.max())|(df_aler_ult.index==((df_aler.index.max())-1)) |(df_aler_ult.index==((df_aler.index.max())-2))|(df_aler_ult.index==((df_aler.index.max())-3)) |(df_aler_ult.index==((df_aler.index.max())-4))] if len(df_aler_ult) == 0: exists_anom_last_5 = 'FALSE' else: exists_anom_last_5 = 'TRUE' df_aler = df_aler[(df_aler['anomaly_score']> 2)] max = df_aler['anomaly_score'].max() min = df_aler['anomaly_score'].min() df_aler['anomaly_score']= ( df_aler['anomaly_score'] - min ) /(max - min) max = df_aler_ult['anomaly_score'].max() min = df_aler_ult['anomaly_score'].min() df_aler_ult['anomaly_score']= ( df_aler_ult['anomaly_score'] - min ) /(max - min) print ("Anomaly finished. Start forecasting") stepwise_model1 = ExponentialSmoothing(df['valores'],seasonal_periods=best_period,trend=best_trend , seasonal='add') print ("Pass the training") fit_stepwise_model1 = stepwise_model1.fit() #with open('./models_temp/learned_model.pkl','w') as f: # pickle.dump(results,f) filename='./models_temp/learned_model_holt_winters'+name with open(filename,'w') as f: f.write(str(best_period)+','+str(best_trend)) f.close() new_model(name, 'Holtwinters', pack('N', 365),str(best_period)+','+str(best_trend),mae_period) future_forecast_pred1 = fit_stepwise_model1.forecast(num_fut) print ("Pass the forecast") engine_output['rmse'] = rmse engine_output['mse'] = mse engine_output['mae'] = mean_absolute_error(list_test, future_forecast_pred) engine_output['present_status']=exists_anom_last_5 engine_output['present_alerts']=df_aler_ult.fillna(0).to_dict(orient='record') engine_output['past']=df_aler.fillna(0).to_dict(orient='record') engine_output['engine']='Holtwinters' print ("Only for future") df_future= pd.DataFrame(future_forecast_pred1,columns=['value']) df_future['value']=df_future.value.astype("float32") df_future['step']= np.arange( len(lista_datos),len(lista_datos)+num_fut,1) engine_output['future'] = df_future.to_dict(orient='record') test_values['step'] = test_values.index print ("debug de Holtwinters") print (test_values) engine_output['debug'] = test_values.to_dict(orient='record') print ("la prediccion es") print (df_future) return engine_output
def forecast_holt(lista_datos,num_fut,desv_mse=0,name='NA'): lista_puntos = np.arange(0, len(lista_datos),1) df, df_train, df_test = create_train_test(lista_puntos, lista_datos) engine_output={} best_period=0 #stepwise_model = ExponentialSmoothing(df_train['valores'],seasonal_periods=best_period ,trend='add', seasonal='add', ) #fit_stepwise_model = stepwise_model.fit() filename='./models_temp/learned_model_holt_winters'+name with open(filename,'r') as f: best_period, best_trend= f.read().split(",") best_period=int(best_period) best_trend=best_trend f.close() (model_name,model,params)=get_best_model(name) print("parametros" + params) best_period, best_trend=params.split(",") best_period=int(best_period) best_trend=best_trend print("el dato es ") print (str(best_period)) stepwise_model = ExponentialSmoothing(df_train['valores'],seasonal_periods=best_period ,trend='add', seasonal='add', ) fit_stepwise_model = stepwise_model.fit() future_forecast_pred = fit_stepwise_model.forecast(len(df_test['valores'])) print (future_forecast_pred.values) list_test = df_test['valores'].values mse_test = (future_forecast_pred - list_test) test_values = pd.DataFrame(future_forecast_pred,index = df_test.index,columns=['expected value']) print(list_test) mse = mean_squared_error(future_forecast_pred.values,list_test) print('Model_test mean error: {}'.format(mse)) rmse = np.sqrt(mse) print('Model_test root error: {}'.format(rmse)) mse_abs_test = abs(mse_test) df_aler = pd.DataFrame(future_forecast_pred,index = df.index,columns=['expected value']) df_aler['step'] = df['puntos'] df_aler['real_value'] = df_test['valores'] df_aler['mse'] = mse df_aler['rmse'] = rmse df_aler['mae'] = mean_absolute_error(list_test, future_forecast_pred) df_aler['anomaly_score'] = abs(df_aler['expected value'] - df_aler['real_value']) / df_aler['mae'] df_aler_ult = df_aler[:5] df_aler_ult = df_aler_ult[(df_aler_ult.index==df_aler.index.max())|(df_aler_ult.index==((df_aler.index.max())-1)) |(df_aler_ult.index==((df_aler.index.max())-2))|(df_aler_ult.index==((df_aler.index.max())-3)) |(df_aler_ult.index==((df_aler.index.max())-4))] if len(df_aler_ult) == 0: exists_anom_last_5 = 'FALSE' else: exists_anom_last_5 = 'TRUE' df_aler = df_aler[(df_aler['anomaly_score']> 2)] max = df_aler['anomaly_score'].max() min = df_aler['anomaly_score'].min() df_aler['anomaly_score']= ( df_aler['anomaly_score'] - min ) /(max - min) max = df_aler_ult['anomaly_score'].max() min = df_aler_ult['anomaly_score'].min() df_aler_ult['anomaly_score']= ( df_aler_ult['anomaly_score'] - min ) /(max - min) print ("Anomaly finished. Start forecasting") stepwise_model1 = ExponentialSmoothing(df['valores'],seasonal_periods=best_period , seasonal='add') print ("Pass the training") fit_stepwise_model1 = stepwise_model1.fit() future_forecast_pred1 = fit_stepwise_model1.forecast(num_fut) print ("Pass the forecast") engine_output['rmse'] = rmse engine_output['mse'] = mse engine_output['mae'] = mean_absolute_error(list_test, future_forecast_pred) engine_output['present_status']=exists_anom_last_5 engine_output['present_alerts']=df_aler_ult.fillna(0).to_dict(orient='record') engine_output['past']=df_aler.fillna(0).to_dict(orient='record') engine_output['engine']='Holtwinters' print ("Only for future") df_future= pd.DataFrame(future_forecast_pred1,columns=['value']) df_future['value']=df_future.value.astype("float32") df_future['step']= np.arange( len(lista_datos),len(lista_datos)+num_fut,1) engine_output['future'] = df_future.to_dict(orient='record') test_values['step'] = test_values.index print ("debug de Holtwinters") print (test_values) engine_output['debug'] = test_values.to_dict(orient='record') print ("la prediccion es") print (df_future) return engine_output