def forecast_kMeans_NN(bld_name, load_weekday, n_train, n_lag, n_clusters):
n_days = int(load_weekday.size / T)
MAPE_sum_nn = 0.0
RMSPE_sum_nn = 0.0
for curr_day in range(n_train + n_lag, n_days-1):
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, T * n_lag))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row,:] = load_weekday[train_day * T : train_day * T + T]
X_train[row,:] = load_weekday[train_day * T - n_lag * T: train_day * T]
row += 1
# building test data
X_test = load_weekday[curr_day*T - n_lag*T: curr_day*T]
y_test = load_weekday[curr_day*T: curr_day *T + T]
# n_clusters = 5
kmeans = KMeans(n_clusters, random_state=0)
kmeans.fit(y_train.T)
labels = list(kmeans.labels_)
y_nn = np.zeros((T))
# cluster NN
for c in range(n_clusters):
cluster_idx = [i for i,x in enumerate(labels) if x == c]
cluster_train = []
for k in range(n_lag):
cluster_sub = [a+k*T for a in cluster_idx]
cluster_train.extend(cluster_sub)
X_train_c = X_train[:, cluster_train]
y_train_c = y_train[:, cluster_idx]
X_test_c = X_test[cluster_train]
nn = MLPRegressor(hidden_layer_sizes = (50, 50), activation = 'relu', max_iter = 10000)
nn.fit(X_train_c, y_train_c)
y_nn_c = nn.predict(X_test_c)
y_nn[cluster_idx] = y_nn_c
# statistics of Neural Network
MAPE_nn = predict_util.calMAPE(y_test, y_nn)
MAPE_sum_nn += MAPE_nn
RMSPE_nn = predict_util.calRMSPE(y_test, y_nn)
RMSPE_sum_nn += RMSPE_nn
days_sample = n_days - 1 - n_train - n_lag
MAPE_avg_nn = MAPE_sum_nn / days_sample
RMSPE_avg_nn = RMSPE_sum_nn / days_sample
return (MAPE_avg_nn, RMSPE_avg_nn)
def kNN_forecast(T, n_train, n_lag, load_data, minLoad, maxLoad):
(X_train, y_train) = kNN_historical(T, n_lag, n_train, sumLoad)
MAPE_sum = 0.0
RMSPE_sum = 0.0
#n_days = int(load_data.size / T)
n_days = 365
for d in range(n_train, n_days - 1):
X_test = np.zeros((1, n_lag * T))
X_test[0, :] = load_data[d * T - n_lag * T:d * T]
y_test = load_data[d * T:d * T + T]
# kNN
neigh = KNeighborsRegressor(n_neighbors=10, weights='distance')
neigh.fit(X_train, y_train)
y_test_2d = np.zeros((1, T))
y_test_2d[0, :] = y_test
y_pred = neigh.predict(X_test)
y_pred = y_pred * (maxLoad - minLoad) + minLoad
y_test = y_test * (maxLoad - minLoad) + minLoad
'''
# plot daily forecast
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test.flatten(), 'g')
plt.show()
'''
# update the training set
X_train = np.concatenate((X_train, X_test), axis=0)
y_train = np.concatenate((y_train, y_test_2d), axis=0)
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
# update error metric results
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
days_num = n_days - n_train
return (MAPE_sum / days_num, RMSPE_sum / days_num)
def forecast_bagging_NN(bld_name, load_weekday, n_train, n_lag, bag_num):
n_days = int(load_weekday.size / T)
MAPE_sum_nn = 0.0
RMSPE_sum_nn = 0.0
bag_size = int(n_train * 0.6)
for curr_day in range(n_train + n_lag, n_days - 1):
# bagging parameter
train_start = curr_day - n_train
for i in range(bag_num):
# random sampling
sample_day = np.random.randint(n_train, size=bag_size)
sample_day += train_start
# building training data
y_train = np.zeros((bag_size, T))
X_train = np.zeros((bag_size, T * n_lag))
for row in range(bag_size):
y_train[row, :] = load_weekday[sample_day[row] *
T:sample_day[row] * T + T]
X_train[row, :] = load_weekday[sample_day[row] * T -
n_lag * T:sample_day[row] * T]
# building test data
X_test = np.reshape(
load_weekday[curr_day * T - n_lag * T:curr_day * T], (1, -1))
y_test = load_weekday[curr_day * T:curr_day * T + T]
nn = MLPRegressor(hidden_layer_sizes=(50, 50),
activation='relu',
max_iter=10000)
nn.fit(X_train, y_train)
y_nn = nn.predict(X_test)
MAPE_nn = predict_util.calMAPE(y_test, y_nn)
MAPE_sum_nn += MAPE_nn
RMSPE_nn = predict_util.calRMSPE(y_test, y_nn)
RMSPE_sum_nn += RMSPE_nn
days_sample = n_days - 1 - n_train - n_lag
MAPE_avg_nn = MAPE_sum_nn / (days_sample * bag_num)
RMSPE_avg_nn = RMSPE_sum_nn / (days_sample * bag_num)
return (MAPE_avg_nn, RMSPE_avg_nn)
def SVR_forecast(n_lag, T, X_train, y_train, X_test, y_test, maxLoad, minLoad):
# SVR regressor
clf = SVR(C=10, epsilon=0.01)
# stack SVRs together to forecast multiple outputs
multiSVR = MultiOutputRegressor(clf)
################## prediction #########################################
test_days = X_test.shape[0]
MAPE_sum = 0
RMSPE_sum = 0
for d in range(test_days):
# train SVR model
multiSVR.fit(X_train, y_train)
# prepare test data
X_test_d = np.zeros((1, n_lag * T))
X_test_d[0,:] = X_test[d,:]
y_test_d = y_test[d,:]
y_pred = multiSVR.predict(X_test_d)
y_pred = y_pred * (maxLoad - minLoad) + minLoad
y_test_n = y_test_d * (maxLoad - minLoad) + minLoad
mape = predict_util.calMAPE(y_test_n, y_pred)
rmspe = predict_util.calRMSPE(y_test_n, y_pred)
# update error metric results
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
# update training set
X_train = np.concatenate((X_train, X_test_d), axis = 0)
y_train = np.vstack([y_train, y_test_d])
return (MAPE_sum / test_days, RMSPE_sum / test_days, test_days)
def RNN_LSTM(load, curr_day):
# Network Parameters
num_input = 4 # MNIST data input (img shape: 28*28)
T = 24
num_hidden = 4 # hidden layer num of features
n_train = 5
n_valid = 1
n_lag = 2
timesteps = T * n_lag # timesteps
# tf Graph input
X = tf.placeholder("float", [None, timesteps, num_input])
Y = tf.placeholder("float", [None, T])
# Define weights
weights = tf.Variable(2 * tf.random_normal([timesteps * num_hidden, T]))
biases = tf.Variable(tf.random_normal([T]))
###############################################################################
# add the RNN network
prediction = RNN(X, weights, biases, num_hidden, timesteps, num_input)
# Define loss and optimizer
loss = T * tf.reduce_mean(tf.square(Y - prediction))
loss += 1e-2 * (tf.nn.l2_loss(weights) + tf.nn.l2_loss(biases))
train_op = tf.train.AdamOptimizer(learning_rate=0.1).minimize(loss)
#train_op = tf.train.AdagradOptimizer(learning_rate = 0.1).minimize(loss)
# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()
# Start training
sess = tf.Session()
# Run the initializer
sess.run(init)
# generate the training, validation and test data
(X_train, y_train, X_valid, y_valid, X_test, y_test, min_load,
max_load) = genData_W(load, temperature, humidity, pressure, n_train,
n_valid, n_lag, T, curr_day)
# Training Parameters
training_steps = 10000 # maximum step of training
display_step = 100 # display loss function
last_loss = 10000.0 # init the loss
epsilon = 1e-5 # stopping criterion
step = 0 # training step
while (step < training_steps):
# X_train = X_train.reshape((n_train, timesteps*num_input))
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: X_train, Y: y_train})
# Calculate loss on validation set
#X_valid = X_valid.reshape((n_valid, timesteps, num_input))
l = sess.run(loss, feed_dict={X: X_valid, Y: y_valid})
if ((step + 1) % display_step == 0):
print('iteration number %d, loss is %2f' % (step + 1, l))
if (abs(last_loss - l) < epsilon):
print('training stopped at: iteration number %d, loss is %2f' %
(step + 1, l))
break
else:
last_loss = l
step += 1
# predict and compare with test output
#X_test = X_test.reshape((1, timesteps, num_input))
y_pred = prediction.eval(session=sess, feed_dict={X: X_test})
y_pred = y_pred * (max_load - min_load) + min_load
y_test = y_test * (max_load - min_load) + min_load
# error metrics
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
# plot forecast with result
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test.flatten(), 'g')
red_patch = mpatches.Patch(color='red', label='prediction')
green_patch = mpatches.Patch(color='green', label='actual')
plt.legend(handles=[red_patch, green_patch])
plt.show()
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
tf.reset_default_graph()
sess.close()
return (mape, rmspe)
def NN_forecast_weather(load_weekday, n_train, n_lag, T, temperature, humidity, pressure):
############################ Iteration Parameter ##########################
# maximum iteration
Max_iter = 20000
# stopping criteria
epsilon = 1e-5
last_l = 10000
# set of features
set_fea = 4
# number of neurons in hidden layers
N_neuron = 50
############################ TensorFlow ###################################
# place holders
xs = tf.placeholder(tf.float32, [None, T * n_lag * set_fea])
ys = tf.placeholder(tf.float32, [None, T])
# hidden layers
(l1, w1, b1) = add_layer(xs, T * n_lag * set_fea, N_neuron, activation_function=tf.nn.relu)
(l2, w2, b2) = add_layer(l1, N_neuron, N_neuron, activation_function=tf.nn.tanh)
# output layer
(prediction, wo, bo) = add_layer(l2, N_neuron, T, None)
# loss function, RMSPE
#loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), 1))
loss = T * tf.reduce_mean(tf.square(ys - prediction) )
loss += 1e-2 * ( tf.nn.l2_loss(w1) + tf.nn.l2_loss(b1) + tf.nn.l2_loss(wo) + tf.nn.l2_loss(bo) )
loss += 1e-2 * ( tf.nn.l2_loss(w2) + tf.nn.l2_loss(b2) )
# training step
train_step = tf.train.AdamOptimizer().minimize(loss)
init = tf.global_variables_initializer()
# run
sess = tf.Session()
n_days = int(load_weekday.size / T)
################## generate data ##########################################
MAPE_sum = 0.0
RMSPE_sum = 0.0
for curr_day in range(n_train + n_lag, n_days-1):
# init.
sess.run(init)
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, T * n_lag * set_fea))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row,:] = load_weekday[train_day * T : train_day * T + T]
X_train[row,0*T*n_lag:1*T*n_lag] = load_weekday[train_day * T - n_lag * T: train_day * T]
X_train[row,1*T*n_lag:2*T*n_lag] = temperature[train_day * T - n_lag * T: train_day * T]
X_train[row,2*T*n_lag:3*T*n_lag] = humidity[train_day * T - n_lag * T: train_day * T]
X_train[row,3*T*n_lag:4*T*n_lag] = pressure[train_day * T - n_lag * T: train_day * T]
row += 1
max_load = np.max(X_train[:, 0*T*n_lag:1*T*n_lag])
min_load = np.min(X_train[:, 0*T*n_lag:1*T*n_lag])
# building test data
X_test = np.zeros((1, T * n_lag * set_fea))
X_test[0, 0*T*n_lag:1*T*n_lag] = load_weekday[curr_day*T - n_lag*T: curr_day*T]
X_test[0, 1*T*n_lag:2*T*n_lag] = temperature[curr_day*T - n_lag*T: curr_day*T]
X_test[0, 2*T*n_lag:3*T*n_lag] = humidity[curr_day*T - n_lag*T: curr_day*T]
X_test[0, 3*T*n_lag:4*T*n_lag] = pressure[curr_day*T - n_lag*T: curr_day*T]
y_test = load_weekday[curr_day*T: curr_day *T + T]
X_train[:, 0*T*n_lag:1*T*n_lag] = (X_train[:, 0*T*n_lag:1*T*n_lag]-min_load) / (max_load - min_load)
y_train = (y_train-min_load) / (max_load - min_load)
X_test[:, 0*T*n_lag:1*T*n_lag] = (X_test[:, 0*T*n_lag:1*T*n_lag]-min_load) / (max_load - min_load)
# training
i = 0
while (i < Max_iter):
# training
(t_step, l) = sess.run([train_step, loss], feed_dict={xs: X_train, ys: y_train})
if(abs(last_l - l) < epsilon and i > 8000):
break
else:
last_l = l
i = i+1
#y_ = prediction.eval(session = sess, feed_dict={xs: X_train})
y_pred = prediction.eval(session = sess, feed_dict={xs: X_test})
y_pred = y_pred * (max_load - min_load) + min_load
# plot daily forecast
'''
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test.flatten(), 'g')
plt.show()
'''
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
# update error metric results
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
# close session
tf.reset_default_graph() # reset the graph
sess.close()
days_sample = n_days - 1 - n_train - n_lag
return (MAPE_sum / days_sample, RMSPE_sum / days_sample)
def CNN_forecast(n_lag, T, X_train, y_train, X_test, y_test, maxLoad, minLoad):
############################ TensorFlow ###################################
# place holders
xs = tf.placeholder(tf.float32, [None, T * n_lag])
ys = tf.placeholder(tf.float32, [None, T])
input_layer = tf.reshape(xs, [-1, T, n_lag, 1])
# Convolutional Layer #1
# Computes 32 features using a 5x5 filter with ReLU activation.
# Padding is added to preserve width and height.
# Input Tensor Shape: [batch_size, T, n_lag, 1]
# Output Tensor Shape: [batch_size, T, n_lag, 32]
conv1 = tf.layers.conv2d(
inputs=input_layer,
filters=64,
kernel_size=[2, 2],
padding="same",
activation=tf.nn.relu)
# Pooling Layer #1
# First max pooling layer with a 2x2 filter and stride of 2
# Input Tensor Shape: [batch_size, T, n_lag, 32]
# Output Tensor Shape: [batch_size, T/2, n_lag/2, 32]
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
pool1_flat = tf.reshape(pool1, [-1, T * n_lag * 16])
N_neuron = 50
# hidden layers
(l1, w1, b1) = add_layer(pool1_flat, T * n_lag * 16, N_neuron, activation_function=tf.nn.relu)
#(l2, w2, b2) = add_layer(l1, N_neuron, N_neuron, activation_function=tf.nn.tanh)
# output layer
(prediction, wo, bo) = add_layer(l1, N_neuron, T, None)
# loss function, RMSPE
#loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), 1))
loss = T * tf.reduce_mean(tf.square(ys - prediction) )
loss += 1e-2 * ( tf.nn.l2_loss(w1) + tf.nn.l2_loss(b1) + tf.nn.l2_loss(wo) + tf.nn.l2_loss(bo) )
#loss += 1e-3 * ( tf.nn.l2_loss(w2) + tf.nn.l2_loss(b2) )
# training step
train_step = tf.train.AdamOptimizer(learning_rate=0.01).minimize(loss)
#train_step = tf.train.AdagradOptimizer(learning_rate=1).minimize(loss)
init = tf.global_variables_initializer()
# run
sess = tf.Session()
############################ Iteration Parameter ##########################
# maximum iteration
Max_iter = 20000
# stopping criteria
epsilon = 1e-4
display_step = 100
# predict and compare with test output
test_days = X_test.shape[0]
MAPE_sum = 0
RMSPE_sum = 0
for d in range(test_days):
# init.
sess.run(init)
# training
last_loss = 100000
step = 0
while(step < Max_iter):
# Run optimization op (backprop)
(t_step, l) = sess.run([train_step, loss], feed_dict={xs: X_train, ys: y_train})
#if((step+1) % display_step == 0):
#print('iteration number %d, loss is %2f' % (step+1, l))
if(abs(last_loss - l) < epsilon ):
print('training stopped at: iteration number %d, loss is %2f' % (step+1, l))
break
else:
last_loss = l
step += 1
X_test_d = np.zeros((1, n_lag * T))
X_test_d[0,:] = X_test[d,:]
y_test_d = y_test[d,:]
y_pred = prediction.eval(session = sess, feed_dict={xs: X_test_d})
y_pred = y_pred * (maxLoad - minLoad) + minLoad
y_test_n = y_test_d * (maxLoad - minLoad) + minLoad
# error metrics
mape = predict_util.calMAPE(y_test_n, y_pred)
rmspe = predict_util.calRMSPE(y_test_n, y_pred)
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
'''
# plot forecast with result
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test_n.flatten(), 'g')
red_patch = mpatches.Patch(color='red', label='prediction')
green_patch = mpatches.Patch(color='green', label='actual')
plt.legend(handles=[red_patch, green_patch])
plt.show()
'''
tf.reset_default_graph()
sess.close()
return (MAPE_sum / test_days, RMSPE_sum / test_days, test_days)
def NN_forecast(n_lag, T, X_train, y_train, X_test, y_test, maxLoad, minLoad):
############################ Iteration Parameter ##########################
# maximum iteration
Max_iter = 20000
# stopping criteria
epsilon = 1e-4
last_l = 10000
############################ TensorFlow ###################################
# place holders
xs = tf.placeholder(tf.float32, [None, T * n_lag])
ys = tf.placeholder(tf.float32, [None, T])
N_neuron = 50
# hidden layers
(l1, w1, b1) = add_layer(xs,
T * n_lag,
N_neuron,
activation_function=tf.nn.relu)
(l2, w2, b2) = add_layer(l1,
N_neuron,
N_neuron,
activation_function=tf.nn.tanh)
# output layer
(prediction, wo, bo) = add_layer(l2, N_neuron, T, None)
# loss function, RMSPE
#loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), 1))
loss = T * tf.reduce_mean(tf.square(ys - prediction))
loss += 1e-1 * (tf.nn.l2_loss(w1) + tf.nn.l2_loss(b1) + tf.nn.l2_loss(wo) +
tf.nn.l2_loss(bo))
loss += 1e-1 * (tf.nn.l2_loss(w2) + tf.nn.l2_loss(b2))
# training step
train_step = tf.train.AdamOptimizer().minimize(loss)
init = tf.global_variables_initializer()
# run
sess = tf.Session()
# init.
training_size = 50
MAPE_sum = 0
RMSPE_sum = 0
test_days = X_test.shape[0]
if test_days == 0:
return (0.0, 0.0, 0)
for d in range(test_days):
sess.run(init)
################## training #########################################
i = 0
while (i < Max_iter):
# training
(t_step, l) = sess.run([train_step, loss],
feed_dict={
xs: X_train,
ys: y_train
})
if (abs(last_l - l) < epsilon):
break
else:
last_l = l
i = i + 1
################## prediction #########################################
X_test_d = np.zeros((1, n_lag * T))
X_test_d[0, :] = X_test[d, :]
y_test_d = y_test[d, :]
y_pred = prediction.eval(session=sess, feed_dict={xs: X_test_d})
y_pred = y_pred * (maxLoad - minLoad) + minLoad
y_test_n = y_test_d * (maxLoad - minLoad) + minLoad
'''
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test_n.flatten(), 'g')
plt.show()
'''
mape = predict_util.calMAPE(y_test_n, y_pred)
rmspe = predict_util.calRMSPE(y_test_n, y_pred)
# update error metric results
#print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
# update training set
X_train = np.concatenate((X_train, X_test_d), axis=0)
X_train = X_train[-training_size:, :]
y_train = np.vstack([y_train, y_test_d])
y_train = X_train[-training_size:, :]
# close session
tf.reset_default_graph() # reset the graph
sess.close()
return (MAPE_sum / test_days, RMSPE_sum / test_days, test_days)
def forecast(bld_name, load_weekday, n_train, n_lag):
n_days = int(load_weekday.size / T)
MAPE_sum_nn = 0.0
RMSPE_sum_nn = 0.0
MAPE_sum_rf = 0.0
RMSPE_sum_rf = 0.0
MAPE_sum_lr = 0.0
RMSPE_sum_lr = 0.0
for curr_day in range(n_train + n_lag, n_days-1):
print(curr_day)
# build training data
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, T * n_lag))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row,:] = load_weekday[train_day * T : train_day * T + T]
X_train[row,:] = load_weekday[train_day * T - n_lag * T: train_day * T]
row += 1
# building test data
X_test = load_weekday[curr_day*T - n_lag*T: curr_day*T]
y_test = load_weekday[curr_day*T: curr_day *T + T]
################### forecast ####################################
# suppress warnings
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
nn = MLPRegressor(hidden_layer_sizes = (50, 50), activation = 'relu', max_iter = 10000)
rf = RandomForestRegressor(n_estimators = 100)
lr = LinearRegression(fit_intercept = True, normalize = True)
rf.fit(X_train, y_train)
nn.fit(X_train, y_train)
lr.fit(X_train, y_train)
y_nn = nn.predict(X_test)
y_nn = y_nn.flatten()
y_rf = rf.predict(X_test)
y_rf = y_rf.flatten()
y_lr = lr.predict(X_test)
y_lr = y_lr.flatten()
'''
xaxis = range(T)
plt.figure(figsize=(18,10))
plt.plot(xaxis, y_test, 'r')
plt.plot(xaxis, y_rf, 'g')
plt.show()
'''
# statistics of Neural Network
MAPE_nn = predict_util.calMAPE(y_test, y_nn)
MAPE_sum_nn += MAPE_nn
RMSPE_nn = predict_util.calRMSPE(y_test, y_nn)
RMSPE_sum_nn += RMSPE_nn
# statistics of Random Forest
MAPE_rf = predict_util.calMAPE(y_test, y_rf)
MAPE_sum_rf += MAPE_rf
RMSPE_rf = predict_util.calRMSPE(y_test, y_rf)
RMSPE_sum_rf += RMSPE_rf
# statistics of Linear Regression
MAPE_lr = predict_util.calMAPE(y_test, y_lr)
MAPE_sum_lr += MAPE_lr
RMSPE_lr = predict_util.calRMSPE(y_test, y_lr)
RMSPE_sum_lr += RMSPE_lr
print(MAPE_nn, RMSPE_nn, MAPE_rf, RMSPE_rf, MAPE_lr, RMSPE_lr)
days_sample = n_days - 1 - n_train - n_lag
MAPE_avg_nn = MAPE_sum_nn / days_sample
RMSPE_avg_nn = RMSPE_sum_nn / days_sample
MAPE_avg_rf = MAPE_sum_rf / days_sample
RMSPE_avg_rf = RMSPE_sum_rf / days_sample
MAPE_avg_lr = MAPE_sum_lr / days_sample
RMSPE_avg_lr = RMSPE_sum_lr / days_sample
return (MAPE_avg_nn, RMSPE_avg_nn, MAPE_avg_rf, RMSPE_avg_rf, MAPE_avg_lr, RMSPE_avg_lr)
def NN_forecast(load_weekday, n_train, n_lag, T):
############################ TensorFlow ###################################
# place holders
xs = tf.placeholder(tf.float32, [None, T * n_lag])
ys = tf.placeholder(tf.float32, [None, T])
# 0. input layer
input_layer = tf.reshape(xs, [-1, T * n_lag, 1])
# 1. Convolutional Layer #1
# Computes 32 features using a 4X1 filter with ReLU activation.
# Padding is added to preserve width and height.
# Input Tensor Shape: [batch_size, T * n_lag, 1]
# Output Tensor Shape: [batch_size, T * n_lag, 32]
conv1 = tf.layers.conv1d(inputs=input_layer,
filters=32,
kernel_size=4,
padding="same",
activation=tf.nn.relu)
# 2. Pooling Layer #1
# First max pooling layer with a 2x2 filter and stride of 2
# Input Tensor Shape: [batch_size, T * n_lag, 32]
# Output Tensor Shape: [batch_size, T * n_lag / 2, 32]
pool1 = tf.layers.max_pooling1d(inputs=conv1, pool_size=2, strides=2)
pool1_flat = tf.reshape(pool1, [-1, T * n_lag * 16])
# 3. hidden layer (Full Connection Layer)
N_neuron = 50
(l1, w1, b1) = add_layer(pool1_flat,
T * n_lag * 16,
N_neuron,
activation_function=tf.nn.relu)
# 4. output layer
(prediction, wo, bo) = add_layer(l1, N_neuron, T, None)
# loss function, RMSE
loss = T * tf.reduce_mean(tf.square(ys - prediction))
loss += 1e-3 * (tf.nn.l2_loss(w1) + tf.nn.l2_loss(b1) + tf.nn.l2_loss(wo) +
tf.nn.l2_loss(bo))
# training step
train_step = tf.train.AdamOptimizer(learning_rate=0.01).minimize(loss)
init = tf.global_variables_initializer()
# run
sess = tf.Session()
# init.
#sess.run(init)
n_days = int(load_weekday.size / T)
################## generate data ##########################################
MAPE_sum = 0.0
RMSPE_sum = 0.0
for curr_day in range(n_train + n_lag, n_days - 1):
#init. network parameters
sess.run(init)
#### prepare training and test data ####
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, T * n_lag))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row, :] = load_weekday[train_day * T:train_day * T + T]
X_train[row, 0 * T * n_lag:1 * T *
n_lag] = load_weekday[train_day * T - n_lag * T:train_day *
T]
row += 1
max_load = np.max(X_train)
min_load = np.min(X_train)
# building test data
X_test = np.zeros((1, T * n_lag))
X_test[0, 0 * T * n_lag:1 * T *
n_lag] = load_weekday[curr_day * T - n_lag * T:curr_day * T]
y_test = load_weekday[curr_day * T:curr_day * T + T]
X_train = (X_train - min_load) / (max_load - min_load)
y_train = (y_train - min_load) / (max_load - min_load)
X_test = (X_test - min_load) / (max_load - min_load)
############################ Training ##########################
# maximum iteration
Max_iter = 20000
# stopping criteria
epsilon = 1e-4
last_l = 100000
display_step = 100
# training
i = 0
while (i < Max_iter):
# training
(t_step, l) = sess.run([train_step, loss],
feed_dict={
xs: X_train,
ys: y_train
})
#if((i+1) % display_step == 0):
#print('iteration number %d, loss is %2f' % (i+1, l))
if (abs(last_l - l) < epsilon):
break
else:
last_l = l
i = i + 1
# prediction
y_pred = prediction.eval(session=sess, feed_dict={xs: X_test})
y_pred = y_pred * (max_load - min_load) + min_load
# plot daily forecast
'''
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test.flatten(), 'g')
plt.show()
'''
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
# update error metric results
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
# close session
tf.reset_default_graph() # reset the graph
sess.close()
# calculate average
days_sample = n_days - 1 - n_train - n_lag
return (MAPE_sum / days_sample, RMSPE_sum / days_sample)
def RNN_LSTM(n_lag, T, X_train, y_train, X_test, y_test, maxLoad, minLoad):
num_hidden = 1 # hidden layer num of features
num_input = 1 # number of inputs in each RNN cell
n_train = X_train.shape[0] # number of training samples
timesteps = T * n_lag # timesteps
# tf Graph input
X = tf.placeholder("float", [None, timesteps, num_input])
Y = tf.placeholder("float", [None, T])
# Define weights
weights = tf.Variable(2 * tf.random_normal([timesteps * num_hidden, T]))
biases = tf.Variable(tf.random_normal([T]))
###############################################################################
# add the RNN network
prediction = RNN(X, weights, biases, num_hidden, timesteps)
# Define loss and optimizer
loss = T * tf.reduce_mean(tf.square(Y - prediction))
loss += 1e-3 * (tf.nn.l2_loss(weights) + tf.nn.l2_loss(biases))
train_op = tf.train.AdamOptimizer(learning_rate=0.1).minimize(loss)
#train_op = tf.train.AdagradOptimizer(learning_rate = 0.1).minimize(loss)
# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()
# Start training
sess = tf.Session()
# Training Parameters
training_steps = 10000 # maximum step of training
#display_step = 100 # display loss function
epsilon = 1e-4 # stopping criterion
test_days = X_test.shape[0]
MAPE_sum = 0
RMSPE_sum = 0
# loop : iterate over days
for d in range(test_days):
# Run the initializer
sess.run(init)
# training model
last_loss = 10000.0 # init the loss
step = 0 # training step
while (step < training_steps):
X_train_r = X_train.reshape((n_train, timesteps, num_input))
# Run optimization op (backprop)
(t_step, l) = sess.run([train_op, loss],
feed_dict={
X: X_train_r,
Y: y_train
})
#if((step+1) % display_step == 0):
#print('iteration number %d, loss is %2f' % (step+1, l))
if (abs(last_loss - l) < epsilon):
print('training stopped at: iteration number %d, loss is %2f' %
(step + 1, l))
break
else:
last_loss = l
step += 1
# predict and compare with test output
X_test_d = np.zeros((1, n_lag * T))
X_test_d[0, :] = X_test[d, :]
y_test_d = y_test[d, :]
X_test_n = X_test_d.reshape((1, timesteps, num_input))
y_pred = prediction.eval(session=sess, feed_dict={X: X_test_n})
y_pred = y_pred * (maxLoad - minLoad) + minLoad
y_test_n = y_test_d * (maxLoad - minLoad) + minLoad
# update training set
X_train = np.concatenate((X_train, X_test_d), axis=0)
y_train = np.vstack([y_train, y_test_d])
n_train += 1
# error metrics
mape = predict_util.calMAPE(y_test_n, y_pred)
rmspe = predict_util.calRMSPE(y_test_n, y_pred)
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
# plot forecast with result
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test_n.flatten(), 'g')
red_patch = mpatches.Patch(color='red', label='prediction')
green_patch = mpatches.Patch(color='green', label='actual')
plt.legend(handles=[red_patch, green_patch])
plt.show()
tf.reset_default_graph()
sess.close()
return (MAPE_sum / test_days, RMSPE_sum / test_days, test_days)
def NN_forecast(bld_name, sess):
load_weekday = getWeekday.getWeekdayload(bld_name)
max_load = np.max(load_weekday)
n_days = int(load_weekday.size / T)
################## generate data ##########################################
MAPE_sum = 0.0
RMSPR_sum = 0.0
for curr_day in range(n_train + n_lag, n_days - 1):
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, T * n_lag))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row, :] = load_weekday[train_day * T:train_day * T + T]
X_train[row, 0 * T * n_lag:1 * T *
n_lag] = load_weekday[train_day * T - n_lag * T:train_day *
T]
row += 1
# building test data
X_test = np.zeros((1, T * n_lag))
X_test[0, 0 * T * n_lag:1 * T *
n_lag] = load_weekday[curr_day * T - n_lag * T:curr_day * T]
y_test = load_weekday[curr_day * T:curr_day * T + T]
X_train = X_train / max_load
y_train = y_train / max_load
X_test = X_test / max_load
y_test = y_test / max_load
# maximum iteration
Max_iter = 10000
# stopping criteria
epsilon = 1e-7
last_l = 10000
for i in range(Max_iter):
# training
(t_step, l) = sess.run([train_step, loss],
feed_dict={
xs: X_train,
ys: y_train
})
if (abs(last_l - l) < epsilon):
#print(i)
break
else:
last_l = l
# to see the step improvement
#print(sess.run(loss, feed_dict={xs: X_train, ys: y_train}))
#y_ = prediction.eval(session = sess, feed_dict={xs: X_train})
y_pred = prediction.eval(session=sess, feed_dict={xs: X_test})
# plot daily forecast
'''
T = 96
xaxis = range(T)
plt.plot(xaxis, y_pred.flatten(), 'r')
plt.plot(xaxis, y_test.flatten(), 'g')
plt.show()
'''
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
MAPE_sum += mape
RMSPR_sum += rmspe
days_sample = n_days - 1 - n_train - n_lag
return (MAPE_sum / days_sample, RMSPR_sum / days_sample)
def RNN_LSTM(bld_name, curr_day):
# Training Parameters
training_steps = 10000
display_step = 100
# Network Parameters
num_input = 1 # MNIST data input (img shape: 28*28)
T = 96
num_hidden = 1 # hidden layer num of features
n_train = 5
n_valid = 1
n_lag = 2
timesteps = T * n_lag # timesteps
# tf Graph input
X = tf.placeholder("float", [None, timesteps, num_input])
Y = tf.placeholder("float", [None, T])
# Define weights
weights = tf.Variable(tf.random_normal([T*n_lag, T]))
biases = tf.Variable(tf.random_normal([T]) )
###############################################################################
prediction = RNN(X, weights, biases, num_hidden, timesteps)
# Define loss and optimizer
loss = T * tf.reduce_mean(tf.square(Y - prediction) )
#loss += 1e-2 * ( tf.nn.l2_loss(weights) + tf.nn.l2_loss(biases) )
train_op = tf.train.AdamOptimizer(learning_rate = 0.1).minimize(loss)
# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()
# Start training
sess = tf.Session()
# Run the initializer
sess.run(init)
(X_train, y_train, X_valid, y_valid, X_test, y_test, min_load, max_load) = genData(bld_name, n_train, n_valid, n_lag, T, curr_day)
'''
for step in range(training_steps+1):
X_train = X_train.reshape((n_train, timesteps, num_input))
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: X_train, Y: y_train})
if step > 0 and step % display_step == 0:
# Calculate batch loss and accuracy
l = sess.run(loss, feed_dict={X: X_train, Y: y_train})
print('iteration number %d, loss is %2f' % (step, l))
'''
last_loss = 10000.0
epsilon = 1e-5
step = 0
while(step < training_steps):
X_train = X_train.reshape((n_train, timesteps, num_input))
# Run optimization op (backprop)
sess.run(train_op, feed_dict={X: X_train, Y: y_train})
# Calculate loss on validation set
X_valid = X_valid.reshape((n_valid, timesteps, num_input))
l = sess.run(loss, feed_dict={X: X_valid, Y: y_valid})
if((step+1) % display_step == 0):
print('iteration number %d, loss is %2f' % (step+1, l))
if(abs(last_loss - l) < epsilon ):
print('training stopped at: iteration number %d, loss is %2f' % (step+1, l))
break
else:
last_loss = l
step += 1
X_test = X_test.reshape((1, timesteps, num_input))
y_pred = prediction.eval(session = sess, feed_dict={X: X_test})
y_pred = y_pred * (max_load - min_load) + min_load
y_test = y_test * (max_load - min_load) + min_load
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
'''
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test.flatten(), 'g')
plt.show()
'''
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
tf.reset_default_graph()
sess.close()
return (mape, rmspe)
def NN_forecast(bld_name, n_train, n_lag, T):
############################ Iteration Parameter ##########################
# maximum iteration
Max_iter = 20000
# stopping criteria
epsilon = 1e-5
last_l = 10000
############################ TensorFlow ###################################
# place holders
xs = tf.placeholder(tf.float32, [None, T * n_lag])
ys = tf.placeholder(tf.float32, [None, T])
N_neuron = 50
# hidden layers
(l1, w1, b1) = add_layer(xs, T * n_lag, N_neuron, activation_function=tf.nn.relu)
(l2, w2, b2) = add_layer(l1, N_neuron, N_neuron, activation_function=tf.nn.tanh)
# output layer
(prediction, wo, bo) = add_layer(l2, N_neuron, T, None)
# loss function, RMSPE
#loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), 1))
loss = T * tf.reduce_mean(tf.square(ys - prediction) )
loss += 1e-2 * ( tf.nn.l2_loss(w1) + tf.nn.l2_loss(b1) + tf.nn.l2_loss(wo) + tf.nn.l2_loss(bo) )
loss += 1e-2 * ( tf.nn.l2_loss(w2) + tf.nn.l2_loss(b2) )
# training step
train_step = tf.train.AdamOptimizer().minimize(loss)
# init.
init = tf.global_variables_initializer()
# run
sess = tf.Session()
sess.run(init)
###########################################################################
load_weekday = getWeekday.getWeekdayload(bld_name)
max_load = np.max(load_weekday)
#max_load = 1
n_days = int(load_weekday.size / T)
################## generate data ##########################################
MAPE_sum = 0.0
RMSPR_sum = 0.0
for curr_day in range(n_train + n_lag, n_days-1):
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, T * n_lag))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row,:] = load_weekday[train_day * T : train_day * T + T]
X_train[row,0*T*n_lag:1*T*n_lag] = load_weekday[train_day * T - n_lag * T: train_day * T]
row += 1
max_load = np.max(X_train)
min_load = np.min(X_train)
# building test data
X_test = np.zeros((1, T * n_lag))
X_test[0, 0*T*n_lag:1*T*n_lag] = load_weekday[curr_day*T - n_lag*T: curr_day*T]
y_test = load_weekday[curr_day*T: curr_day *T + T]
X_train = (X_train-min_load) / (max_load - min_load)
y_train = (y_train-min_load) / (max_load - min_load)
X_test = (X_test-min_load) / (max_load - min_load)
# training
i = 0
while (i < Max_iter):
# training
(t_step, l) = sess.run([train_step, loss], feed_dict={xs: X_train, ys: y_train})
if(abs(last_l - l) < epsilon):
break
else:
last_l = l
i = i+1
#y_ = prediction.eval(session = sess, feed_dict={xs: X_train})
y_pred = prediction.eval(session = sess, feed_dict={xs: X_test})
y_pred = y_pred * (max_load - min_load) + min_load
# plot daily forecast
'''
xaxis = range(T)
plt.plot(xaxis, y_pred.flatten(), 'r')
plt.plot(xaxis, y_test.flatten(), 'g')
plt.show()
'''
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
# update error metric results
#print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPR_sum += rmspe
(X_train, y_train, X_valid, y_valid, X_test,
y_test) = genTrainValidTest.genData(sumLoad, n_train, n_valid, n_lag,
T, d)
max_load = np.max(X_train)
min_load = np.min(X_train)
X_train = (X_train - min_load) / (max_load - min_load)
y_train = (y_train - min_load) / (max_load - min_load)
X_test = (X_test - min_load) / (max_load - min_load)
rf = RandomForestRegressor(n_estimators=100)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)
y_pred = y_pred * (max_load - min_load) + min_load
mape = predict_util.calMAPE(y_test, y_pred)
rmspe = predict_util.calRMSPE(y_test, y_pred)
# update error metric results
print('MAPE: %.2f, RMSPE: %.2f' % (mape, rmspe))
MAPE_sum += mape
RMSPE_sum += rmspe
# plot (make this one module)
xaxis = range(T)
plt.step(xaxis, y_pred.flatten(), 'r')
plt.step(xaxis, y_test.flatten(), 'g')
red_patch = mpatches.Patch(color='red', label='prediction')
green_patch = mpatches.Patch(color='green', label='actual')
plt.legend(handles=[red_patch, green_patch])
plt.show()
def forecast_multifeather(bld_name, load_weekday, n_train, n_lag, Temp_weekday,
Huminity_weekday, WindSpeed_weekday, Day_period):
n_days = int(load_weekday.size / T)
MAPE_sum_nn = 0.0
RMSPE_sum_nn = 0.0
MAPE_sum_rf = 0.0
RMSPE_sum_rf = 0.0
MAPE_sum_lr = 0.0
RMSPE_sum_lr = 0.0
# 5 set of features
# (1) load
# (2) temperature
# (3) huminity
# (4) windspeed
# (5) day period
for curr_day in range(n_train + n_lag, n_days - 1):
# build training data
y_train = np.zeros((n_train, T))
X_train = np.zeros((n_train, 5 * T * n_lag))
row = 0
for train_day in range(curr_day - n_train, curr_day):
y_train[row, :] = load_weekday[train_day * T:train_day * T + T]
X_train[row, 0 * T * n_lag:1 * T *
n_lag] = load_weekday[train_day * T - n_lag * T:train_day *
T]
X_train[row, 1 * T * n_lag:2 * T *
n_lag] = Temp_weekday[train_day * T - n_lag * T:train_day *
T]
X_train[row, 2 * T * n_lag:3 * T *
n_lag] = Huminity_weekday[train_day * T -
n_lag * T:train_day * T]
X_train[row, 3 * T * n_lag:4 * T *
n_lag] = WindSpeed_weekday[train_day * T -
n_lag * T:train_day * T]
X_train[row, 4 * T * n_lag:5 * T *
n_lag] = Day_period[train_day * T - n_lag * T:train_day *
T]
row += 1
# building test data
X_test = np.zeros((1, 5 * T * n_lag))
X_test[0, 0 * T * n_lag:1 * T *
n_lag] = load_weekday[curr_day * T - n_lag * T:curr_day * T]
X_test[0, 1 * T * n_lag:2 * T *
n_lag] = Temp_weekday[curr_day * T - n_lag * T:curr_day * T]
X_test[0, 2 * T * n_lag:3 * T *
n_lag] = Huminity_weekday[curr_day * T - n_lag * T:curr_day * T]
X_test[0, 3 * T * n_lag:4 * T *
n_lag] = WindSpeed_weekday[curr_day * T - n_lag * T:curr_day *
T]
X_test[0, 4 * T * n_lag:5 * T *
n_lag] = Day_period[curr_day * T - n_lag * T:curr_day * T]
y_test = load_weekday[curr_day * T:curr_day * T + T]
################### forecast ####################################
# suppress warnings
with warnings.catch_warnings():
warnings.filterwarnings("ignore")
nn = MLPRegressor(hidden_layer_sizes=(50, 50),
activation='relu',
max_iter=10000)
rf = RandomForestRegressor(n_estimators=100)
lr = LinearRegression(fit_intercept=True, normalize=True)
rf.fit(X_train, y_train)
nn.fit(X_train, y_train)
lr.fit(X_train, y_train)
y_nn = nn.predict(X_test)
y_nn = y_nn.flatten()
y_rf = rf.predict(X_test)
y_rf = y_rf.flatten()
y_lr = lr.predict(X_test)
y_lr = y_lr.flatten()
'''
xaxis = range(T)
plt.figure(figsize=(18,10))
plt.plot(xaxis, y_test, 'r')
plt.plot(xaxis, y_rf, 'g')
plt.show()
'''
# statistics of Neural Network
MAPE_nn = predict_util.calMAPE(y_test, y_nn)
MAPE_sum_nn += MAPE_nn
RMSPE_nn = predict_util.calRMSPE(y_test, y_nn)
RMSPE_sum_nn += RMSPE_nn
# statistics of Random Forest
MAPE_rf = predict_util.calMAPE(y_test, y_rf)
MAPE_sum_rf += MAPE_rf
RMSPE_rf = predict_util.calRMSPE(y_test, y_rf)
RMSPE_sum_rf += RMSPE_rf
# statistics of Linear Regression
MAPE_lr = predict_util.calMAPE(y_test, y_lr)
MAPE_sum_lr += MAPE_lr
RMSPE_lr = predict_util.calRMSPE(y_test, y_lr)
RMSPE_sum_lr += RMSPE_lr
days_sample = n_days - 1 - n_train - n_lag
MAPE_avg_nn = MAPE_sum_nn / days_sample
RMSPE_avg_nn = RMSPE_sum_nn / days_sample
MAPE_avg_rf = MAPE_sum_rf / days_sample
RMSPE_avg_rf = RMSPE_sum_rf / days_sample
MAPE_avg_lr = MAPE_sum_lr / days_sample
RMSPE_avg_lr = RMSPE_sum_lr / days_sample
return (MAPE_avg_nn, RMSPE_avg_nn, MAPE_avg_rf, RMSPE_avg_rf, MAPE_avg_lr,
RMSPE_avg_lr)
