def split_data(self, proportions):
data_size = self.X.shape[0]
num_train = int(proportions[0]*data_size)
num_test = int(proportions[1]*data_size)
num_valid = data_size - num_train_num_test
indices = range(data_size)
np.random_shuffle(indices)
indices_train = indices[0:num_train]
indices_valid = indices[num_train:num_train+num_valid]
indices_test = indices[num_train+num_valid:data_size]
self.X_train = self.X[indices_train]
self.X_valid = self.X[indices_valid]
self.X_test = self.X[indices_test]
self.y_train = self.y[indices_train]
self.y_valid = self.y[indices_valid]
self.y_test = self.y[indices_test]
self.set_sizes()
def split_data(self, proportions):
data_size = self.X.shape[0]
num_train = int(proportions[0] * data_size)
num_test = int(proportions[1] * data_size)
num_valid = data_size - num_train_num_test
indices = range(data_size)
np.random_shuffle(indices)
indices_train = indices[0:num_train]
indices_valid = indices[num_train:num_train + num_valid]
indices_test = indices[num_train + num_valid:data_size]
self.X_train = self.X[indices_train]
self.X_valid = self.X[indices_valid]
self.X_test = self.X[indices_test]
self.y_train = self.y[indices_train]
self.y_valid = self.y[indices_valid]
self.y_test = self.y[indices_test]
self.set_sizes()
def load_labels (self, mode):
if mode == 'train':
txtname = os.path.join(self.data_path,'train.txt')
if mode =='test':
txtname = os.path.join(self.data_path,'.txt')
with open(txtname,'r') as f:
image_ind = [x.strip() for x in f.readlines()]
labels = []
for img in image_ind:
label, num = self.load_data(ind)
if num == 0:
continue
imagename = os.path.join(self.data_path, 'Images', img + 'jpg')
labels.append({'imagename': imagename, 'label' = label})
np.random_shuffle(labels)
return labels
def run_LAmbDA(gamma, delta, tau, prc_cut, bs_prc, do_prc, hidden_feats,
lambda1, lambda2, lambda3):
print(
"gamma=%.4f, delta=%.4f, tau=%.4f, prc_cut=%.4f, bs_prc=%.4f, do_prc=%.4f, hidden_feats=%.4f, lambda1= %.4f, lambda2= %.4f, lambda3= %.4f"
% (gamma, delta, tau, prc_cut, bs_prc, do_prc, hidden_feats, lambda1,
lambda2, lambda3))
global X, Y, Gnp, Dnp, train, test, prt
D = tf.cast(Dnp, tf.float32)
G = tf.cast(Gnp, tf.float32)
hidden_feats = math.floor(hidden_feats)
input_feats = X.shape[1]
num_labls = G.shape.as_list()
output_feats = num_labls[1]
num_labls = num_labls[0]
rowsums = np.sum(Gnp, axis=1)
train2 = resample(prc_cut, Y, Gnp, train, gamma)
bs = int(np.ceil(bs_prc * train2.size))
xs = tf.placeholder(tf.float32, [None, X.shape[1], X.shape[2]])
ys = tf.placeholder(tf.float32, [None, num_labls])
layer1 = add_layer(xs,
input_feats,
hidden_feats,
activation_function=tf.sigmoid,
dropout_function=True,
rnn_layer=True,
lambda1=lambda1,
keep_prob1=do_prc)
predict = add_layer(layer1,
hidden_feats,
output_feats,
activation_function=tf.nn.softmax,
dropout_function=False,
lambda1=lambda1)
Cm = tf.matmul(tf.transpose(tf.matmul(ys, D)), predict + 0.1) / tf.reshape(
tf.reduce_sum(tf.transpose(tf.matmul(ys, D)), 1), (-1, 1))
mCm = tf.reshape(
tf.reduce_mean(
tf.cast(tf.matmul(tf.transpose(D), G) > 0, tf.float32) * Cm, 1),
(-1, 1))
yw = tf.multiply(predict + 0.1,
tf.matmul(tf.matmul(ys, D), tf.pow(mCm / Cm, tau)))
ye = tf.multiply(tf.matmul(ys, G), yw)
yt = tf.matmul(ys, tf.matmul(tf.transpose(ys), ye))
ya = (delta * yt) + ((1 - delta) * ye)
yn = tf.one_hot(tf.argmax(ya, axis=1), output_feats)
Ct = tf.transpose(tf.matmul(tf.transpose(layer1), ys)) / tf.reshape(
tf.reduce_sum(tf.transpose(ys + 0.01), 1), (-1, 1))
E = tf.multiply(
tf.matmul(tf.reshape(tf.reduce_sum(tf.square(Ct), 1),
(-1, 1)), tf.ones([1, num_labls])) +
tf.matmul(tf.ones([num_labls, 1]),
tf.reshape(tf.reduce_sum(tf.square(Ct), 1), (1, -1))) -
tf.multiply(tf.cast(2, tf.float32), tf.matmul(Ct, tf.transpose(Ct))),
tf.ones([num_labls, num_labls]) - tf.eye(tf.cast(num_labls, tf.int32)))
M1 = (tf.cast(tf.matmul(G, tf.transpose(G)) > 0, tf.float32) *
(tf.ones([num_labls, num_labls]) -
tf.cast(tf.matmul(D, tf.transpose(D)) > 0, tf.float32))) / (
tf.matrix_band_part(
tf.matmul(tf.reshape(tf.reduce_sum(G, 1), (-1, 1)),
tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0) +
tf.transpose(
tf.matrix_band_part(
tf.matmul(tf.reshape(tf.reduce_sum(G, 1), (-1, 1)),
tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0)))
M2 = tf.cast(tf.matmul(D, tf.transpose(D)) > 0, tf.float32) / (
tf.matrix_band_part(
tf.matmul(
tf.reshape(
tf.reduce_sum(
tf.cast(tf.matmul(D, tf.transpose(D)) > 0, tf.float32),
1),
(-1, 1)), tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0) +
tf.transpose(
tf.matrix_band_part(
tf.matmul(
tf.reshape(
tf.reduce_sum(
tf.cast(
tf.matmul(D, tf.transpose(D)) > 0, tf.float32),
1),
(-1, 1)), tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0)))
#***********************************************************************
# Cost function with new label matrix
iter = 2000
# Initialize to unambiguous labels
G2 = np.copy(Gnp)
G2[rowsums > 1, :] = 0
YI = np.matmul(Y, G2)
YIrs = np.sum(YI, axis=1)
G2 = tf.cast(G2, tf.float32)
yi = tf.matmul(ys, G2)
trainI = train2[np.in1d(train2, np.where(YIrs == 1))]
testI = test[np.in1d(test, np.where(YIrs == 1))]
lossI = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - predict), reduction_indices=[1]))
train_stepI = tf.train.AdamOptimizer(learning_rate=0.01,
epsilon=1e-8).minimize(lossI)
# LAmbDA optimization
loss1 = tf.reduce_mean(
tf.reduce_sum(tf.square(yn - predict), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(
learning_rate=0.01,
epsilon=1e-8).minimize(loss1 + lambda2 * tf.reduce_mean(E * M1) -
lambda3 * tf.reduce_mean(E * M2))
#train_step = tf.train.AdamOptimizer(learning_rate=0.01,epsilon=1e-8).minimize(loss1+(lambda2*(tf.reduce_sum(E*M1)/tf.cast(tf.count_nonzero(M1>0),tf.float32)))-(lambda3*(tf.reduce_sum(E*M2)/tf.cast(tf.count_nonzero(M2>0),tf.float32))))
init = tf.global_variables_initializer()
trainI.astype(int)
tensor_trainI = {xs: X[trainI, :, :], ys: Y[trainI, :]}
tensor_testI = {xs: X[testI, :, :], ys: Y[testI, :]}
tensor_train = {xs: X[train2[0:bs], :, :], ys: Y[train2[0:bs], :]}
tensor_test = {xs: X[test, :, :], ys: Y[test, :]}
# run training process
sess = tf.Session()
sess.run(init)
for i in range(iter + 1):
if i <= 1000:
sess.run(train_stepI, feed_dict=tensor_trainI)
if i % 10 == 0:
print(
str(sess.run(lossI, feed_dict=tensor_trainI)) + ' ' +
str(sess.run(lossI, feed_dict=tensor_testI)))
else:
sess.run(train_step, feed_dict=tensor_train)
if i % 10 == 0:
print(
str(sess.run(loss1, feed_dict=tensor_train)) + ' ' +
str(sess.run(loss1, feed_dict=tensor_test)) + ' ' +
str(lambda2 * sess.run(tf.reduce_mean(E * M1),
feed_dict=tensor_train)) + ' ' +
str(lambda3 * sess.run(tf.reduce_mean(E * M2),
feed_dict=tensor_train)))
elif i % 50 == 0:
np.random_shuffle(train2)
tensor_train = {
xs: X[train2[0:bs], :, :],
ys: Y[train2[0:bs], :]
}
if prt:
blah = sess.run(predict, feed_dict=tensor_test)
blah2 = sess.run(layer1, feed_dict=tensor_test)
sio.savemat('preds_cv' + str(cv) + '.mat', {'preds': blah})
sio.savemat('truth_cv' + str(cv) + '.mat', {'labels': Y[test, :]})
sio.savemat('hidden_cv' + str(cv) + '.mat', {'hidden': blah2})
print(
"loss1=%.4f, gamma=%.4f, delta=%.4f, tau=%.4f, prc_cut=%.4f, bs_prc=%.4f, do_prc=%.4f, hidden_feats=%.4f, lambda1= %.4f, lambda2= %.4f, lambda3= %.4f"
% (sess.run(loss1, feed_dict=tensor_test), gamma, delta, tau, prc_cut,
bs_prc, do_prc, hidden_feats, lambda1, lambda2, lambda3))
acc = sess.run(loss1, feed_dict=tensor_test)
tf.reset_default_graph()
return (acc)
def run_LAmbDA2(gamma, delta, tau, prc_cut, bs_prc, num_trees, max_nodes):
global X, Y, Gnp, Dnp, train, test, prt, cv
D = tf.cast(Dnp, tf.float32)
G = tf.cast(Gnp, tf.float32)
#optunity_it = optunity_it+1;
num_trees = int(num_trees)
max_nodes = int(max_nodes)
prc_cut = int(np.ceil(prc_cut))
print(
"gamma=%.4f, delta=%.4f, tau=%.4f, prc_cut=%i, bs_prc=%.4f, num_trees=%i, max_nodes=%i"
% (gamma, delta, tau, prc_cut, bs_prc, num_trees, max_nodes))
input_feats = X.shape[1]
num_labls = G.shape.as_list()
output_feats = num_labls[1]
#print(output_feats)
num_labls = num_labls[0]
rowsums = np.sum(Gnp, axis=1)
train2 = resample(prc_cut, Y, Gnp, train, gamma)
# Bug??
bs = int(np.ceil(bs_prc * train2.size))
xs = tf.placeholder(tf.float32, [None, input_feats])
#ys = tf.placeholder(tf.float32, [None,num_labls])
yin = tf.placeholder(tf.int32, [None])
print("Vars loaded xs and ys created")
hparams = tensor_forest.ForestHParams(num_classes=output_feats,
num_features=input_feats,
num_trees=num_trees,
max_nodes=max_nodes).fill()
print("Tensor forest hparams created")
forest_graph = tensor_forest.RandomForestGraphs(hparams)
print("Tensor forest graph created")
train_op = forest_graph.training_graph(xs, yin)
loss_op = forest_graph.training_loss(xs, yin)
print("Loss and train ops created")
predict, _, _ = forest_graph.inference_graph(xs)
print("Tensor forest variables created through predict")
accuracy_op = tf.reduce_mean(
tf.reduce_sum(tf.square(tf.one_hot(yin, output_feats) - predict),
reduction_indices=[1]))
print(
tf.reduce_sum(tf.square(tf.one_hot(yin, output_feats) - predict),
reduction_indices=[1]))
#predict = tf.one_hot(pred);
print("Lambda specific variables created")
# Creating training and testing steps
G2 = np.copy(Gnp)
G2[rowsums > 1, :] = 0
YI = np.matmul(Y, G2)
YIrs = np.sum(YI, axis=1)
trainI = train2[np.in1d(train2, np.where(YIrs == 1))]
print("data type trainI,", trainI.dtype)
testI = test[np.in1d(test, np.where(YIrs == 1))]
print("trainI testI created")
#init_vars=tf.global_variables_initializer()
init_vars = tf.group(
tf.global_variables_initializer(),
resources.initialize_resources(resources.shared_resources()))
sess = tf.Session()
sess.run(init_vars)
print("Session started")
#beep = sess.run(predict,feed_dict={xs:X[1:100,:]});
#beep = sess.run(predict,feed_dict={xs:X[train2[0:bs],:]});
tensor_trainI = {
xs: X[trainI, :],
yin: sess.run(tf.argmax(get_yi(rowsums, G2, Y[trainI, :]), axis=1))
}
print("tensor_trainI made")
tensor_testI = {
xs: X[testI, :],
yin: sess.run(tf.argmax(get_yi(rowsums, G2, Y[testI, :]), axis=1))
}
print("tensor_testI made")
tensor_train = {
xs:
X[train2[0:bs], :],
yin:
sess.run(
tf.argmax(get_yn(
sess.run(predict, feed_dict={xs: X[train2[0:bs], :]}),
Y[train2[0:bs], :], delta, tau, output_feats),
axis=1))
}
print("tensor_train made")
tensor_test = {
xs:
X[test, :],
yin:
sess.run(
tf.argmax(get_yn(sess.run(predict, feed_dict={xs: X[test, :]}),
Y[test, :], delta, tau, output_feats),
axis=1))
}
print("tensor_test made")
#**********************************
#print("Loss and training steps created with sample tensors")
# Setting params and initializing
print("Beginning iterations")
# Starting training iterations
print(X.shape)
for i in range(1, 101):
if i < 50:
sess.run(train_op, feed_dict=tensor_trainI)
#print("ran train op")
if i % 10 == 0:
print(
str(sess.run(accuracy_op, feed_dict=tensor_trainI)) + ' ' +
str(sess.run(accuracy_op, feed_dict=tensor_testI)))
else:
sess.run(train_op, feed_dict=tensor_train)
if i % 10 == 0:
print(
str(sess.run(accuracy_op, feed_dict=tensor_train)) + ' ' +
str(sess.run(accuracy_op, feed_dict=tensor_test)))
elif i % 10 == 0:
np.random_shuffle(train2)
tensor_train = {
xs:
X[train2[0:bs], :],
yin:
sess.run(
get_yn(
sess.run(predict,
feed_dict={xs: X[train2[0:bs], :]}),
Y[train2[0:bs], :], delta, tau, output_feats))
}
if prt:
blah = sess.run(predict, feed_dict=tensor_test)
sio.savemat('preds_cv' + str(cv) + '.mat', {'preds': blah})
sio.savemat('truth_cv' + str(cv) + '.mat', {'labels': Y[test, :]})
acc = sess.run(accuracy_op, feed_dict=tensor_test)
print(
"loss1=%.4f, gamma=%.4f, delta=%.4f, tau=%.4f, prc_cut=%i, bs_prc=%.4f, num_trees=%i, max_nodes=%i"
% (acc, gamma, delta, tau, prc_cut, bs_prc, num_trees, max_nodes))
tf.reset_default_graph()
return (acc)
def run_LAmbDA(gamma, delta, tau, prc_cut, bs_prc, do_prc, hidden_feats,
lambda1, lambda2, lambda3):
print(
"gamma=%.4f, delta=%.4f, tau=%.4f, prc_cut=%.4f, bs_prc=%.4f, do_prc=%.4f, hidden_feats=%.4f, lambda1= %.4f, lambda2= %.4f, lambda3= %.4f"
% (gamma, delta, tau, prc_cut, bs_prc, do_prc, hidden_feats, lambda1,
lambda2, lambda3))
global X, Y, Gnp, Dnp, train, test, prt
D = tf.cast(Dnp, tf.float32)
G = tf.cast(Gnp, tf.float32)
hidden_feats = int(math.floor(hidden_feats))
input_feats = X.shape[1]
num_labls = G.shape.as_list()
output_feats = num_labls[1]
num_labls = num_labls[0]
rowsums = np.sum(Gnp, axis=1)
#print(G.shape)
train2 = resample(prc_cut, Y, Gnp, train, gamma)
bs = int(np.ceil(bs_prc * train2.size))
xs = tf.placeholder(tf.float32, [None, input_feats])
ys = tf.placeholder(tf.float32, [None, num_labls])
#print(input_feats) # Testing
#print(hidden_feats) # Testing
layer1_1 = add_layer(xs,
input_feats,
hidden_feats,
activation_function=tf.sigmoid,
dropout_function=True,
lambda1=lambda1,
keep_prob1=do_prc)
predict_1 = add_layer(layer1_1,
hidden_feats,
output_feats,
activation_function=tf.nn.softmax,
dropout_function=False,
lambda1=lambda1)
layer1_2 = add_layer(xs,
input_feats,
hidden_feats,
activation_function=tf.sigmoid,
dropout_function=True,
lambda1=lambda1,
keep_prob1=do_prc)
predict_2 = add_layer(layer1_2,
hidden_feats,
output_feats,
activation_function=tf.nn.softmax,
dropout_function=False,
lambda1=lambda1)
layer1_3 = add_layer(xs,
input_feats,
hidden_feats,
activation_function=tf.sigmoid,
dropout_function=True,
lambda1=lambda1,
keep_prob1=do_prc)
predict_3 = add_layer(layer1_3,
hidden_feats,
output_feats,
activation_function=tf.nn.softmax,
dropout_function=False,
lambda1=lambda1)
layer1_4 = add_layer(xs,
input_feats,
hidden_feats,
activation_function=tf.sigmoid,
dropout_function=True,
lambda1=lambda1,
keep_prob1=do_prc)
predict_4 = add_layer(layer1_4,
hidden_feats,
output_feats,
activation_function=tf.nn.softmax,
dropout_function=False,
lambda1=lambda1)
layer1_5 = add_layer(xs,
input_feats,
hidden_feats,
activation_function=tf.sigmoid,
dropout_function=True,
lambda1=lambda1,
keep_prob1=do_prc)
predict_5 = add_layer(layer1_5,
hidden_feats,
output_feats,
activation_function=tf.nn.softmax,
dropout_function=False,
lambda1=lambda1)
yn_1 = get_yn(predict_1, ys, delta, tau, output_feats)
yn_2 = get_yn(predict_2, ys, delta, tau, output_feats)
yn_3 = get_yn(predict_3, ys, delta, tau, output_feats)
yn_4 = get_yn(predict_4, ys, delta, tau, output_feats)
yn_5 = get_yn(predict_5, ys, delta, tau, output_feats)
E_1 = get_Eucl(layer1_1, ys, num_labls)
E_2 = get_Eucl(layer1_2, ys, num_labls)
E_3 = get_Eucl(layer1_3, ys, num_labls)
E_4 = get_Eucl(layer1_4, ys, num_labls)
E_5 = get_Eucl(layer1_5, ys, num_labls)
M1 = (tf.cast(tf.matmul(G, tf.transpose(G)) > 0, tf.float32) *
(tf.ones([num_labls, num_labls]) -
tf.cast(tf.matmul(D, tf.transpose(D)) > 0, tf.float32))) / (
tf.matrix_band_part(
tf.matmul(tf.reshape(tf.reduce_sum(G, 1), (-1, 1)),
tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0) +
tf.transpose(
tf.matrix_band_part(
tf.matmul(tf.reshape(tf.reduce_sum(G, 1), (-1, 1)),
tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0)))
M2 = tf.cast(tf.matmul(D, tf.transpose(D)) > 0, tf.float32) / (
tf.matrix_band_part(
tf.matmul(
tf.reshape(
tf.reduce_sum(
tf.cast(tf.matmul(D, tf.transpose(D)) > 0, tf.float32),
1),
(-1, 1)), tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0) +
tf.transpose(
tf.matrix_band_part(
tf.matmul(
tf.reshape(
tf.reduce_sum(
tf.cast(
tf.matmul(D, tf.transpose(D)) > 0, tf.float32),
1),
(-1, 1)), tf.reshape(tf.ones([1, num_labls]),
(1, -1))), -1, 0)))
#***********************************************************************
# Cost function with new label matrix
iter = 2000
# Initialize to unambiguous labels
G2 = np.copy(Gnp)
G2[rowsums > 1, :] = 0
YI = np.matmul(Y, G2)
#print(YI)
YIrs = np.sum(YI, axis=1)
print(YIrs.shape)
G2 = tf.cast(G2, tf.float32)
yi = tf.matmul(ys, G2)
trainI = train2[np.in1d(train2, np.where(YIrs == 1))]
testI = test[np.in1d(test, np.where(YIrs == 1))]
lossI_1 = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - predict_1), reduction_indices=[1]))
lossI_2 = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - predict_2), reduction_indices=[1]))
lossI_3 = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - predict_3), reduction_indices=[1]))
lossI_4 = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - predict_4), reduction_indices=[1]))
lossI_5 = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - predict_5), reduction_indices=[1]))
lossI_All = tf.reduce_mean(
tf.reduce_sum(tf.square(yi - (
(predict_1 + predict_2 + predict_3 + predict_4 + predict_5) / 5)),
reduction_indices=[1]))
train_stepI_1 = tf.train.AdamOptimizer(learning_rate=0.01,
epsilon=1e-8).minimize(lossI_1)
train_stepI_2 = tf.train.AdamOptimizer(learning_rate=0.01,
epsilon=1e-8).minimize(lossI_2)
train_stepI_3 = tf.train.AdamOptimizer(learning_rate=0.01,
epsilon=1e-8).minimize(lossI_3)
train_stepI_4 = tf.train.AdamOptimizer(learning_rate=0.01,
epsilon=1e-8).minimize(lossI_4)
train_stepI_5 = tf.train.AdamOptimizer(learning_rate=0.01,
epsilon=1e-8).minimize(lossI_5)
# LAmbDA optimization
loss1_1 = tf.reduce_mean(
tf.reduce_sum(tf.square(yn_1 - predict_1), reduction_indices=[1]))
loss1_2 = tf.reduce_mean(
tf.reduce_sum(tf.square(yn_2 - predict_2), reduction_indices=[1]))
loss1_3 = tf.reduce_mean(
tf.reduce_sum(tf.square(yn_3 - predict_3), reduction_indices=[1]))
loss1_4 = tf.reduce_mean(
tf.reduce_sum(tf.square(yn_4 - predict_4), reduction_indices=[1]))
loss1_5 = tf.reduce_mean(
tf.reduce_sum(tf.square(yn_5 - predict_5), reduction_indices=[1]))
loss1_All = tf.reduce_mean(
tf.reduce_sum(tf.square(((yn_1 + yn_2 + yn_3 + yn_4 + yn_5) / 5) - (
(predict_1 + predict_2 + predict_3 + predict_4 + predict_5) / 5)),
reduction_indices=[1]))
train_step_1 = tf.train.AdamOptimizer(
learning_rate=0.01,
epsilon=1e-8).minimize(loss1_1 + lambda2 * tf.reduce_mean(E_1 * M1) -
lambda3 * tf.reduce_mean(E_1 * M2))
train_step_2 = tf.train.AdamOptimizer(
learning_rate=0.01,
epsilon=1e-8).minimize(loss1_2 + lambda2 * tf.reduce_mean(E_2 * M1) -
lambda3 * tf.reduce_mean(E_2 * M2))
train_step_3 = tf.train.AdamOptimizer(
learning_rate=0.01,
epsilon=1e-8).minimize(loss1_3 + lambda2 * tf.reduce_mean(E_3 * M1) -
lambda3 * tf.reduce_mean(E_3 * M2))
train_step_4 = tf.train.AdamOptimizer(
learning_rate=0.01,
epsilon=1e-8).minimize(loss1_4 + lambda2 * tf.reduce_mean(E_4 * M1) -
lambda3 * tf.reduce_mean(E_4 * M2))
train_step_5 = tf.train.AdamOptimizer(
learning_rate=0.01,
epsilon=1e-8).minimize(loss1_5 + lambda2 * tf.reduce_mean(E_5 * M1) -
lambda3 * tf.reduce_mean(E_5 * M2))
train_step_All = tf.train.AdamOptimizer(
learning_rate=0.01, epsilon=1e-8
).minimize(loss1_All + lambda2 * tf.reduce_mean(
((E_1 + E_2 + E_3 + E_4 + E_5) / 5) * M1) - lambda3 * tf.reduce_mean(
((E_1 + E_2 + E_3 + E_4 + E_5) / 5) * M2)) #******Testing********
#train_step = tf.train.AdamOptimizer(learning_rate=0.01,epsilon=1e-8).minimize(loss1+(lambda2*(tf.reduce_sum(E*M1)/tf.cast(tf.count_nonzero(M1>0),tf.float32)))-(lambda3*(tf.reduce_sum(E*M2)/tf.cast(tf.count_nonzero(M2>0),tf.float32))))
init = tf.global_variables_initializer()
trainI.astype(int)
tensor_trainI = {xs: X[trainI, :], ys: Y[trainI, :]}
tensor_testI = {xs: X[testI, :], ys: Y[testI, :]}
tensor_train = {xs: X[train2[0:bs], :], ys: Y[train2[0:bs], :]}
tensor_test = {xs: X[test, :], ys: Y[test, :]}
# run training process
sess = tf.Session()
sess.run(init)
for i in range(iter + 1):
if i <= 1000: # changed
sess.run(train_stepI_1, feed_dict=tensor_trainI)
sess.run(train_stepI_2, feed_dict=tensor_trainI)
sess.run(train_stepI_3, feed_dict=tensor_trainI)
sess.run(train_stepI_4, feed_dict=tensor_trainI)
sess.run(train_stepI_5, feed_dict=tensor_trainI)
if i % 10 == 0:
print(
str(sess.run(lossI_All, feed_dict=tensor_trainI)) + ' ' +
str(sess.run(lossI_All, feed_dict=tensor_testI)))
else:
sess.run(train_step_1, feed_dict=tensor_train)
sess.run(train_step_2, feed_dict=tensor_train)
sess.run(train_step_3, feed_dict=tensor_train)
sess.run(train_step_4, feed_dict=tensor_train)
sess.run(train_step_5, feed_dict=tensor_train)
#sess.run(train_step_All, feed_dict=tensor_train) #************Testing********************
if i % 10 == 0:
print(
str(sess.run(loss1_All, feed_dict=tensor_train)) + ' ' +
str(sess.run(loss1_All, feed_dict=tensor_test)) + ' ' +
str(lambda2 * sess.run(tf.reduce_mean((
(E_1 + E_2 + E_3 + E_4 + E_5) / 5) * M1),
feed_dict=tensor_train)) + ' ' +
str(lambda3 * sess.run(tf.reduce_mean((
(E_1 + E_2 + E_3 + E_4 + E_5) / 5) * M2),
feed_dict=tensor_train)))
elif i % 50 == 0:
np.random_shuffle(train2)
tensor_train = {xs: X[train2[0:bs], :], ys: Y[train2[0:bs], :]}
if prt:
blah = sess.run(
(predict_1 + predict_2 + predict_3 + predict_4 + predict_5) / 5,
feed_dict=tensor_test)
blah2_1 = sess.run(layer1_1, feed_dict=tensor_test)
blah2_2 = sess.run(layer1_1, feed_dict=tensor_test)
blah2_3 = sess.run(layer1_1, feed_dict=tensor_test)
blah2_4 = sess.run(layer1_1, feed_dict=tensor_test)
blah2_5 = sess.run(layer1_1, feed_dict=tensor_test)
sio.savemat('preds_cv' + str(cv) + '.mat', {'preds': blah})
sio.savemat('truth_cv' + str(cv) + '.mat', {'labels': Y[test, :]})
sio.savemat(
'hidden_cv' + str(cv) + '.mat', {
'hidden1': blah2_1,
'hidden2': blah2_2,
'hidden3': blah2_3,
'hidden4': blah2_4,
'hidden5': blah2_5
})
print(
"loss1_All=%.4f, gamma=%.4f, delta=%.4f, tau=%.4f, prc_cut=%.4f, bs_prc=%.4f, do_prc=%.4f, hidden_feats=%.4f, lambda1= %.4f, lambda2= %.4f, lambda3= %.4f"
% (sess.run(loss1_All, feed_dict=tensor_test), gamma, delta, tau,
prc_cut, bs_prc, do_prc, hidden_feats, lambda1, lambda2, lambda3))
acc = sess.run(loss1_All, feed_dict=tensor_test)
tf.reset_default_graph()
return (acc)
