def run_dbn():
X_train, Y_train, X_test, Y_test = normalize_data()
regressor = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=16,
activation_function='relu')
# Y_train = np.reshape(Y_train, (79, 2))
print(X_train.shape, Y_train.shape)
regressor.fit(X_train, Y_train)
# Test
Y_pred = regressor.predict(X_test)
Y_pred = np.delete(Y_pred, np.s_[-1:], axis=1)
Y_test = np.delete(Y_test, np.s_[-1:], axis=1)
print("Y_pred", Y_pred)
print("Y_test", Y_test)
print('Done.\nR-squared: %f\nMSE: %f' %
(r2_score(Y_test, Y_pred), mean_squared_error(Y_test, Y_pred)))
# print("mean_absolute_error", mean_absolute_error(Y_test, Y_pred) / Y_test.shape[0])
# print("len", Y_test.shape[0])
abs_sum = 0
for i in range(0, 13):
v1 = Y_pred[i][0]
v2 = Y_test[i][0]
print(v1, v2)
abs_sum += abs(v1 - v2)
print("final: ", abs_sum, abs_sum / 13)
def train_model(learning_rate_rbm, learning_rate, batch_size, x_train, y_trian, x_test):
path_DBN = os.path.join(os.path.join(os.path.dirname(os.path.abspath(__file__)), "models"), "deep-belief-network")
sys.path.append(path_DBN)
from dbn.tensorflow import SupervisedDBNRegression
regressor_DBN = SupervisedDBNRegression(learning_rate_rbm=learning_rate_rbm, learning_rate=learning_rate,
batch_size=batch_size, verbose=False)
regressor_DBN.fit(x_train, y_trian)
pred = regressor_DBN.predict(x_test)
return pred
def update_mse(tmp_input_element, tmp_list):
data_train, label_train, data_test, label_test = \
HSMemory.create_train_and_test_data(tmp_list, tmp_input_element.number_visible_input)
tmp_regression = SupervisedDBNRegression(
hidden_layers_structure=[
tmp_input_element.number_visible_input,
tmp_input_element.number_hidden_input
],
learning_rate_rbm=tmp_input_element.learning_rate_rbm,
learning_rate=tmp_input_element.learning_rate,
n_epochs_rbm=tmp_input_element.n_epochs_rbm,
n_iter_backprop=tmp_input_element.n_iter_back_prop,
contrastive_divergence_iter=tmp_input_element.
contrastive_divergence_iter,
batch_size=tmp_input_element.batch_size,
activation_function=tmp_input_element.activation_function,
n_hidden_layers_mlp=tmp_input_element.n_hidden_layers_mlp,
cost_function_name=tmp_input_element.cost_function_name)
tmp_regression.fit(data_train, label_train) # train data
tmp_input_element.train_mse = sum(
tmp_regression.train_loss) / HSElement.config_n_iter_back_prop
y_pred_test = tmp_regression.predict(data_test)
check_nan = np.isnan(y_pred_test).any()
if check_nan:
tmp_input_element.test_mse = 1000
else:
tmp_input_element.test_mse = mean_squared_error(
label_test, y_pred_test)
if np.isnan(tmp_input_element.train_mse) or np.isinf(
tmp_input_element.train_mse):
tmp_input_element.train_mse = 1000
# add to export result
tmp_result_data = [
tmp_input_element.learning_rate_rbm,
tmp_input_element.learning_rate,
tmp_input_element.number_visible_input,
tmp_input_element.number_hidden_input, tmp_input_element.train_mse,
tmp_input_element.test_mse, '', '', '', '', '', '', '', ''
]
TensorGlobal.followHs.append(tmp_result_data)
TensorGlobal.sessFlg = True
tf.reset_default_graph()
del tmp_regression
return tmp_input_element
def create_random_model():
#tmp_learning_rate_rbm = 0.001 + uniform(0, 1) * (0.5 - 0.001) #lorenz
RandomRegression.tmp_learning_rate_rbm = 0.005 + uniform(0, 1) * (
0.2 - 0.005) #random
#tmp_learning_rate = 0.01 + uniform(0, 1) * (0.9 - 0.01) #lorenz
RandomRegression.tmp_learning_rate = 0.0008 + uniform(0, 1) * (
0.08 - 0.0008) #random
tmp_regressor = SupervisedDBNRegression(
hidden_layers_structure=[
RandomRegression.number_visible_input,
RandomRegression.number_hidden_input
],
learning_rate_rbm=RandomRegression.tmp_learning_rate_rbm,
learning_rate=RandomRegression.tmp_learning_rate,
#n_epochs_rbm=100, #lorenz
#n_epochs_rbm=150,
#n_epochs_rbm=30,
n_epochs_rbm=RandomRegression.number_iter_rbm_loop,
n_iter_backprop=RandomRegression.number_iter_backprop,
#n_iter_backprop=50,
contrastive_divergence_iter=2,
batch_size=32,
activation_function='relu',
n_hidden_layers_mlp=1,
cost_function_name='mse')
return tmp_regressor, RandomRegression.tmp_learning_rate_rbm, RandomRegression.tmp_learning_rate
def train_model(learning_rate_rbm, learning_rate, batch_size, x_train, y_train, x_test, message_queue):
path_DBN = os.path.join(os.path.join(os.path.dirname(os.path.abspath(__file__)), "models"), "deep-belief-network")
sys.path.append(path_DBN)
from dbn.tensorflow import SupervisedDBNRegression
regressor_DBN = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=learning_rate_rbm,
learning_rate=learning_rate,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=batch_size,
activation_function='sigmoid',
verbose=False)
regressor_DBN.fit(x_train, y_train)
pred = regressor_DBN.predict(x_test)
message_queue.put(pred)
return
def build_RBM(num_bp, epoch_pretrain=25, batch_size=24, hidDim=[100,140]):
regressor = SupervisedDBNRegression(hidden_layers_structure=hidDim,
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=epoch_pretrain,
n_iter_backprop=num_bp,
batch_size=batch_size,
activation_function='tanh')
return regressor
def gerar_dbn(topologia=[10], tx_rbm=0.1, tx_apr=0.3, n_epoc_rbm=0, n_iter=20, funcao='relu' ):
from dbn.tensorflow import SupervisedDBNRegression
dbn = SupervisedDBNRegression(hidden_layers_structure=topologia,
learning_rate_rbm=tx_rbm,
learning_rate=tx_apr,
n_epochs_rbm=n_epoc_rbm,
n_iter_backprop=n_iter,
batch_size=1,
activation_function=funcao)
return dbn
def create_random_model():
RandomRegressionDolar.tmp_learning_rate_rbm = 0.0005 + uniform(0, 1) * (0.05 - 0.0005) #random
RandomRegressionDolar.tmp_learning_rate = 0.00005 + uniform(0, 1) * (0.005 - 0.00005) #random
tmp_regressor = SupervisedDBNRegression(hidden_layers_structure=[RandomRegressionDolar.number_visible_input,
RandomRegressionDolar.number_hidden_input],
learning_rate_rbm=RandomRegressionDolar.tmp_learning_rate_rbm,
learning_rate=RandomRegressionDolar.tmp_learning_rate,
n_epochs_rbm=RandomRegressionDolar.number_iter_rbm_loop,
n_iter_backprop=RandomRegressionDolar.number_iter_backprop,
contrastive_divergence_iter=2,
batch_size=32,
activation_function='relu',
n_hidden_layers_mlp=1,
cost_function_name='mse')
return tmp_regressor, RandomRegressionDolar.tmp_learning_rate_rbm, RandomRegressionDolar.tmp_learning_rate
#print(X.shape[0])
#stdScaler = StandardScaler()
min_max_scaler = MinMaxScaler()
X = min_max_scaler.fit_transform(X)
#print('x_train number: ', X.shape[0])
#print('x_test number: ', X_test.shape[0])
#print('Y_train number: ', Y.shape[0])
#print('y_test number: ', Y_test)
regressor = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=10,
n_iter_backprop=100,
batch_size=16,
activation_function='relu')
regressor.fit(X, Y)
# Save the model
regressor.save('models/abalone_3.pkl')
# Restore it
#regressor = SupervisedDBNRegression.load('models/abalone_2.pkl')
# Test
data1 = pd.read_csv("abalone_test.csv")
Y_train = Y_raw.iloc[]
X_test = X_raw.iloc[]
X_train = X_raw.iloc[]
# Data scaling
min_max_scaler = MinMaxScaler()
X_train = min_max_scaler.fit_transform(X_train)
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[7],
learning_rate_rbm=0.01,
learning_rate=0.0001,
n_epochs_rbm=500,
n_iter_backprop=7409, # run more iter
batch_size=40,
activation_function='relu')
regressor.fit(X_train, Y_train)
# Test
X_test = min_max_scaler.transform(X_test)
Y_pred = regressor.predict(X_test)
mse = mean_squared_error(Y_test, Y_pred)
print('Done.\nR-squared: %f\nMSE: %f' % (r2_score(Y_test, Y_pred), mse))
def mean_absolute_percentage_error(y_test, y_pred):
# Data scaling
min_max_scaler = MinMaxScaler()
X_train = min_max_scaler.fit_transform(X_train)
LEARNING_RATE_BASE = 0.01 # 最初学习率
LEARNING_RATE_DECAY = 0.99 # 学习率的衰减率
LEARNING_RATE_STEP = 100 # 喂入多少轮BATCH-SIZE以后，更新一次学习率。一般为总样本数量/BATCH_SIZE
# 计数器，用来记录运行了几轮的BATCH_SIZE，初始为0，设置为不可训练
gloabl_steps = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE,
gloabl_steps,
LEARNING_RATE_STEP,
LEARNING_RATE_DECAY,
staircase=True)
print(X_train.shape)
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[80],
learning_rate_rbm=0.01,
learning_rate=learning_rate,
n_epochs_rbm=1,
n_iter_backprop=200,
batch_size=16,
activation_function='relu')
regressor.fit(X_train, Y_train)
# Test
X_test = min_max_scaler.transform(X_test)
Y_pred = regressor.predict(X_test)
print('Done.\nR-squared: %f\nMSE: %f' %
(r2_score(Y_test, Y_pred), mean_squared_error(Y_test, Y_pred)))
def train_model(learning_rate, periods, batch_size, feature, label,
path_out_png):
path_DBN = os.path.join(
os.path.join(os.path.dirname(os.path.abspath(__file__)), "models"),
"deep-belief-network")
sys.path.append(path_DBN)
from dbn.tensorflow import SupervisedDBNRegression
X_train, X_test, Y_train, Y_test = train_test_split(feature,
label,
test_size=0.2,
shuffle=False)
train_steps_per_period = X_train.shape[0] // periods # floor
test_steps_per_period = X_test.shape[0] // periods
# print(X_train)
# print(Y_train)
'''regressor_DBN = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=learning_rate,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=batch_size,
activation_function='sigmoid',
verbose=False)'''
regressor_DBN = SupervisedDBNRegression(learning_rate=learning_rate,
batch_size=batch_size,
verbose=False)
print("Training model...")
print("RMSE (on training data):")
root_mean_squared_errors = []
for period in range(0, periods):
x_train = np.array(
X_train[period * train_steps_per_period:(period + 1) *
train_steps_per_period])
# x_train=x_train.reshape(x_train.size,1)
y_trian = np.array(
Y_train[period * train_steps_per_period:(period + 1) *
train_steps_per_period])
# y_trian=y_trian.reshape(y_trian.size,1,1)
# print(x_train)
# print(y_trian)
regressor_DBN.fit(x_train, y_trian)
x_test = X_test[period * test_steps_per_period:(period + 1) *
test_steps_per_period]
y_test = Y_test[period * test_steps_per_period:(period + 1) *
test_steps_per_period]
predictions = regressor_DBN.predict(x_test)
# predictions = np.array([predictions])
# print(predictions.shape)
# print(y_test.shape)
root_mean_squared_error = math.sqrt(
mean_squared_error(y_test, predictions))
print(" period %02d : %0.2f" % (period, root_mean_squared_error))
root_mean_squared_errors.append(root_mean_squared_error)
print("Model training finished.")
# Output a graph of loss metrics over periods.
plt.subplot(1, 2, 2)
plt.ylabel('RMSE')
plt.xlabel('Periods')
plt.title("Root Mean Squared Error vs. Periods")
plt.tight_layout()
plt.plot(root_mean_squared_errors)
plt.savefig(path_out_png)
print("Final RMSE (on training data): %0.2f" % root_mean_squared_error)
use_CCA_data = True
use_deep = False
step = 1
train_deep = 50
train_start = 51
predict_start = 52
assert step > 0
assert train_deep >= step and train_start >= train_deep
assert predict_start > train_start
assert not (True == use_all_data and True == use_CCA_data)
regressor_DBN = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=32,
activation_function='sigmoid',
verbose=False)
regressor_AdaBoost = AdaBoostRegressor()
regressor_DBNAdaBoost = AdaBoostRegressor(SupervisedDBNRegression(
hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=16,
activation_function='sigmoid',
verbose=False),
loss="square",
n_estimators=250,
X = min_max_scaler.fit_transform(X)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.25)
#print('X: ', X.shape[1])
#print('Y: ', Y)
#print('Y_train number: ', Y_train[0])
#print('y_test number: ', Y_test.shape[0])
#'''
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[10, 100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=100,
batch_size=16,
activation_function='relu')
regressor.fit(X_train, Y_train)
# Save the model
regressor.save('models/taipei_data.pkl')
# Restore it
#regressor = SupervisedDBNRegression.load('models/model_regression.pkl')
# Test
X_test = min_max_scaler.transform(X_test)
Y_pred = regressor.predict(X_test)
print('Done.\nR-squared: %f\nMSE: %f\nMAPE: %f' %
def DBN_Run(hidden_layers_struc, learnin_rate_rbm, learnin_rate,
num_epochs_rbm, num_iter_backprop, batchSize, activation_func):
# This is a parameter for the start date of the model, it must be entered in the format Month/Day/Year like 2/6/2019
# The program will find the next closest date to the one listed by iterating forware in the calendar (no leap years)
# Enter post 1/3/1950 for Volume data to be there
startDate = "6/26/2000"
# defines a start time for the project job
startTime = time.time()
# Creates the output file director if it is not already created
if not os.path.isdir("benchmark-output"):
os.mkdir("benchmark-output")
# Loading dataset
SP_Data_Full = pd.read_csv("data-files/S&P_Movement.csv", sep=',')
# Change start index based on the given start date and read in new dataframe
startIndex = SP_Data_Full.index[SP_Data_Full["Date"] == startDate].values
SP_Data = SP_Data_Full.iloc[startIndex[0]:-1]
SP_Data.reset_index(inplace=True)
# Shift the data set so that the model is reading in the previous day's information on the High, Low, Close, Volume
# and Movement
SP_Data["PrevHigh"] = SP_Data["High"].shift(-1)
SP_Data["PrevLow"] = SP_Data["Low"].shift(-1)
SP_Data["PrevClose"] = SP_Data["Close"].shift(-1)
SP_Data["PrevVolume"] = SP_Data["Volume"].shift(-1)
SP_Data["PrevMovement"] = SP_Data["Movement"].shift(-1)
# split the new dataframe into features and targets
target = SP_Data[["Close"], ["Movement"]]
features = SP_Data[[
"Date", "Open", "PrevHigh", "PrevLow", "PrevVolume", "PrevMovement"
]]
features = format_year(features)
# format the dataframe as a numpy array for the tensorflow functions
target_array = target.values
features_array = features.values
X, Y = features_array, target_array
# Splitting data into test and train
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=1337)
# Data scaling
min_max_scaler = MinMaxScaler()
X_train = min_max_scaler.fit_transform(X_train)
# Training
regressor = SupervisedDBNRegression(
hidden_layers_structure=hidden_layers_struc,
learning_rate_rbm=learnin_rate_rbm,
learning_rate=learnin_rate,
n_epochs_rbm=num_epochs_rbm,
n_iter_backprop=num_iter_backprop,
batch_size=batchSize,
activation_function=activation_func)
regressor.fit(X_train, Y_train)
trainingTime = time.time() - startTime
# Test
X_test = min_max_scaler.transform(X_test)
Y_pred = regressor.predict(X_test)
r2 = r2_score(Y_test, Y_pred)
mse = mean_squared_error(Y_test, Y_pred)
testingTime = time.time() - startTime - trainingTime
totalRunTime = time.time() - startTime
# Text output file for more user friendly reading
# formated based on the input into this function as the hyperparameters in order delimited by the _
file = open(
"benchmark-output/result_" + str(hidden_layers_struc) + "_" +
str(learnin_rate_rbm) + "_" + str(learnin_rate) + "_" +
str(num_epochs_rbm) + "_" + str(num_iter_backprop) + "_" +
str(batchSize) + "_" + str(activation_func) + ".txt", "w+")
file.write('Done.\nR-squared: %f\nMSE: %f' % (r2, mse) + "\n")
file.write("Training Time: " + str(trainingTime) + "\n")
file.write("Testing Time: " + str(testingTime) + "\n")
file.write("Total Run Time: " + str(totalRunTime) + "\n\n")
file.write("Network Information:")
file.write("Hidden Layer Structure: " + str(hidden_layers_struc) + "\n")
file.write("Learning Rate RBM: " + str(learnin_rate_rbm) + "\n")
file.write("Learning Rate: " + str(learnin_rate) + "\n")
file.write("Number of Epochs: " + str(num_epochs_rbm) + "\n")
file.write("Number of Iterative Backpropogations: " +
str(num_iter_backprop) + "\n")
file.write("Batch Size: " + str(batchSize) + "\n")
file.write("Activation Function: " + str(activation_func) + "\n")
file.close()
# CSV file output for use in data visualization
hiddenlayerNumNodes = hidden_layers_struc[0]
hiddenlayerNum = hidden_layers_struc[1]
file = open(
"benchmark-output/result_" + str(hidden_layers_struc) + "_" +
str(learnin_rate_rbm) + "_" + str(learnin_rate) + "_" +
str(num_epochs_rbm) + "_" + str(num_iter_backprop) + "_" +
str(batchSize) + "_" + str(activation_func) + ".csv", "w+")
file.write(
"R-squared,MSE,trainingTime,testingTime,totalRunTime,hiddenlayerNumNodes,hiddenlayerNum,learnin_rate_rbm"
",learnin_rate,num_epochs_rbm,num_iter_backprop,batchSize,activation_func\n"
)
file.write(
str(r2) + "," + str(mse) + "," + str(trainingTime) + "," +
str(testingTime) + "," + str(totalRunTime) + "," +
str(hiddenlayerNumNodes) + "," + str(hiddenlayerNum) + "," +
str(learnin_rate_rbm) + "," + str(learnin_rate) + "," +
str(num_epochs_rbm) + "," + str(num_iter_backprop) + "," +
str(batchSize) + "," + str(activation_func))
file.close()
data_rs_x_2013 = pd.concat([Lst_rs_2013,Rndaily_rs_2013,Ndvi_rs_2013],axis=1).values
data_rs_x_2014 = pd.concat([Lst_rs_2014,Rndaily_rs_2014,Ndvi_rs_2014],axis=1).values
data_rs_x_2015 = pd.concat([Lst_rs_2015,Rndaily_rs_2015,Ndvi_rs_2015],axis=1).values
data_rs_x_2016 = pd.concat([Lst_rs_2016,Rndaily_rs_2016,Ndvi_rs_2016],axis=1).values
#How to use pd.concat:https://blog.csdn.net/stevenkwong/article/details/52528616
data_rs_x_2013_mm = MinMaxScaler().fit_transform(data_rs_x_2013)
data_rs_x_2014_mm = MinMaxScaler().fit_transform(data_rs_x_2014)
data_rs_x_2015_mm = MinMaxScaler().fit_transform(data_rs_x_2015)
data_rs_x_2016_mm = MinMaxScaler().fit_transform(data_rs_x_2016)
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=300,
batch_size=16,
activation_function='relu')
regressor.fit(x_train, y_train)
# Test
#X_test = min_max_scaler.transform(X_test)
y_pred = regressor.predict(x_test)
print('Done.\nR-squared: %f\nMSE: %f' % (r2_score(y_test, y_pred), mean_squared_error(y_test, y_pred)))
r, p = pearsonr(y_test.flatten(), y_pred.flatten())
r2 = r2_score(y_test.flatten(), y_pred.flatten())
MAE = mean_absolute_error(y_test.flatten(), y_pred.flatten())
MSE = mean_squared_error(y_test.flatten(), y_pred.flatten())
random_state=1337)
# Data scaling
min_max_scaler = MinMaxScaler()
X_train = min_max_scaler.fit_transform(X_train)
#print('x_train number: ', X_train[0])
#print('x_test number: ', X_test.shape[1])
#print('Y_train number: ', Y_train[0])
#print('y_test number: ', Y_test.shape[0])
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=16,
activation_function='relu')
#regressor.fit(X_train, Y_train)
# Save the model
#regressor.save('model_regression_128.pkl')
# Restore it
regressor = SupervisedDBNRegression.load('models/model_regression.pkl')
# Test
X_test = min_max_scaler.transform(X_test)
Y_pred = regressor.predict(X_test)
print('Done.\nR-squared: %f\nMSE: %f' %
from sklearn.preprocessing import MinMaxScaler
from dbn.tensorflow import SupervisedDBNRegression
# Loading dataset
boston = load_boston()
X, Y = boston.data, boston.target
# Splitting data
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
# Data scaling
min_max_scaler = MinMaxScaler()
X_train = min_max_scaler.fit_transform(X_train)
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[100],
learning_rate_rbm=0.01,
learning_rate=0.01,
n_epochs_rbm=20,
n_iter_backprop=200,
batch_size=16,
activation_function='relu')
regressor.fit(X_train, Y_train)
# Test
X_test = min_max_scaler.transform(X_test)
Y_pred = regressor.predict(X_test)
print 'Done.\nR-squared: %f\nMSE: %f' % (r2_score(Y_test, Y_pred), mean_squared_error(Y_test, Y_pred))
