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
