def train_predict():
"""Train and predict time series data"""
# Load command line arguments
train_file = sys.argv[1]
parameter_file = sys.argv[2]
# Load training parameters
params = json.loads(open(parameter_file).read())
# Load time series dataset, and split it into train and test
x_train, y_train, x_test, y_test, x_test_raw, y_test_raw,\
last_window_raw, last_window = data_helper.load_timeseries(train_file, params)
# Build RNN (LSTM) model
lstm_layer = [1, params['window_size'], params['hidden_unit'], 1]
model = build_model.rnn_lstm(lstm_layer, params)
# Train RNN (LSTM) model with train set
model.fit(x_train,
y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
validation_split=params['validation_split'])
# Check the model against test set
predicted = build_model.predict_next_timestamp(model, x_test)
predicted_raw = []
for i in range(len(x_test_raw)):
predicted_raw.append((predicted[i] + 1) * x_test_raw[i][0])
# Plot graph: predicted VS actual
plt.subplot(111)
plt.plot(predicted_raw, label='Actual')
plt.plot(y_test_raw, label='Predicted')
plt.legend()
plt.show()
# Predict next time stamp
next_timestamp = build_model.predict_next_timestamp(model, last_window)
next_timestamp_raw = (next_timestamp[0] + 1) * last_window_raw[0][0]
print('The next time stamp forecasting is: {}'.format(next_timestamp_raw))
def predict(data, model, number_of_predictions):
parameter_file = 'training_config.json'
params = json.loads(open(parameter_file).read())
predicted_values = []
for i in range(number_of_predictions):
x_train, y_train, x_test, y_test, x_test_raw, y_test_raw, last_window_raw, last_window = data_helper.load_timeseries(
data, params)
next_timestamp = model_helper.predict_next_timestamp(
model, last_window)
next_timestamp_raw = (next_timestamp[0] + 1) * last_window_raw[0][0]
print('#{}#The next time stamp forecasting is: {}'.format(
i + 1, next_timestamp_raw))
predicted_values.append(next_timestamp_raw)
np_pred = np.array([next_timestamp_raw])
data = np.append(data, np_pred)
def train(data, model_file, model_weights_file):
parameter_file = 'training_config.json'
params = json.loads(open(parameter_file).read())
x_train, y_train, x_test, y_test, x_test_raw, y_test_raw, last_window_raw, last_window = data_helper.load_timeseries(
data, params)
model_file_path = Path(model_file)
if model_file_path.is_file():
print('Existing trained model found.')
model = model_helper.load_model(model_file, model_weights_file)
else:
print('Creating a new model.')
lstm_layer = [1, params['window_size'], params['hidden_unit'], 1]
model = model_helper.rnn_lstm(lstm_layer, params)
model.fit(x_train,
y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
validation_split=params['validation_split'],
verbose=1)
predicted = model_helper.predict_next_timestamp(model, x_test)
predicted_raw = []
for i in range(len(x_test_raw)):
predicted_raw.append((predicted[i] + 1) * x_test_raw[i][0])
# serialize model to JSON
model_json = model.to_json()
with open(model_file, 'w') as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights(model_weights_file)
print("Saved model to disk")
def train_predict():
"""Train and predict time series data"""
# Load command line arguments
train_file = sys.argv[1]
parameter_file = sys.argv[2]
# Load training parameters
params = json.loads(open(parameter_file).read())
# print(params)
# print('================')
for q in range(29):
params["window_size"] = q + 1
# Load time series dataset, and split it into train and test
x_train, y_train, x_test, y_test, x_test_raw, y_test_raw,\
last_window_raw, last_window = data_helper.load_timeseries(train_file, params)
# Build RNN (FFNN) model
FFNN_layer = [1, params['window_size'], params['hidden_unit'], 1]
print(FFNN_layer)
print('================')
model = build_model.rnn_FFNN(FFNN_layer, params)
# Train RNN (FFNN) model with train set
model.fit(x_train,
y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
validation_split=params['validation_split'])
# Check the model against test set
predicted = build_model.predict_next_timestamp(model, x_test)
predicted_raw = []
RMSE_result_raw = []
for i in range(len(x_test_raw)):
predicted_raw.append((predicted[i] + 1) * x_test_raw[i][0])
RMSE_result_raw.append((y_test_raw[i] + 1) -
(predicted_raw[i] + 1))
#draw_xticks
#data*0.2
x = []
my_xticks = []
for o in range(10):
x.append((4000 / 10) * (o + 1))
my_xticks.append((2008 + o))
# Plot graph: predicted VS actual
plt.figure(facecolor='white')
plt.subplot(111)
plt.plot(predicted_raw, color='red', label='Actual')
plt.plot(y_test_raw, color='blue', label='Predicted')
plt.xticks(x, my_xticks)
plt.title('predicted VS actual')
#plt.show()
plt.savefig("p-predicted/predicted-" + str(q + 1) + ".png")
# print('================')
# print(predicted_raw)
# print(y_test_raw)
# print(predicted_raw.shape)
# print(y_test_raw.shape)
MAPE = (sum((predicted_raw - y_test_raw) / len(predicted_raw)) *
100) / len(predicted_raw)
# print(MAPE)
# np.savetxt('MAPE', MAPE)
# print('================')
# print(RMSE_result_raw)
# print(predicted_raw)
# print(y_test_raw)
# print(type(RMSE_result_raw))
# print(type(predicted_raw))
# print(type(y_test_raw))
#RMSE
RMSE_result = np.sqrt(
sum((predicted_raw - y_test_raw)**2) / len(predicted_raw))
plt.figure(facecolor='white')
plt.plot(RMSE_result_raw, color='blue', label='RMSE_result')
# plt.plot(predicted_raw, color='red', label='predicted')
# plt.plot(y_test_raw, color='green', label='Original')
plt.ylabel('PM2.5-Value', fontsize=12)
plt.xlabel('Year', fontsize=12)
plt.xticks(x, my_xticks)
plt.title('RMSE: %.4f' % RMSE_result)
#plt.show()
plt.savefig("p-RMSE/draw_RMSE-" + str(q + 1) + ".png")
# Predict next time stamp
next_timestamp = build_model.predict_next_timestamp(model, last_window)
next_timestamp_raw = (next_timestamp[0] + 1) * last_window_raw[0][0]
print('The next time stamp forecasting is: {}'.format(
next_timestamp_raw))
#print(RMSE_result)
for i in range(15):
# print(RMSE_result)
# print(min_RMSE[i])
if RMSE_result < min_RMSE_value[i]:
min_RMSE[i] = q + 1
min_RMSE_value[i] = RMSE_result
min_next_temp[i] = next_timestamp_raw
MAPE_value[i] = MAPE
break
def train_predict():
"""Train and predict time series data"""
# Load command line arguments
start_time = sys.argv[1]
end_time = sys.argv[2]
#filename = sys.argv[1]
parameter_file = sys.argv[3]
train_file=pd.DataFrame()
train_file=data_processing.data_preprocessing(start_time,end_time)
train_file.to_csv('out_temp1.csv' , index =False)
x='out_temp1.csv'
# Load training parameters
params = json.loads(open(parameter_file).read())
# Load time series dataset, and split it into train and test
x_train, y_train, x_test, y_test, x_test_raw, y_test_raw,last_window_raw, last_window = data_helper.load_timeseries(x, params)
# Build RNN (LSTM) model
lstm_layer = [1, params['window_size'], params['hidden_unit'], 1]
model = build_model.rnn_lstm(lstm_layer, params)
# Train RNN (LSTM) model with train set
model.fit(
x_train,
y_train,
batch_size=params['batch_size'],
epochs=params['epochs'],
validation_split=params['validation_split'])
# Check the model against test set
predicted = build_model.predict_next_timestamp(model, x_test)
predicted_raw = []
for i in range(len(x_test_raw)):
predicted_raw.append((predicted[i] + 1) * x_test_raw[i][0])
# Plot graph: predicted VS actual
#plt.subplot(111)
#plt.plot(predicted_raw, label='Actual')
#plt.plot(y_test_raw, label='Predicted')
#plt.legend()
#plt.show()
#print(predicted_raw.dtype )
# Predict next time stamp
np.savetxt("y_test_raw1.csv",y_test_raw,delimiter=',')
np.savetxt("predicted_raw1.csv",predicted_raw,delimiter=',')
data_new =[]
for i in range(5) :
next_timestamp = build_model.predict_next_timestamp(model, last_window)
next_timestamp_raw = (next_timestamp[0] + 1) * last_window_raw[0][i]
data_new.append(format(next_timestamp))
print('The next time stamp forecasting is: {}'.format(next_timestamp_raw))
plt.plot(data_new)
plt.show()