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)