def estimate_holt(df, seriesname, alpha=0.2, slope=0.1, trend="add", estimationlength=2): numbers = np.asarray(df[seriesname], dtype='float') model = Holt(numbers) fit = model.fit(alpha, slope, trend) estimate = fit.forecast(estimationlength) return estimate # Perform Dickey-Fuller test: print("Results of Dickey-Fuller Test:") array = np.asarray(timeseries, dtype='float') np.nan_to_num(array, copy=False) dftest = adfuller(array, autolag='AIC') dfoutput = pd.Series(dftest[0:4], index=[ 'Test Statistic', 'p-value', '#Lags Used', 'Number of Observations Used' ]) for key, value in dftest[4].items(): dfoutput['Critical Value (%s)' % key] = value print(dfoutput)
def estimate_Holt(array, alpha, slope, sizeestimate): model = Holt(array) fit = model.fit(smoothing_level=alpha, smoothing_slope=slope) forecast = fit.forecast(sizeestimate) for index in range(len(forecast)): forecast[index] = round(forecast[index], 4) return forecast
def estimate_holt(df, seriesname, alpha=0.2, slope=0.1, trend="add"): numbers = np.asarray(df[seriesname], dtype='float') model = Holt(numbers) fit = model.fit(alpha, slope, trend) estimate = fit.forecast(2)[-1] print("Dollar estimation:", estimate) return estimate
def evaluate_holt_model(X): """ Evaluate a Holt Model :param X: list or series containing all historical data :return: mse (error metric) and the fitted model """ # Prepare training dataset train_size = int(len(X) * 0.75) train, test = X[0:train_size], X[train_size:] history = [x for x in train] # Make predictions predictions = list() for t in range(len(test)): # Fit model model = Holt(history) model_fit = model.fit() # Forecast yhat = model_fit.forecast()[0] # Store prediction and move forward one time step predictions.append(yhat) history.append(test[t]) # calculate out of sample error mse = mean_squared_error(test, predictions) return mse, model_fit
def estimate_Holt(dataframe, name, alpha, slope, sizeestimate): array = np.asarray(dataframe[name]) model = Holt(array) fit = model.fit(smoothing_level = alpha,smoothing_slope = slope) forecast = fit.forecast(sizeestimate) for index in range ( len(forecast) ): forecast[index] = round(forecast[index], 4) return forecast
def estimate_Holt(dataframe, name, alpha, slope, sizeestimate): # Holt requires an array to work with, so we convert the column into an array array = np.asarray(dataframe[name]) model = Holt(array) fit = model.fit(smoothing_level = alpha,smoothing_slope = slope) forecast = fit.forecast(sizeestimate) for index in range ( len(forecast) ): forecast[index] = round(forecast[index], 4) return forecast
def DEF_damping_f(self, df, alpha, beta): try: double_exp = Holt(np.array(df['Actual']), exponential=True, damped=True) fit_double_exp = double_exp.fit(smoothing_level=alpha, smoothing_slope=beta,optimized=False) forecast = fit_double_exp.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-DEF_DAMPING")
def run_holts(train, validate, target_variable,exponential, smoothing_level = .1, smoothing_slope = .1): # Create model object model = Holt(train[target_variable], exponential = exponential) # Fit model model = model.fit(smoothing_level = smoothing_level, smoothing_slope=smoothing_slope, optimized = False) # Create predictions y_pred = model.predict(start=validate.index[0], end=validate.index[-1]) return model, y_pred
def create_Holt_Winters(self, series, param): assert type(param) == str self.args = param # self.print_params(param) model = Holt(series, exponential=self.get_bool('exponential'), damped=self.get_bool('damped')) return model.fit(smoothing_level=self.get_float('smoothing_level'), smoothing_slope=self.get_float('smoothing_slope'), optimized=self.get_bool('optimized'), damping_slope=self.get_float('damping_slope'))
def predict(self, test_X, test_Y): predictions = numpy.empty(0) for t in range(0, test_Y.shape[0]): array = numpy.hstack((self.train_Y, test_Y[:t])) model = Holt(array, exponential=self.exponential, damped=self.damped) fit = model.fit(smoothing_level=self.smoothing_level, smoothing_slope=self.smoothing_slope, damping_slope=self.damping_slope, optimized=self.optimized) predictions = numpy.append(predictions, fit.forecast(1)[0]) return predictions
def holts(train, validate, yhat_df): ''' This function sets default parameters for Holt's model. yhat_items makes predictions based on model. ''' for col in train.columns: model = Holt(train[col], exponential=False, damped=True) model = model.fit(smoothing_level=.1, smoothing_slope=.1, optimized=True) yhat_items = model.predict(start=validate.index[0], end=validate.index[-1]) yhat_df[col] = round(yhat_items, 2) return yhat_df
class TS_Holt(object): def __init__(self, folder_debug=None, filename_weights=None): self.name = 'TS_Holt' self.model = [] self.folder_debug = folder_debug self.exponential = False self.damped = True self.optimized = False self.damping_slope = 0.98 self.smoothing_slope = 0.2 self.smoothing_level = 0.8 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 = Holt(array_Y, exponential=self.exponential, damped=self.damped) self.fit = self.model.fit(smoothing_level=self.smoothing_level, smoothing_slope=self.smoothing_slope, damping_slope=self.damping_slope, optimized=self.optimized) 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, test_X, test_Y): predictions = numpy.empty(0) for t in range(0, test_Y.shape[0]): array = numpy.hstack((self.train_Y, test_Y[:t])) model = Holt(array, exponential=self.exponential, damped=self.damped) fit = model.fit(smoothing_level=self.smoothing_level, smoothing_slope=self.smoothing_slope, damping_slope=self.damping_slope, optimized=self.optimized) predictions = numpy.append(predictions, fit.forecast(1)[0]) return predictions
def holt(train, validate, target_var, eval_df): model_type = "Holt's Linear Trend" model = Holt(train[target_var], exponential=False) model = model.fit(smoothing_level=.1, smoothing_slope=.1, optimized=False) temps = model.predict(start=validate.index[0], end=validate.index[-1]) yhat = pd.DataFrame({target_var: '1'}, index=validate.index) yhat[target_var] = round(temps, 4) rmse = plot_and_eval(train, validate, yhat, target_var, model_type) eval_df = append(model_type, target_var, rmse, eval_df) return eval_df
def estimate_holt(array, alpha, slope, a): numbers = array model = Holt(numbers) fit = model.fit(alpha, slope) estimate = fit.forecast(a)[-1] return estimate
def estimate_holt(df, seriesname, alpha=0.2, slope=0.1): numbers = np.asarray(df[seriesname]) model = Holt(numbers) fit = model.fit(alpha, slope) estimate = fit.forecast(1)[-1] return estimate
plt.plot(train['Thousands of Passengers'], label='Train') plt.plot(test['Thousands of Passengers'], label='Test') plt.plot(y_hat['SES'], label='Simple Exp Smoothing') # 트렌드와 패턴이 반영안된 걸 확인할 수 있음 # %% # mse가 너무커서 루트를 씌워줌 rmse_ses = np.sqrt(mean_squared_error(test['Thousands of Passengers'],y_hat['SES']) ) # %% from statsmodels.tsa.api import Holt # %% holt_model = Holt(train['Thousands of Passengers']) # %% holt_result = holt_model.fit() # %% y_hat['Holt'] = holt_result.forecast(len(test)) # %% 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
def estimate_holt(df, alpha=0.2, slope=0.1): model = Holt(df) fit = model.fit(alpha, slope) estimate = fit.forecast(1)[-1] return estimate
def damped_double_exponential_smoothing(self, y, bias, alpha, beta): smoother = Holt(y - bias, damped_trend=True) fit_model = smoother.fit(smoothing_level=alpha, smoothing_trend=beta) fitted = fit_model.fittedvalues self.model_params = (fit_model, bias, len(y)) return fitted
def estimate_holt(data, alpha=0.2, slope=0.1, trend='add', fc=1): numbers = np.asarray(data, dtype='float') model = Holt(numbers) fit = model.fit(alpha, slope, trend) estimate = fit.forecast(fc)[-1] return estimate