"""Traing a given non time-series network by the given cost function, training data, batch_size, n_epoch etc.

assert X_train.shape[0] >= batch_size, "Number of training examples should be bigger than the batch size"

print("Start training the network ...")

start_time_begin = time.time()

for epoch in range(n_epoch):

start_time = time.time()

loss_ep = 0; n_step = 0

for X_train_a, y_train_a in iterate.minibatches(X_train, y_train,

batch_size, shuffle=True):

feed_dict = {x: X_train_a, y_: y_train_a}

feed_dict.update( network.all_drop ) # enable noise layers

loss, _ = sess.run([cost, train_op], feed_dict=feed_dict)

loss_ep += loss

n_step += 1

loss_ep = loss_ep/ n_step

if epoch + 1 == 1 or (epoch + 1) % print_freq == 0:

if (X_val is not None) and (y_val is not None):

print("Epoch %d of %d took %fs" % (epoch + 1, n_epoch, time.time() - start_time))

if eval_train is True:

train_loss, train_acc, n_batch = 0, 0, 0

for X_train_a, y_train_a in iterate.minibatches(

X_train, y_train, batch_size, shuffle=True):

dp_dict = dict_to_one( network.all_drop ) # disable noise layers

feed_dict = {x: X_train_a, y_: y_train_a}

feed_dict.update(dp_dict)

if acc is not None:

err, ac = sess.run([cost, acc], feed_dict=feed_dict)

train_acc += ac

else:

err = sess.run(cost, feed_dict=feed_dict)

train_loss += err; n_batch += 1

print(" train loss: %f" % (train_loss/ n_batch))

if acc is not None:

print(" train acc: %f" % (train_acc/ n_batch))

val_loss, val_acc, n_batch = 0, 0, 0

for X_val_a, y_val_a in iterate.minibatches(

X_val, y_val, batch_size, shuffle=True):

dp_dict = dict_to_one( network.all_drop ) # disable noise layers

feed_dict = {x: X_val_a, y_: y_val_a}

feed_dict.update(dp_dict)

if acc is not None:

err, ac = sess.run([cost, acc], feed_dict=feed_dict)

val_acc += ac

else:

err = sess.run(cost, feed_dict=feed_dict)

val_loss += err; n_batch += 1

print(" val loss: %f" % (val_loss/ n_batch))

if acc is not None:

print(" val acc: %f" % (val_acc/ n_batch))

else:

print("Epoch %d of %d took %fs, loss %f" % (epoch + 1, n_epoch, time.time() - start_time, loss_ep))

"""

print('Start testing the network ...')

if batch_size is None:

dp_dict = dict_to_one( network.all_drop )

feed_dict = {x: X_test, y_: y_test}

feed_dict.update(dp_dict)

if cost is not None:

print(" test loss: %f" % sess.run(cost, feed_dict=feed_dict))

print(" test acc: %f" % sess.run(acc, feed_dict=feed_dict))

# print(" test acc: %f" % np.mean(y_test == sess.run(y_op,

# feed_dict=feed_dict)))

else:

test_loss, test_acc, n_batch = 0, 0, 0

for X_test_a, y_test_a in iterate.minibatches(

X_test, y_test, batch_size, shuffle=True):

dp_dict = dict_to_one( network.all_drop ) # disable noise layers

feed_dict = {x: X_test_a, y_: y_test_a}

feed_dict.update(dp_dict)

if cost is not None:

err, ac = sess.run([cost, acc], feed_dict=feed_dict)

test_loss += err

else:

ac = sess.run(acc, feed_dict=feed_dict)

test_acc += ac; n_batch += 1

if cost is not None:

print(" test loss: %f" % (test_loss/ n_batch))

"""

dp_dict = dict_to_one( network.all_drop ) # disable noise layers

feed_dict = {x: X,}

feed_dict.update(dp_dict)

"""

from sklearn.metrics import confusion_matrix, f1_score, accuracy_score

c_mat = confusion_matrix(y_test, y_predict, labels = [x for x in range(n_classes)])

f1 = f1_score(y_test, y_predict, average = None, labels = [x for x in range(n_classes)])

f1_macro = f1_score(y_test, y_predict, average='macro')

acc = accuracy_score(y_test, y_predict)

print('confusion matrix: \n',c_mat)

print('f1-score:',f1)

print('f1-score(macro):',f1_macro) # same output with > f1_score(y_true, y_pred, average='macro')

print('accuracy-score:', acc)

"""

"""

"""Input the features and labels, return the features and labels after oversampling.

# ======== Classes balancing

if printable:

print("Classes balancing for training examples...")

from collections import Counter

c = Counter(y_train)

if printable:

print('the occurrence number of each stage: %s' % c.most_common())

print('the least stage is Label %s have %s instances' % c.most_common()[-1])

print('the most stage is Label %s have %s instances' % c.most_common(1)[0])

most_num = c.most_common(1)[0][1]

if printable:

print('most num is %d, all classes tend to be this num' % most_num)

locations = {}

number = {}

for lab, num in c.most_common(): # find the index from y_train

number[lab] = num

locations[lab] = np.where(np.array(y_train)==lab)[0]

if printable:

print('convert list(np.array) to dict format')

X = {} # convert list to dict

for lab, num in number.items():

X[lab] = X_train[locations[lab]]

# oversampling

if printable:

print('start oversampling')

for key in X:

temp = X[key]

while True:

if len(X[key]) >= most_num:

break

X[key] = np.vstack((X[key], temp))

if printable:

print('first features of label 0 >', len(X[0][0]))

print('the occurrence num of each stage after oversampling')

for key in X:

print(key, len(X[key]))

if printable:

print('make each stage have same num of instances')

for key in X:

X[key] = X[key][0:most_num,:]

print(key, len(X[key]))

# convert dict to list

if printable:

print('convert from dict to list format')

y_train = []

X_train = np.empty(shape=(0,len(X[0][0])))

for key in X:

X_train = np.vstack( (X_train, X[key] ) )

y_train.extend([key for i in range(len(X[key]))])

# print(len(X_train), len(y_train))

c = Counter(y_train)

if printable:

print('the occurrence number of each stage after oversampling: %s' % c.most_common())

# ================ End of Classes balancing