def compare(y_raw_test, y_predicted): predictions = list() for i in range(len(y_predicted)): yhat = y_predicted[i] yhat = data_misc.inverse_difference(raw_values, yhat, len(y_test) + 1 - i) predictions.append(yhat) rmse = sqrt(mean_squared_error(y_raw_test, predictions)) return rmse, predictions
def compare_train(train_scaled, y_predicted): predictions = list() d = raw_values[0:split + 1] for i in range(len(train_scaled)): yhat = y_predicted[i] yhat = data_misc.inverse_difference(raw_values[0:split + 1], yhat, len(train_scaled) + 1 - i) predictions.append(yhat) # d = train_scaled[:, 0:-1] rmse = sqrt(mean_squared_error(raw_values[1:split + 1], predictions)) return rmse
def compare_train(y_test, y_predicted): predictions = list() d = raw_values[window_size:split + window_size + 1] for i in range(len(y_train)): yhat = y_predicted[i] yhat = data_misc.inverse_difference(d, yhat, len(y_train) + 1 - i) predictions.append(yhat) d = raw_values[window_size + 1:split + window_size + 1] rmse = sqrt(mean_squared_error(d, predictions)) return rmse, predictions
def compare_test(y_test, y_predicted): predictions = list() for i in range(len(y_test)): yhat = y_predicted[i] d = raw_values yhat = data_misc.inverse_difference(d, yhat, len(y_test) + 1 - i) predictions.append(yhat) d = raw_values[split + 1:] rmse = sqrt(mean_squared_error(d, predictions)) # rmse = sqrt(mean_squared_error(y_test, y_predicted)) return rmse, predictions
def compare_train(len_y_train=0, y_predicted=[]): predictions = list() d = avg_values[total_window_size:split + total_window_size + 1] for i in range(len_y_train): X = x_train[i] yhat = y_predicted[i] yhat = data_misc.invert_scale(scaler, X, yhat) yhat = data_misc.inverse_difference(d, yhat, len_y_train + 1 - i) predictions.append(yhat) d = avg_values[total_window_size + 1:split + total_window_size + 1] rmse = sqrt(mean_squared_error(d, predictions)) return rmse, predictions
def compare_train(train_scaled, y_predicted): predictions = list() for i in range(len(train_scaled)): X, y = train_scaled[i, 0:-1], train_scaled[i, -1] yhat = y_predicted[i] yhat = data_misc.invert_scale(scaler, X, yhat) # Se agrega split+1 ya para que sea consecuente con la data para realizar el diff. yhat = data_misc.inverse_difference(raw_values[:split + 1], yhat, len(train_scaled) + 1 - i) # print(yhat) predictions.append(yhat) d = raw_values[1:split + 1] # Se empieza desde uno ya que el primer dato no se puede tomar en cuenta por diff. rmse = sqrt(mean_squared_error(d, predictions)) return rmse
def compare_train(window_size, scaler, len_y_train, x_train, y_predicted=[]): predictions = list() d = dc.avg_values[window_size:dc.split_train_test + window_size + 1] for i in range(len_y_train): X = x_train[i] yhat = y_predicted[i] yhat = data_misc.invert_scale(scaler, X, yhat) yhat = data_misc.inverse_difference(d, yhat, len_y_train + 1 - i) predictions.append(yhat) # the +1 represents the drop that we did when the data was diff d = dc.avg_values[window_size + 1:dc.split_train_test + window_size + 1] rmse = sqrt(mean_squared_error(d, predictions)) return rmse, predictions
def compare_test(test_scaled, y_predicted): predictions = list() for i in range(len(test_scaled)): X, y = test_scaled[i, 0:-1], test_scaled[i, -1] yhat = y_predicted[i] # predictions.append(yhat) yhat = data_misc.invert_scale(scaler, X, yhat) yhat = data_misc.inverse_difference(y_raw_supervised[split:], yhat, len(test_scaled) + 1 - i) # print(yhat) predictions.append(yhat) # Se aumenta uno ya que el primer dato no se puede tomar en cuenta por diff. d = raw_values[1 + split:] # d = test_scaled[:, -1] rmse = sqrt(mean_squared_error(d, predictions)) return rmse, predictions
def compare(y_test, y_predicted): predictions = list() for i in range(len(y_test)): X = x_test[i] yhat = y_predicted[i] yhat = sc.inverse_transform(yhat) yhat = yhat.flatten() d = raw_values[upper_train:] yhat = data_misc.inverse_difference(d, yhat[0], len(y_test) + 1 - i) predictions.append(yhat) z = raw_values[upper_train:upper_train + testset_length] rmse = sqrt(mean_squared_error(z, predictions)) # rmse = sqrt(mean_squared_error(y_test, y_predicted)) return rmse, predictions
def compare_test(len_y_test=0, y_predicted=[]): predictions = list() for i in range(len_y_test): X = x_test[i] yhat = y_predicted[i] yhat = data_misc.invert_scale(scaler, X, yhat) # Stationary d = avg_values[split + total_window_size - 1:] yhat = data_misc.inverse_difference(d, yhat, len_y_test + 1 - i) predictions.append(yhat) d = avg_values[split + total_window_size + 1:] # d = avg_values[split + window_size :] rmse = sqrt(mean_squared_error(d, predictions)) # rmse = sqrt(mean_squared_error(y_test, y_predicted)) return rmse, predictions
def compare_test(window_size, scaler, len_y_test, x_test, y_predicted=[]): predictions = list() for i in range(len_y_test): X = x_test[i] yhat = y_predicted[i] yhat = data_misc.invert_scale(scaler, X, yhat) # Stationary d = dc.avg_values[dc.split_train_test + window_size - 1:] yhat = data_misc.inverse_difference(d, yhat, len_y_test + 1 - i) predictions.append(yhat) # the +1 represents the drop that we did when the data was diff d = dc.avg_values[dc.split_train_test + window_size + 1:] # d = avg_values[split + window_size :] rmse = sqrt(mean_squared_error(d, predictions)) # rmse = sqrt(mean_squared_error(y_test, y_predicted)) return rmse, predictions
def compare(y_raw_test, y_predicted): predictions = list() predictions2 = list() train_tmp = list() for i in range(len(train)): train_tmp.append(train[i, -1]) sum_first_values = raw_values[2] for i in range(len(y_predicted)): yhat = y_predicted[i] yhat = data_misc.inverse_difference(raw_values, yhat, len(y_test) + 1 - i) predictions.append(yhat) a = data_misc.inverse_difference2(sum_first_values, train_tmp, y_predicted[i]) train_tmp.append(y_predicted[i]) predictions2.append(a) rmse = sqrt(mean_squared_error(y_raw_test, predictions)) rmse2 = sqrt(mean_squared_error(y_raw_test, predictions2)) print('predictions2: %i' % (rmse2)) return rmse, predictions
def compare_val(window_size, scaler, len_y_val, x_val, y_predicted=[]): predictions = list() for i in range(len_y_val): X = x_val[i] yhat = y_predicted[i] yhat = data_misc.invert_scale(scaler, X, yhat) # Stationary #print(yhat) # Limit between the train and the val. the val d works from the end to the start. d = dc.avg_values[dc.split_train_val + window_size:dc.split_train_val + window_size + 1 + len_y_val] yhat = data_misc.inverse_difference(d, yhat, len_y_val + 1 - i) predictions.append(yhat) #print('Predictions') #print(predictions) # the +1 represents the drop that we did when the data was diff d = dc.avg_values[dc.split_train_val + window_size + 1: dc.split_train_val + window_size + 1 + dc.split_val_test] # d = avg_values[split + window_size :] rmse = sqrt(mean_squared_error(d, predictions)) # rmse = sqrt(mean_squared_error(y_test, y_predicted)) return rmse, predictions
supervised = data_misc.timeseries_to_supervised(diff_values, 1) supervised_values = supervised.values train, test = supervised_values[0:-1], supervised_values[-1:] test_scaled = scaler.transform(test) X, y = test_scaled[0, 0:-1], test_scaled[0, -1] else: flag = True X, y = test_scaled[i, 0:-1], test_scaled[i, -1] yhat = regr.predict([X]) print("Y_test: " + str(y) + " Yhat: " + str(yhat)) yhat = data_misc.invert_scale(scaler, X, yhat) # Se recorre -1 porque para que no se alinie donde empezó yhat = data_misc.inverse_difference(raw_values, yhat, -1 - i) # store forecast predictions.append(yhat) allList.append(yhat) # df = DataFrame(raw_values) # print(df[0][i]) # columns = [df[0][i] for i in range(0,df.size)] # columns.append(yhat) raw_values = allList # print(columns) rmse = sqrt(mean_squared_error(raw_values[-20:], predictions)) print('Test RMSE: %.7f' % (rmse)) misc.plot_line_graph('ElasticNet', raw_values[-20:], predictions) misc.print_comparison_list('Raw', raw_values[-20:], predictions)
print(regr.intercept_) y_predicted = regr.predict(X_test) print('y_test: ') print(y_test) print('y_predicted: ') print(y_predicted) predictions = list() for i in range(len(test_scaled)): X, y = test_scaled[i, 0:-1], test_scaled[i, -1] yhat = y_predicted[i] print("Y_test: " + str(y) + " Yhat: " + str(yhat)) yhat = data_misc.invert_scale(scaler, X, yhat) #print("yhat no scaled:" + str(yhat)) yhat = data_misc.inverse_difference(raw_values, yhat, len(test_scaled) -0 - i) #print("yhat no difference:" + str(yhat)) # store forecast predictions.append(yhat) rmse = sqrt(mean_squared_error(raw_values[-10:], predictions)) print('Test RMSE: %.7f' % (rmse)) misc.plot_line_graph('Test vs Predicted Data', raw_values[-10:], predictions) misc.print_comparison_list('Raw', raw_values[-10:], predictions) misc.plot_data_graph('All Data', raw_values) misc.plot_data_graph('Training Data', raw_values[:-10])
# data = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200] data = [ 112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118, 115, 126, 141, 135, 125, 149, 170 ] diff_size = 1 diff_values = data_misc.difference(data, diff_size) diff_values = diff_values.values size_diff_values = len(diff_values) split = int(size_diff_values * 0.80) train, test = diff_values[0:split], diff_values[split:] predictions = list() predictions2 = list() train_tmp = list() for i in range(len(train)): train_tmp.append(train[i]) for i in range(len(test)): yhat = test[i] yhat = data_misc.inverse_difference(data, yhat, len(test) + 1 - i) a = data_misc.inverse_difference2(data[0], train_tmp, test[i]) train_tmp.append(test[i]) predictions.append(yhat) predictions2.append(a) print(predictions) print(predictions2) print('end')
predictions = list() normal_y = list() for i in range(len(test_scaled)): # make one-step forecast x_train, y_train = test_scaled[i, 0:-1], test_scaled[i, -1] # Forecast for test y_predicted = forecast_lstm(lstm_model, 1, x_train) # invert scaling y_predicted = data_misc.invert_scale(scaler, x_train, y_predicted) y = data_misc.invert_scale(scaler, x_train, y_train) # invert differencing test # We get the history and we cut because we pair with the supervised that was cut before. It was full of zeroes d = raw_values[split + window_size - 1:] y_predicted = data_misc.inverse_difference(d, y_predicted, len(test_scaled) + 1 - i) y = data_misc.inverse_difference(d, y, len(test_scaled) + 1 - i) # print(" Y_test: " + str(y) + " Yhat: " + str(yhat) + " yraw:" + str(raw_values[i + len(train) + 1])) # store forecast normal_y.append(y) predictions.append(y_predicted) # report performance # the +1 represents the drop that we did when the data was diff y_raw = raw_values[split + 1 + window_size:] test_rmse = sqrt(mean_squared_error(y_raw, predictions)) print('%d) Test RMSE: %.3f' % (r + 1, test_rmse)) # print(predictions) error_scores.append(test_rmse) # plot
# split data into train and test-sets train, test = supervised_values[0:split], supervised_values[split:] # transform the scale of the data scaler, train_scaled, test_scaled = data_misc.scale(train, test) x_train, y_train = train_scaled[:, 0:-1], train_scaled[:, -1] x_test, y_test = test_scaled[:, 0:-1], test_scaled[:, -1] y_predicted = x_test predictions = list() for i in range(len(x_test)): X, y = x_test[i], y_test[i] yhat = y_predicted[i] # print("Y_test: " + str(y) + " Yhat: " + str(yhat)) yhat = data_misc.invert_scale(scaler, X, yhat) # print("yhat no scaled:" + str(yhat)) yhat = data_misc.inverse_difference(raw_values, yhat, len(x_test) + 1 - i) # print("yhat no difference:" + str(yhat)) # store forecast predictions.append(yhat) d = raw_values[split + 1:] rmse = sqrt(mean_squared_error(d, predictions)) print('Test RMSE: %.7f' % (rmse))
avg = [10, 22, 30, 42, 50, 62, 70, 82, 90, 102] btc = [110, 123, 130, 143, 150, 163, 170, 183, 190, 203] trend = [212, 224, 232, 244, 252, 264, 272, 284, 292, 304] df = DataFrame({'btc': btc, 'trend': trend}) print(btc) avg_diff = data_misc.difference(avg, 1) avg_supervised = data_misc.timeseries_to_supervised(avg_diff, avg_window_size) print(avg_supervised) btc_supervised = supervised_diff_dt(df, btc_window_size) # We pair the avg_supervised column with the weight_supervised cut_beginning = [avg_window_size, btc_window_size] cut_beginning = max(cut_beginning) avg_supervised = avg_supervised.values[cut_beginning:, :] btc_supervised = btc_supervised[cut_beginning:, :] # Concatenate with numpy supervised = np.concatenate((btc_supervised, avg_supervised), axis=1) print(supervised) print("No diff") for i in range(len(avg_diff)): avg_un_diff = data_misc.inverse_difference(avg, avg_diff[i], len(avg_diff) + 1 - i) print(avg_un_diff) print("End")