def dataframe(df_path, subject_id, subject_template, in_mat, out_mat): # overwrite_dat=OVERWRITE_DF
import os # Imports must be made inside Node Function.
import pandas as pd
from utils import compute_rmse, vec
if not os.path.isfile(df_path):
e = 'File %s does not exist. Please re-run initialisation script.' % df_path
return print (e)
else:
df = pd.read_csv(df_path, index_col=0)
cols_h = ['subject','template','matfile_name','px','py','pz','translation','rotation','total_length','resolution','noise','rmse']
cols_r = list(df)
if not cols_h != cols_r:
e = 'Column names do not match. Please check.'
return print (e)
matfile_id = in_mat.split('/')[-1]
px, py, pz, vec_length = vec(in_mat,out_mat)
rx, ry, rz = None, None, None
trans, rot = matfile_id.split('_')[0], matfile_id.split('_')[1]
vox_dim = '1' # find params of functions, to get vox_dim ## HERE
rmse = compute_rmse(in_mat,out_mat)
df_tmp = pd.DataFrame([[subject_id,matfile_id,px,py,pz,vec_length,trans,rot,vox_dim,rmse]], columns=cols_r)
df = df.append(df_tmp, ignore_index=True)
df.to_csv(df_path)
def run_experiments(X_train, y_train, X_test, y_test, X_star_train,
X_star_test):
# normalization of the training data
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
'''
scaler = StandardScaler()
scaler.fit(X_star_train)
X_star_train = scaler.transform(X_star_train)
X_star_test = scaler.transform(X_star_test)
'''
results = OrderedDict()
if 1:
y_predicted = fit_SVR(X_train, y_train, X_test)
results["svm"] = [util.compute_rmse(y_test, y_predicted)]
X_train_mod = np.column_stack((X_train, X_star_train))
X_test_mod = np.column_stack((X_test, X_star_test))
scaler = StandardScaler()
scaler.fit(X_train_mod)
X_train_mod = scaler.transform(X_train_mod)
X_test_mod = scaler.transform(X_test_mod)
# print(X_train_mod.shape)
y_predicted = fit_SVR(X_train_mod, y_train, X_test_mod)
results["svm_pi"] = [util.compute_rmse(y_test, y_predicted)]
if 1:
y_predicted = KT_LUPI(X_train, X_star_train, y_train, X_test)
results["svm_kt_lupi"] = [util.compute_rmse(y_test, y_predicted)]
if 1:
y_predicted = RobustKT_LUPI(X_train, X_star_train, y_train, X_test)
results["svm_robust_kt_lupi"] = [
util.compute_rmse(y_test, y_predicted)
]
print(results)
return results
def evaluate(self, X_test, y_test):
"""evaluates the pipeline on df_test and return the RMSE"""
y_pred = self.pipeline.predict(X_test)
rmse = compute_rmse(y_pred, y_test)
return rmse
# normalization of the training data
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
'''
scaler = StandardScaler()
scaler.fit(X_star_train)
X_star_train = scaler.transform(X_star_train)
X_star_test = scaler.transform(X_star_test)
'''
if 1:
y_predicted = fit_SVR(X_train, y_train, X_test)
print("SVM Error Rate:")
rmseSVM[i] = util.compute_rmse(y_test, y_predicted)
print(rmseSVM[i])
X_train_mod = np.column_stack((X_train, X_star_train))
X_test_mod = np.column_stack((X_test, X_star_test))
scaler = StandardScaler()
scaler.fit(X_train_mod)
X_train_mod = scaler.transform(X_train_mod)
X_test_mod = scaler.transform(X_test_mod)
# print(X_train_mod.shape)
y_predicted = fit_SVR(X_train_mod, y_train, X_test_mod)
print("SVM with extra features Error Rate:")
rmseSVM_PI[i] = util.compute_rmse(y_test, y_predicted)
print(rmseSVM_PI[i])
if 1:
def main():
logger = logging.getLogger(__name__)
## Load config file
with open("config.json", "r") as f:
config = json.load(f)
## Cleaning TensorBoard events
clean_events(config)
## Load data
data_loader = DataLoader(config)
X_train, X_test, y_train, y_test = data_loader.get_data()
## Create placeholders
X = tf.placeholder(tf.float64, [None, 13])
# y = tf.placeholder(tf.float32, [None, 2])
y = tf.placeholder(tf.float64, [None])
## Create model and outputs
net = SimpleNet(config)
net_output = net.forward(X)
y_pred, log_sigma = net_output[..., 0], net_output[..., 1]
# Track mean of log_sigma across batch of data
tf.summary.scalar("mean_log_sigma", tf.reduce_mean(log_sigma))
## Define metrics based on experiment
# Loss
type_exp = '_'.join(config['exp_name'].split('_')[:2])
if type_exp == 'vanilla_loss':
loss = compute_loss(y_true=y, y_pred=y_pred)
elif type_exp == 'loss_bnn':
loss = compute_loss_bnn(y_true=y, y_pred=y_pred, log_sigma=log_sigma)
# Root Mean Squared Error (RMSE)
rmse = compute_rmse(y_true=y, y_pred=y_pred)
## Define optimizer
optimizer = net.train_optimizer(loss)
## Merging all summaries
merged_summary = tf.summary.merge_all()
## Launching the execution graph for training
with tf.Session() as sess:
# Initializing all variables
sess.run(tf.global_variables_initializer())
# Create train and test writer
train_writer = tf.summary.FileWriter("./tensorboard/" +
config["exp_name"] + "/train/")
test_writer = tf.summary.FileWriter("./tensorboard/" +
config["exp_name"] + "/test/")
# Visualizing the Graph
train_writer.add_graph(sess.graph)
for epoch in range(config["trainer"]["num_epochs"]):
for batch in range(config["trainer"]["num_iter_per_epoch"]):
# Yield next batch of data
batch_X, batch_y = next(
data_loader.get_next_batch(
config["trainer"]["batch_size"]))
# Run the optimizer
sess.run(optimizer, feed_dict={X: batch_X, y: batch_y})
# Compute train loss and rmse
train_loss, train_rmse = sess.run([loss, rmse],
feed_dict={
X: batch_X,
y: batch_y
})
if (epoch % config["trainer"]["writer_step"] == 0):
# Run the merged summary and write it to disk
s = sess.run(merged_summary,
feed_dict={
X: batch_X,
y: batch_y
})
train_writer.add_summary(s, (epoch + 1))
# Evaluate test data
test_loss, test_rmse = sess.run([loss, rmse],
feed_dict={
X: X_test,
y: y_test
})
s = sess.run(merged_summary, feed_dict={X: X_test, y: y_test})
test_writer.add_summary(s, (epoch + 1))
if (epoch % config["trainer"]["display_step"] == 0):
print("Epoch: {:03d},".format(epoch + 1), \
"train_loss= {:03f},".format(train_loss), \
"train_rmse= {:03f},".format(train_rmse), \
"test_loss= {:03f},".format(test_loss), \
"test_rmse={:03f}".format(test_rmse)
)
print("Training complete")
testPred = clf.predict(test_data)
return testPred
# Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(200 * rng.rand(600, 1) - 100, axis=0)
y = np.array([np.pi * np.sin(X).ravel(), np.pi * np.cos(X).ravel()]).T
y += (0.5 - rng.rand(*y.shape))
X_train, X_test, y_train, y_test = train_test_split(
X, y, train_size=400, test_size=200, random_state=4)
if 0:
y_predicted = fit_SVR(X_train, y_train[:,1], X_test)
rmse = util.compute_rmse(y_test[:,1], y_predicted)
print("SVM Result:")
print(rmse)
if 0:
X_mod = np.column_stack((X_train, y_train[:,1]))
X_test_mod = np.column_stack((X_test, y_test[:,1]))
y_predicted = fit_SVR(X_mod, y_train[:,0], X_test_mod)
rmse = util.compute_rmse(y_test[:,0], y_predicted)
print("SVM with extra features Result:")
print(rmse)
if 1:
y_predicted = KT_LUPI_GPR(X_train, y_train[:,0], y_train[:,1], X_test)
rmse = util.compute_rmse(y_test[:,0], y_predicted)
def test_prediction(self):
pred = super(TodayStreams, self).test_prediction()
y_true = self.enc_test[self.label]
self.rmse = utils.compute_rmse(y_true, pred)
self.r_squared = utils.compute_r_squared(y_true, pred)
output_weights = utils.pseudoinv_qrpivot(H)
else:
output_weights = utils.pseudoinv_svd(H.T) * T.T
print 'Unknown Pseudo-Inverse method selected! Using default Moore-Penrose Pseudo-Inverse method instead...'
t1 = time()
train_time = t0 - t1 # time to train the ELM
##################################################################
################## CALCULATE TRAINING ACCURACY ###################
Y = np.mat(H.T * output_weights).T # Y: the actual output of the training data
Y = np.squeeze(np.asarray(Y)) # Squeeze matrix to one dimension array
# print np.squeeze(Y), x_sample
if elm_type == REGRESSION:
train_accuracy = utils.compute_rmse(T, Y)
print 'Train Accuracy = ' + str(train_accuracy)
fig = plt.figure('TRAIN REGRESSION')
ax = fig.add_subplot(111)
ax.plot(x, y_true, 'g-', linewidth=2, label='True')
ax.scatter(x_sample, y_sample1, s=50, facecolors='none', edgecolors='b', linewidths=0.5, label='Train Data1')
ax.scatter(x_sample, y_sample2, s=50, facecolors='none', edgecolors='r', linewidths=0.5, label='Train Data2')
ax.plot(x_sample, Y, 'y--', linewidth=2, label='Train Output')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Regression with ELM with N data = ' + str(len(x_sample)))
plt.legend()
plt.grid()
# plt.show()
def elm(train_data, test_data, elm_type, num_hidden_neuron, activation_function, pseudo_inverse_method):
"""
ELM taken from http://www.ntu.edu.sg/home/egbhuang/elm_random_hidden_nodes.html
"""
REGRESSION = 0
CLASSIFIER = 1
##################################################################
######################## LOAD TRAINING DATA SET ##################
T = np.mat(train_data[:,0].T)
P = np.mat(train_data[:,1:np.size(train_data,1)].T)
#print 'T: ', T.shape
#print 'P: ', P.shape
##################################################################
######################## LOAD TESTING DATA SET ###################
TVT = np.mat(test_data[:,0].T)
TVP = np.mat(test_data[:,1:np.size(test_data,1)].T)
# Initialize NUMBER of NEURON, TEST DATA, and TRAIN DATA
num_train_data = np.size(P,1)
num_test_data = np.size(TVP,1)
num_input_neuron = np.size(P,0)
if elm_type != REGRESSION:
print 'Not implemented yet!'
##################################################################
##################### CALCULATE WEIGHT AND BIAS ##################
t0 = time()
# Random generate input weight w_i and bias b_i of hidden neuron
input_weights =np.mat(np.random.rand(num_hidden_neuron, num_input_neuron) * 2 - 1)
bias_hidden_neuron = np.mat(np.random.rand(num_hidden_neuron, 1))
temp_H = np.mat(input_weights * P)
ind = np.mat(np.ones((1, num_train_data)))
bias_matrix = bias_hidden_neuron * ind # Extend the bias matrix to match the dimension of H
temp_H = temp_H + bias_matrix
##################################################################
############ CALCULATE HIDDEN NEURON OUTPUT MATRIX H #############
if activation_function == 'sigmoid':
# equal to MATLAB code -> H = 1 ./ (1 + exp(-tempH));
H = np.mat(np.divide(1, (1 + np.exp(np.multiply(-1, temp_H))))) # element wise divide and multiplication
elif activation_function == 'sine':
H = np.mat(np.sin(temp_H))
elif activation_function == 'hardlim':
H = utils.hardlim(temp_H)
elif activation_function == 'tribas':
H = utils.triangular_bf(temp_H)
elif activation_function == 'radbas':
H = utils.rad_bf(temp_H)
else:
H = np.mat(np.divide(1, (1 + np.exp(np.multiply(-1, temp_H))))) # element wise divide and multiplication
print 'Unknown Activation Function selected! Using default sigmoid as Activation Function instead...'
##################################################################
################ CALCULATE OUTPUT WEIGHTS beta_i #################
if pseudo_inverse_method == 'svd':
output_weights = utils.pseudoinv_svd(H.T) * T.T
elif pseudo_inverse_method == 'geninv':
output_weights = utils.pseudoinv_geninv(H.T) * T.T
elif pseudo_inverse_method == 'qrpivot':
output_weights = utils.pseudoinv_qrpivot(H.T) * T.T
else:
output_weights = utils.pseudoinv_svd(H.T) * T.T
print 'Unknown Pseudo-Inverse method selected! Using default Moore-Penrose Pseudo-Inverse method instead...'
t1 = time()
train_time = t1 - t0 # time to train the ELM
print 'Train Time = ' + str(train_time)
##################################################################
################## CALCULATE TRAINING ACCURACY ###################
Y = np.mat(H.T * output_weights).T # Y: the actual output of the training data
print 'Y_ELM: ', Y
Y = np.squeeze(np.asarray(Y)) # Squeeze matrix to one dimension array
# print np.squeeze(Y), x_sample
train_accuracy = 0
if elm_type == REGRESSION:
train_accuracy = utils.compute_rmse(T, Y)
print 'Train Accuracy = ' + str(train_accuracy)
##################################################################
############### CALCULATE OUTPUT OF TESTING INPUT ################
t2 = time()
temp_H_test = input_weights * TVP
ind = np.mat(np.ones((1, num_test_data)))
bias_matrix = bias_hidden_neuron * ind # Extend the bias matrix to match the dimension of H
temp_H_test = temp_H_test + bias_matrix
if activation_function == 'sigmoid':
# equal to MATLAB code -> H = 1 ./ (1 + exp(-tempH));
H_test = np.mat(np.divide(1, (1 + np.exp(np.multiply(-1, temp_H_test))))) # element wise divide and multiplication
elif activation_function == 'sine':
H_test = np.mat(np.sin(temp_H_test))
elif activation_function == 'hardlim':
H_test = utils.hardlim(temp_H_test)
elif activation_function == 'tribas':
H_test = utils.triangular_bf(temp_H_test)
elif activation_function == 'radbas':
H_test = utils.rad_bf(temp_H_test)
else:
H_test = np.mat(np.divide(1, (1 + np.exp(np.multiply(-1, temp_H_test))))) # element wise divide and multiplication
print 'Unknown Activation Function selected! Using default sigmoid as Activation Function instead...'
TY = np.mat(H_test.T * output_weights).T # TY: the actual output of the testing data
print 'TY_ELM: ', TY
t3 = time()
test_time = t3 - t2 # ELM time to predict the whole testing data
print 'Test Time = ' + str(test_time)
TY = np.squeeze(np.asarray(TY)) # Squeeze matrix to one dimension array
# print np.squeeze(Y), x_sample
##################################################################
################## CALCULATE TRAINING ACCURACY ###################
test_accuracy = 0
if elm_type == REGRESSION:
test_accuracy = utils.compute_rmse(TVT, TY)
print 'Test Accuracy = ' + str(test_accuracy)
if elm_type == CLASSIFIER:
print 'Not implemented yet!'
return Y, TY, train_accuracy, test_accuracy