def load_models():
return {
"Sugar Price Index": ARIMAResults.load("model/SugarARIMA.pkl"),
"Meat Price Index": ARIMAResults.load("model/MeatARIMA.pkl"),
"Dairy Price Index": ARIMAResults.load("model/DairyARIMA.pkl"),
"Cereals Price Index": ARIMAResults.load("model/CerealsARIMA.pkl"),
"Oils Price Index": ARIMAResults.load("model/OilsARIMA.pkl")
}
def predict(model, n=6):
'''
进行预测
:param model: 模型
:param n:一般3个点是一个月
:return:预测结果
'''
if isinstance(model, str):
# 模型加载
loaded = ARIMAResults.load('model.pkl')
# 预测未来3个单位,即为1个月
predictions = loaded.forecast(n)
# 预测结果为：
pre_result = predictions[0]
print('预测结果为：', pre_result)
# 标准误差为：
error = predictions[1]
print('标准误差为：', error)
# 置信区间为：
confidence = predictions[2]
print('置信区间为：', confidence)
else:
# 预测未来3个单位,即为1个月
predictions = model.forecast(n)
# 预测结果为：
pre_result = predictions[0]
print('预测结果为：', pre_result)
# 标准误差为：
error = predictions[1]
print('标准误差为：', error)
# 置信区间为：
confidence = predictions[2]
print('置信区间为：', confidence)
return pre_result
def predict_and_plot_closing_price():
df = pd.read_csv(INPUT_FILE, parse_dates=['Date'], usecols=["Date", "Close"])
df = df[::-1]
df.columns = ["ds", "y"]
print(df.head())
data = np.array(df["y"])
split_per = split_ratio*len(df)
split_per = int(math.ceil(split_per))
training, test = data[:split_per], data[split_per:]
history = [x for x in training]
predictions = []
for t in range(len(test)):
model = ARIMA(history, order=(p, d, q))
model_fit = model.fit(disp=0)
model_fit.save('model.pkl')
output = model_fit.forecast()
yhat = output[0]
predictions.append(yhat)
obs = test[t]
history.append(obs)
print('predicted=%f, expected=%f' % (yhat,obs))
for t in range(7):
loaded = ARIMAResults.load('model.pkl')
output = loaded.forecast()
yhat = output[0]
predictions.append(yhat)
history.append(yhat)
print('predicted=%f' % (yhat))
plt.plot(test,color="#39FF14",linewidth=7.0)
plt.plot(predictions, color="black")
def districts():
start = request.args.get('start')
end = request.args.get('end')
rows = DistrictQuantity.query.join(District).with_entities(
District.name.label('name'),
DistrictQuantity.date_occurrence.label('date'),
DistrictQuantity.theft.label('theft')).filter(
DistrictQuantity.date_occurrence >= start).filter(
DistrictQuantity.date_occurrence <= end).all()
values = __transform(rows)
if datetime.strptime(start, '%Y-%m-%d') >= datetime.strptime(
'2018-01-01', '%Y-%m-%d'):
d = pandas.date_range(start='1/1/2018', end='12/1/2018', freq='MS')
d = d.format(formatter=lambda current: current.strftime('%Y-%m'))
values["labels"] = d
for row in District.query.with_entities(
District.id.label('id'), District.name.label('name')).all():
loaded = ARIMAResults.load(ROOT + '/{}.pkl'.format(row.id))
x = [int(round(x)) for x in loaded.forecast(steps=12)[0]]
total = sum(x)
values["total"] += total
values["data"].append({
"values": x,
"label": "{} Previsão".format(row.name),
"total": total
})
return jsonify(values)
def predict(hours):
series = pp.get_data()
X = series.values
history = [x for x in X]
hours_in_week = 168
validation = pp.get_validate()
y = validation.values
model_fit = ARIMAResults.load('model.pkl')
predictions = list()
yhat = model_fit.forecast()[0]
yhat = inverse_difference(history, yhat, hours_in_week)
predictions.append(yhat)
history.append(yhat)
for i in range(1, hours):
diff = difference(history, hours_in_week)
model = ARIMA(diff, order=(1, 0, 0))
model_fit = model.fit(trend='nc', disp=0)
yhat = model_fit.forecast()[0]
yhat = inverse_difference(history, yhat, hours_in_week)
history.append(yhat)
predictions.append(yhat)
return predictions
def build_arima_model(train,
target,
params=(24, 0, 24),
adfuller_test=True,
maxiter=100):
df_target = get_df_arma(train, target)
if adfuller_test:
check_stationarity(df_target[target])
model = sm.tsa.ARIMA(df_target, params)
start = train['date'].head(1)[0].strftime('%d_%m_%Y_%H_%M')
end = pd.to_datetime(
train['date'].tail(1).values[0]).strftime('%d_%m_%Y_%H_%M')
filename = '../models/arima_model_p_%d_d_%d_q_%d_%s_from_%s_to_%s.pkl' % (
*params, target, start, end)
if os.path.exists(filename):
print("Loading...")
result = ARIMAResults.load(filename)
else:
result = model.fit(solver='bfgs', maxiter=maxiter)
result.save(filename)
return result
def main_task():
# load and prepare datasets
dataset = Series.from_csv(file_path)
X = dataset.values.astype('float32')
history = [x for x in X]
validation = Series.from_csv(file_path)
y = validation.values.astype('float32')
# load model
model_fit = ARIMAResults.load('car.pkl')
# make first prediction
predictions = list()
yhat = float(model_fit.forecast()[0])
predictions.append(yhat)
history.append(y[0])
print('>Predicted=%.3f, Expected=%3.f' % (yhat, y[0]))
# rolling forecasts
for i in range(1, len(y)):
# predict
model = ARIMA(history, order=(2, 1, 0))
model_fit = model.fit(trend='nc', disp=0)
yhat = float(model_fit.forecast()[0])
predictions.append(yhat)
# observation
obs = y[i]
history.append(obs)
print('>Predicted=%.3f, Expected=%3.f' % (yhat, obs))
# report performance
rmse = sqrt(mean_squared_error(y, predictions))
print('RMSE: %.3f' % rmse)
pyplot.plot(y)
pyplot.plot(predictions, color='red')
pyplot.show()
def more_prediction():
dataset = pd.Series.from_csv('dataset.csv')
X = dataset.values.astype('float32')
history = [x for x in X]
validation = pd.Series.from_csv('validation.csv')
y = validation.values.astype('float32')
# load model
model_fit = ARIMAResults.load('model.pkl')
bias = np.load('model_bias.npy')
# 做出第一个预测
predictions = list()
yhat = bias + float(model_fit.forecast()[0])
predictions.append(yhat)
history.append(y[0])
print('>Predicted=%.3f, Expected=%3.f' % (yhat, y[0]))
# 滚动预测
for i in range(1, len(y)):
# predict
model = ARIMA(history, order=(4, 0, 0))
model_fit = model.fit(disp=-1)
yhat = bias + float(model_fit.forecast()[0])
predictions.append(yhat)
# observation
obs = y[i]
history.append(obs)
print('>Predicted=%.3f, Expected=%3.f' % (yhat, obs))
# 报告性能
mse = mean_squared_error(y, predictions)
rmse = math.sqrt(mse)
print('RMSE: %.3f' % rmse)
pyplot.plot(y)
pyplot.plot(predictions, color='red')
pyplot.show()
def finalize(filename=None):
dataset = Series.from_csv('Krakow_data.csv')
X = dataset.values.astype('float32')
history = [x for x in X]
months_in_year = 12
diff = difference.difference(X, months_in_year)
model = ARIMA(diff, order=(6, 0, 2))
model_fit = model.fit(trend='nc', disp=0)
model_fit.save('model.pkl')
np.save('model_bias.npy', [0.237574])
validation = Series.from_csv('Krakow_validation.csv')
y = validation.values.astype('float32')
model_fit = ARIMAResults.load('model.pkl')
bias = np.load('model_bias.npy')
predictions = list()
yhat = float(model_fit.forecast()[0])
yhat = bias + difference.inverse_difference(history, yhat, months_in_year)
predictions.append(yhat)
history.append(y[0])
label_for_x = [
'2017-06', '2017-07', '2017-08', '2017-09', '2017-10', '2017-11',
'2017-12', '2018-01', '2018-02', '2018-03', '2018-04', '2018-05',
'2018-06', '2018-07', '2018-08'
]
print('For month: {} Predicted= {} , Expected= {}'.format(
label_for_x[0], str(yhat), str(y[0])))
for i in range(1, len(y)):
months_in_year = 12
diff = difference.difference(history, months_in_year)
model = ARIMA(diff, order=(6, 0, 2))
model_fit = model.fit(trend='nc', disp=0)
yhat = model_fit.forecast()[0]
yhat = bias + difference.inverse_difference(history, yhat,
months_in_year)
predictions.append(yhat)
obs = y[i]
history.append(obs)
print('For month: {} Predicted= {} , Expected= {}'.format(
label_for_x[i], str(yhat), str(obs)))
mse = mean_squared_error(y, predictions)
rmse = sqrt(mse)
print('RMSE: {:0.3f}'.format(rmse))
plt.figure(figsize=(10, 7))
plt.title('Forecast for temperature in Kraków')
plt.xlabel('Data')
plt.ylabel('Temperature')
plt.xticks(list(range(0, 15)), label_for_x)
plt.xticks(rotation=45)
plt.grid()
plt.plot(y, label="Observational values")
plt.plot(predictions, color='red', label="Foreseen values")
plt.legend()
plt.savefig(filename)
return rmse
def recursive_test1(data, arima_Order, numOfP):
"""def make_predictions(xList, yList, model, bias, numOfPredictions):
count = 0
while count < numOfPredictions:
model = ARIMA(xList, arima_Order)
model_fit = model.fit(trend = 'nc', disp=0)
prdct = bias + float(model_fit.forecast()[0])
xList.append(prdct[0])
print("Prediction ",count," : ",prdct[0])
yList.append(prdct[0])
count = count + 1
return yList
"""
D = data.values.astype('float32')
history = [x for x in D]
modelF = ARIMAResults.load('model.pkl')
biasF = numpy.load('model_bias.npy')
#Make first prediction
predictions = []
predic = biasF + float(modelF.forecast()[0])
print("\nRecursive Orig D: ", D)
print("\nRecursive Orig history: ", history)
predictions.append(predic[0])
history.append(predic[0])
count = 0
#Rolling forecasts
while count < numOfP:
#Make predictions
model = ARIMA(history, arima_Order)
model_fit = model.fit(trend='nc', disp=0)
predic = bias + float(model_fit.forecast()[0])
predictions.append(predic)
history.append(predic)
count = count + 1
print("\nRecursive D: ", D)
print("\nRecursive history: ", history)
print("\nRecursive predictions: ", predictions)
pyplot.plot(D, color='blue')
pyplot.plot(predictions, color='red')
pyplot.show()
return
def predict_model(self,
timeseries_series,
fitted_model_name,
num_steps = 1,
differencing_interval=1):
model_fit = ARIMAResults.load(fitted_model_name + '.pkl')
bias = np.load(fitted_model_name + '_bias.npy')
yhat, err95, ci95 = model_fit.forecast(steps=num_steps)
yhat = bias + self.reverse_difference_decomposition(timeseries_series.values, yhat, differencing_interval)
return yhat
def forecast_1day(arg_dict):
'''load finalized model and make a prediction'''
# Load model
model_fit = ARIMAResults.load(r'data/model.pkl')
bias = np.load(r'data/model_bias.npy')
# Pick a future to predict. 0 means literally tomorrow.
yhat = bias + float(model_fit.forecast()[0])
print(
f"The predicted cumulative {arg_dict['dependent_variable']} for {arg_dict['place']} for tomorrow (input data plus 1 day) are {place_value(yhat)}"
)
def train_and_evaluate_arima_model(train_data, test_data, ARIMA_ORDER,
is_saved_model):
predictions = []
actuals = []
arima_model_fit = None
recur_train_data = [x for x in train_data]
if is_saved_model == False:
## Train the model using walk-forward validation technique / rolling forecast
for i in range(len(test_data)):
model = ARIMA(recur_train_data, order=ARIMA_ORDER)
arima_model_fit = model.fit(disp=0) # Fit the ARIMA model
output = arima_model_fit.forecast()
predicted_value = output[0]
actual_value = test_data[i]
recur_train_data.append(actual_value)
predictions.append(predicted_value)
actuals.append(actual_value)
# print('Predicted Value: %f, Actual Value: %f' % (predicted_value, actual_value))
elif is_saved_model == True:
## Load the saved ARIMA model
arima_loaded_model = ARIMAResults.load(model_filename)
arima_model_fit = arima_loaded_model
# print('Training the ARIMA{} model..'.format(arima_order))
for i in range(len(test_data)):
model = ARIMA(recur_train_data, order=ARIMA_ORDER)
arima_model_fit = model.fit(disp=0) # Fit the ARIMA model
output = arima_model_fit.forecast()
predicted_value = output[0]
actual_value = test_data[i]
recur_train_data.append(actual_value)
predictions.append(predicted_value)
actuals.append(actual_value)
## Evaluate the ARIMA model using several metrics (Mean Absolute Error, Mean Absolute Percentage Error, Root Mean Squared Error)
mae = metrics.mean_absolute_error(actuals, predictions)
mape = np.mean(
np.abs((np.array(actuals) - np.array(predictions)) /
np.array(actuals))) * 100
mse = metrics.mean_squared_error(actuals, predictions)
rmse = np.sqrt(mse)
return mae, mape, rmse, predictions, actuals, arima_model_fit
def arimainference(self, pickleFileLocation, storeLocation,
daysintothefuture):
print(pickleFileLocation)
model = ARIMAResults.load(pickleFileLocation)
predictions = model.forecast(daysintothefuture)
predictions = pd.DataFrame({"predictions": predictions})
print(predictions)
# ran=random.randint(100,999)
csvresults = predictions.to_csv()
inferenceDataResultsPath = os.path.join(storeLocation, "inference.csv")
inference = open(inferenceDataResultsPath, "w+")
inference.write(csvresults)
inference.close()
return inferenceDataResultsPath
def graph_print(called_status, graph_to_print, training_data, test_data, len_training):
results_ar = ARIMAResults.load("../trained_model/"+called_item+".pkl")
global original_data_plot, predicted_data
if called_status == 0:
#making prediction
pred = results_ar.forecast(steps=60)[0]
y = pred.tolist()
s = pd.Series(y, copy=False)
s = np.exp(s)
training_data = training_data.reset_index()
for x in range(len(s)):
if(training_data.Month[len(training_data)-1].month < 12):
m = training_data.Month[len(training_data)-1].month + 1
y = training_data.Month[len(training_data)-1].year
else:
y = training_data.Month[len(training_data)-1].year + 1
m = 1
d = '{}-{}'.format(y, m)
d = datetime.strptime(d, '%Y-%m')
training_data = training_data.append(
{'Month': d, 'Quantity': s[x]}, ignore_index=True)
training_data.set_index("Month", inplace=True)
original_data_plot = training_data[:len_training]
predicted_data = training_data[len_training:]
fig = plt.figure(figsize=(4.5, 4), dpi=90)
plt.title(title_print_first_word+" of "+called_item)
if(graph_to_print == "Line Graph"):
plt.plot(original_data_plot, color='black', label="Training Data")
plt.plot(test_data, color='blue', label="Actual Data")
plt.plot(predicted_data, color='red', label="Predicted Data")
elif(graph_to_print == "Scatter Graph"):
plt.scatter(original_data_plot.index.values, original_data_plot['Quantity'], s=10, color='black', label="Training Data")
plt.scatter(test_data.index.values, test_data['Quantity'], s=10, color='blue', label="Actual Data")
plt.scatter(predicted_data.index.values, predicted_data['Quantity'], s=10, color='red', label="Predicted Data")
# plt.show()
plt.xlabel("Date")
plt.ylabel("Quantity in Kg")
plt.legend(loc='best')
# You can make your x axis labels vertical using the rotation
# specify the window as master
canvas = FigureCanvasTkAgg(fig, master=window)
canvas.draw()
canvas.get_tk_widget().grid(row=1, column=0, columnspan=4,
padx=7, pady=5, ipadx=20)
called_status = 1
return called_status
def predictRun(p, d, q):
X = validate.getdataset().values.astype('float32')
history = [x for x in X]
months_in_year = 12
y = validate.getvalidation().values.astype('float32')
# load model
model_fit = ARIMAResults.load(variables.model)
bias = numpy.load(variables.bias)
# make first prediction
predictions = list()
yhat = float(model_fit.forecast()[0])
yhat = bias + inverse_difference(history, yhat, months_in_year)
predictions.append(yhat)
history.append(y[0])
print('>Predicted=%.3f, Expected=%3.f, accuracy=%3.f' %
(yhat, y[0], yhat / y[0] * 100))
# rolling forecasts
for i in range(1, len(y)):
# difference data
months_in_year = 12
diff = difference(history, months_in_year)
# predict
model = ARIMA(diff, order=(p, d, q))
model_fit = model.fit(trend='nc', disp=0)
yhat = model_fit.forecast()[0]
yhat = bias + inverse_difference(history, yhat, months_in_year)
predictions.append(yhat)
# observation
obs = y[i]
history.append(obs)
print('>Predicted=%.3f, Expected=%3.f, accuracy=%3.f' %
(yhat, obs, yhat / obs * 100))
# report performance
mse = mean_squared_error(y, predictions)
rmse = sqrt(mse)
print('RMSE: %.3f' % rmse)
pyplot.plot(y)
pyplot.plot(predictions, color='red')
red_line = mlines.Line2D([], [], color='red', label='Voorspelling')
blue_line = mlines.Line2D([], [], color='blue', label='Werkelijkheid')
pyplot.legend(handles=[red_line, blue_line])
pyplot.title('Voorspelling verkoop wijn 1972')
pyplot.ylabel('Hoeveelheid')
pyplot.xlabel('Maand')
pyplot.show()
def __init__(self, model_folder_abs_path: str):
self._model_folder_abs_path: str = model_folder_abs_path
if not os.path.exists(self._model_folder_abs_path):
os.makedirs(self._model_folder_abs_path)
model_file_abs_path = self._get_model_abs_file_path()
model_meta_data_file_abs_path = self._get_model_meta_data_abs_file_path(
)
if os.path.exists(model_file_abs_path) and os.path.exists(
model_meta_data_file_abs_path):
self._arima_model: ARIMAResults = ARIMAResults.load(
model_file_abs_path)
with open(model_meta_data_file_abs_path) as file_meta_data:
self._meta_data = json.load(file_meta_data)
else:
self._arima_model: ARIMAResults = None
self._meta_data = None
def predictFuture():
series = validate.getdatafile()
months_in_year = 12
model_fit = ARIMAResults.load(variables.model)
bias = numpy.load(variables.bias)
yhat = float(model_fit.forecast()[0])
yhat = bias + inverse_difference(series.values, yhat, months_in_year)
print('Predicted: %.3f' % yhat)
pyplot.plot(series)
pyplot.title('Lijn diagram tot aan voorspelling')
pyplot.show()
prediction = pd.DataFrame(yhat)
prediction.to_csv(variables.predictionSave,
mode='a',
sep=',',
header=False)
prediction.to_csv(variables.datafileloc, mode='a', header=False)
def validate_model(X, Y, arima_Order):
X = X.values.astype('float32')
Y = Y.values.astype('float32')
history = [x for x in X]
#load model
model_fit = ARIMAResults.load('model.pkl')
bias = numpy.load('model_bias.npy')
#Make first prediction
predictions = list()
yhat = bias + float(model_fit.forecast()[0])
predictions.append(yhat)
history.append(Y[0])
print('\nPrediction: ', yhat, ' Expected: ', Y[0])
#Rolling forecasts
for i in range(1, len(Y)):
#Make predictions
model = ARIMA(history, arima_Order)
model_fit = model.fit(trend='nc', disp=0)
yhat = bias + float(model_fit.forecast()[0])
predictions.append(yhat)
#Observations
obs = Y[i]
history.append(obs)
print('Prediction: ', yhat, ' Expected: ', obs)
#Reporting Performance
mse = mean_squared_error(Y, predictions)
rmse = sqrt(mse)
"""
print("\n Validation X: ",X)
print("\n Validation Y: ",Y)
print("\n Validation History: ",history)
print("\n Validation Predictions: ",predictions)
"""
pyplot.plot(Y)
pyplot.plot(predictions, color='red')
pyplot.show()
print('\nRMSE: ', rmse)
return
def predict():
try:
months = int(ery_monts.get())
if months <= 0:
tkMessageBox.showinfo("Error",
"Months should be greater than zero")
else:
dataset = Series.from_csv('dataset_training.csv')
X = dataset.values.astype('float32')
history = [x for x in X]
months_in_year = 12
model_fit = ARIMAResults.load('sales_model.pkl')
bias = numpy.load('model_bias.npy')
predictions = list()
yhat = float(model_fit.forecast()[0])
yhat = bias + inverse_difference(history, yhat, months_in_year)
predictions.append(yhat)
history.append(X[0])
for i in range(0, months):
iteration = months
diff = difference(history, iteration)
# predict here
model = ARIMA(diff, order=(0, 0, 1))
model_fit = model.fit(trend='nc', disp=0)
yhat = model_fit.forecast()[0]
yhat = bias + inverse_difference(history, yhat, iteration)
#add predicted data in predictions list to plot graph
predictions.append(yhat)
#add predicted data to history
#which helps to improve accuracy while predict future
history.append(yhat)
print("Prediction> " + str(yhat))
pyplot.figure(num='Predicted Results')
pyplot.plot(predictions, color='red')
pyplot.show()
except Exception as e:
tkMessageBox.showinfo("Error", "invalid month")
def main():
data = pd.read_csv("./query_large.csv", sep=",")
np_date = ["" for i in range(len(data))]
data = data[296:]
data = data.iloc[::-1]
for i, item in enumerate(data["time"]):
np_date[i] = datetime.strptime(item[:-5], '%Y-%m-%dT%H:%M:%S')
X = np.array(data["mag"])
for i in range(len(X)):
if X[i] >= 5:
X = X[i:]
break
count = 1
ans = []
new_data = []
for i in range(len(X)):
if X[i] < 5:
#print('in if ' + str( X[i]))
count = count + 1
else:
# print('in else ' + str( X[i]))
# print('appended '+ str(count))
ans.append(count)
count = 0
#new_data.append(data["time"][i])
data_f = pd.DataFrame(data=ans, columns=['timeSinceLast'])
dataset = data_f
model = sm.tsa.statespace.SARIMAX(dataset, order=(5, 0, 1))
model_fit = model.fit(disp=0)
model_fit.save('arima_nowcasting.pkl')
model = ARIMAResults.load('arima_nowcasting.pkl')
start_index = int(sys.argv[1])
end_index = int(sys.argv[2])
forecast = model.predict(start=start_index, end=end_index)
print(forecast)
plt.scatter(forecast.index.tolist(), forecast.values)
def recursive_test(data, arima_Order, numOfPredictions):
def make_predictions(xList, yList, model, bias, numOfPredictions):
count = 0
while count < numOfPredictions:
model = ARIMA(xList, arima_Order)
model_fit = model.fit(trend='nc', disp=0)
prdct = bias + float(model_fit.forecast()[0])
xList.append(prdct[0])
print("Prediction ", count, " : ", prdct[0])
yList.append(prdct[0])
count = count + 1
return yList
X = data.values.astype('float32')
orig = X.tolist()
xList = X.tolist()
yList = []
model_fit = ARIMAResults.load('model.pkl')
bias = numpy.load('model_bias.npy')
predictions = make_predictions(xList, yList, model_fit, bias,
numOfPredictions)
"""
print("\n xList:")
print(xList)
print("\n yList:")
print(yList)
print("\n orig:")
print(orig)
"""
pyplot.plot(orig, color='blue')
pyplot.plot(xList, color='red')
#pyplot.plot(predictions, color = 'green')
pyplot.show()
return
def test_ARIMA():
fited_model = ARIMAResults.load('ARIMA_best')
ar_coef, ma_coef = fited_model.arparams, fited_model.maparams
resid = fited_model.resid
ar_num, ma_num = ar_coef.size, ma_coef.size
with open('test_data.json', 'r') as f:
test_data = json.load(f)
rmse_sum, mae_sum, mape_sum = 0, 0, 0
skip_mape_count = 0
for data in tqdm(test_data):
history = []
label = []
pred = []
for index, d in enumerate(data['data']):
if index > ar_num:
label.append(d[1])
cur_resid = np.random.choice(resid, ma_num)
diff = difference(history)
yhat = history[-1] + predict(ar_coef, diff) + predict(
ma_coef, cur_resid)
pred.append(yhat)
history.append(d[1])
label = np.array(label)
pred = np.array(pred)
rmse = np.sqrt(np.mean(np.square(label - pred)))
mae = np.mean(np.abs(label - pred))
mape_mask = label > 1
mape = np.sum(np.abs(label - pred) / (label + 0.001) * mape_mask)
mape_count = np.sum(mape_mask)
if mape_count != 0:
mape = mape / np.sum(mape_mask)
mape_sum += mape
else:
skip_mape_count += 1
rmse_sum += rmse
mae_sum += mae
print('RMSE is {:.3f}'.format(rmse_sum / len(test_data)))
print('MAE is {:.3f}'.format(mae_sum / len(test_data)))
print('MAPE is {:.5f}'.format(mape_sum /
(len(test_data) - skip_mape_count)))
def validate_model(self,
validation_timeseries_series,
timeseries_series,
fitted_model_name,
differencing_interval=1):
timeseries_values = timeseries_series.values.astype('float32')
history = [x for x in timeseries_values]
validation_timeseries_values = validation_timeseries_series.values.astype('float32')
model_fit = ARIMAResults.load(fitted_model_name + '.pkl')
bias = np.load(fitted_model_name + '_bias.npy')
predictions = list()
yhat = float(model_fit.forecast()[0])
yhat = bias + self.reverse_difference_decomposition(history, yhat, differencing_interval)
predictions.append(yhat)
history.append(validation_timeseries_values[0])
print ('>Predicted=%.6f, Expected=%6.f' % (yhat, validation_timeseries_values[0]))
for i in range(1, len(validation_timeseries_values)):
diff = self.difference_composition(history, differencing_interval)
# predict
model = ARIMA(diff, order=self.get_arima_order() )
model_fit = model.fit(trend='nc', disp=0)
yhat = model_fit.forecast()[0]
yhat = bias + self.reverse_difference_decomposition(history, yhat, differencing_interval)
predictions.append(yhat)
# observation
obs = validation_timeseries_values[i]
history.append(obs)
print ('>Predicted=%.6f, Expected=%6.f' % (yhat, obs))
self.validation_dataset_predictions = predictions
self.validation_dataset_history = history
mse = mean_squared_error(validation_timeseries_values, predictions)
rmse = sqrt(mse)
return rmse
def cities():
start = request.args.get('start')
end = request.args.get('end')
rows = CityQuantity.query.join(City).with_entities(
City.name, CityQuantity.date_occurrence, CityQuantity.theft).filter(
CityQuantity.date_occurrence >= start).filter(
CityQuantity.date_occurrence <= end).all()
values = __transform(rows)
if datetime.strptime(start, '%Y-%m-%d') >= datetime.strptime(
'2018-01-01', '%Y-%m-%d'):
loaded = ARIMAResults.load(ROOT + 'ssp/v1/cities.pkl')
d = pandas.date_range(start='1/1/2018', end='12/1/2018', freq='MS')
d = d.format(formatter=lambda current: current.strftime('%Y-%m'))
x = [int(round(x)) for x in loaded.forecast(steps=12)[0]]
total = sum(x)
values["labels"] = d
values["total"] = values["total"] + total
values["data"].append({
"values": x,
"label": "Goiânia Previsão",
"total": total
})
return jsonify(values)
def main():
data = pd.read_csv("./query_large.csv",
sep=",",
parse_dates=['time'],
index_col='time',
squeeze=True) #, date_parser=parser)
fit = data['mag']
model = sm.tsa.statespace.SARIMAX(fit, order=(1, 0, 1))
model_fit = model.fit(disp=0)
residuals = DataFrame(model_fit.resid)
model_fit.save('arima_normal.pkl')
timestamp = lambda s: datetime.strptime(s, "%d/%m/%Y")
model = ARIMAResults.load('arima_normal.pkl')
start_index = int(sys.argv[1])
end_index = start_index + 6 #datetime(1925, 12, 26)
forecast = model.predict(start=start_index, end=end_index)
print(forecast)
for i in range(interval, len(dataset)):
value = dataset[i] - dataset[i - interval]
diff.append(value)
return diff
# invert differenced value
def inverse_difference(history, yhat, interval=1):
return yhat + history[-interval]
# load and prepare datasets
dataset = Series.from_csv('trainsetar1.csv')
X = dataset.values.astype('float32')
history = [x for x in X]
months_in_year = 12
validation = Series.from_csv('testsetar1.csv')
y = validation.values.astype('float32')
# load model
model_fit = ARIMAResults.load('model1.pkl')
bias = numpy.load('model_bias1.npy')
# make first prediction
predictions = list()
yhat = float(model_fit.forecast()[0])
yhat = bias + inverse_difference(history, yhat, months_in_year)
predictions.append(yhat)
history.append(y[0])
print('>Predicted=%.d, Expected=%.d' % (yhat, y[0]))
# rolling forecasts
for i in range(1, len(y)):
# difference data
months_in_year = 12
diff = difference(history, months_in_year)
# predict
model = ARIMA(diff, order=(0,0,1))
def test():
# load model
model_fit = ARIMAResults.load('model.pkl')
forecast = model_fit.forecast(steps=7)[0]
print(forecast)
def prediction():
model_fit = ARIMAResults.load('model.pkl')
bias = np.load('model_bias.npy')
yhat = bias + float(model_fit.forecast()[0])
print('Predicted: %.3f' % yhat)
def load_models(self):
for i in self.describe:
self.describe[i]['model'] = ARIMAResults.load(
f'{self.model_path}/model_{i}.pkl')