def test(model_directory, input_image):
# Import data
test_img = cv2.imread(input_image, 0)
if test_img.shape != [28, 28]:
test_img = cv2.resize(test_img, (28, 28))
test_img = test_img.reshape(28, 28, -1)
else:
test_img = test_img.reshape(28, 28, -1)
test_img = test_img.reshape(-1, 784)
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
saver.restore(sess, model_directory)
acc_buffer = []
y_final = sess.run(y, feed_dict={x: test_img, is_training: False})
print("prediction value : {}".format(y_final[0].argmax()))
def test_ensemble(model_directory_list, batch_size):
# Import data
PIXEL_DEPTH = mnist_data.PIXEL_DEPTH
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(
False)
is_training = tf.placeholder(tf.bool, name='MODE')
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 45 * 45])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
# Calculate accuracy for all mnist test images
test_size = 10000
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = numpy.zeros_like(batch_ys)
for dir in model_directory_list:
print(dir)
saver.restore(sess, dir + '/model.ckpt')
pred = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
y_final += one_hot_matrix(
pred) # take a majority vote as an answer
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
def test_ensemble(model_directory_list, batch_size):
# Import data
PIXEL_DEPTH = mnist_data.PIXEL_DEPTH
mnist = input_data.read_data_sets('data/', one_hot=True)
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
# Calculate accuracy for all mnist test images
test_size = mnist.test.num_examples
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
batch = mnist.test.next_batch(batch_size)
batch_xs = (
batch[0] - (PIXEL_DEPTH / 2.0) / PIXEL_DEPTH
) # make zero-centered distribution as in mnist_data.extract_data()
batch_ys = batch[1]
y_final = numpy.zeros_like(batch_ys)
for dir in model_directory_list:
saver.restore(sess, dir + '/model.ckpt')
pred = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
y_final += one_hot_matrix(
pred) # take a majority vote as an answer
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
def load_top_level_weights(params):
print("-" * 50)
print("Testing...")
embedding_weight = params["embedding_weight"]
embedding_dimensions = params["embedding_dimensions"]
input_data = params["input_data"]
cnn_params = {
"cudnn": USE_CUDNN,
"out_channels": params["out_channels"],
"row_dim": embedding_dimensions,
"batch_size": params["batchsize"],
"hidden_dim": params["unit"],
"n_classes": params["output_dimensions"],
"embedding_weight": embedding_weight,
}
x_tst = input_data['x_tst']
y_tst = input_data['y_tst']
n_eval = len(x_tst)
cnn_params['mode'] = 'test-predict'
cnn_params['load_param_node_name'] = params["current_depth"]
if params["model_type"] == "XML-CNN":
model = xml_cnn_model.CNN(**cnn_params)
else:
model = cnn_model.CNN(**cnn_params)
model.to_gpu()
output = np.zeros([n_eval, params["output_dimensions"]], dtype=np.int8)
output_probability_file_name = "CNN/RESULT/probability_" + params[
"current_depth"] + ".csv"
with open(output_probability_file_name, 'w') as f:
f.write(','.join(params["learning_categories"]) + "\n")
test_batch_size = params["batchsize"]
with chainer.using_config('train', False), chainer.no_backprop_mode():
for i in tqdm(six.moves.range(0, n_eval, test_batch_size),
desc="Predict Test loop"):
x = chainer.Variable(
chainer.cuda.to_gpu(X_tst[i:i + params["batchsize"]]))
t = Y_tst[i:i + test_batch_size]
net_output = F.sigmoid(model(x))
output[i:i + test_batch_size] = select_function(net_output.data)
with open(output_probability_file_name, 'a') as f:
tmp = chainer.cuda.to_cpu(net_output.data)
low_values_flags = tmp < 0.001
tmp[low_values_flags] = 0
np.savetxt(f, tmp, fmt='%.4g', delimiter=",")
return output
def test_org(model_directory, batch_size):
# Import data
PIXEL_DEPTH = mnist_data.PIXEL_DEPTH
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(
False)
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
# Calculate accuracy for all mnist test images
test_size = test_labels.shape[0]
total_batch = int(test_size / batch_size)
saver.restore(sess, model_directory)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
def test(args, model_directory):
# Import data
input_size = args.input_size
num_classes = args.num_classes
batch_size = args.batch_size
test_data, img_prefixes = load_data.prepare_cosmology_test_data(args)
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, input_size*input_size])
y = cnn_model.CNN(args, x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
ckpt = tf.train.get_checkpoint_state(args.model_dir)
if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):
print("Reading model parameters from %s" % ckpt.model_checkpoint_path)
saver = tf.train.Saver()
saver.restore(sess, ckpt.model_checkpoint_path)
else:
print("Created model with fresh parameters.")
session.run(tf.global_variables_initializer())
# Calculate accuracy for all mnist test images
test_size = test_data.shape[0]
total_batch = test_size/batch_size if test_size%batch_size==0 else int(test_size / batch_size) + 1
res = []
# Loop over all batches
for i in range(total_batch):
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
y_final = sess.run(y, feed_dict={x: batch_xs, is_training: False})
res.extend(y_final.flatten())
pred = dict(zip(img_prefixes, res))
print(pred)
df = pd.DataFrame.from_dict(pred, orient="index")
df = df.reset_index()
df.to_csv(os.path.join(args.data_dir, "prediction.csv"), header=["Id", "Predicted"], index=False)
def train():
preprocess()
vocab, rev_vocab = data_utils.initialize_vocabulary(FLAGS.vocabulary_file)
embeddings = data_utils.get_trimmed_glove_vectors(FLAGS.save_embedding_file)
model = cnn_model.CNN(
batch_size=FLAGS.batch_size,
word_embedding=embeddings,
sent_len=FLAGS.max_sentence_len,
input_type=FLAGS.input_layer_type,
word_num=len(rev_vocab),
word_dim=FLAGS.embedding_dim,
vocab=vocab,
l2_alpha=FLAGS.l2_reg_lambda,
dropout_prob=FLAGS.dropout_keep_prob,
kernel_num=FLAGS.num_filters,
learning_rate_base=FLAGS.learning_rate,
epoch=FLAGS.num_epochs,
model_path=FLAGS.model_path
)
train_data = data_utils.text_dataset('./input/data/train_data.ids', FLAGS.max_sentence_len)
valid_data = data_utils.text_dataset('./input/data/valid_data.ids', FLAGS.max_sentence_len)
print('train data size ={a}, valid data zize ={b}'.format(a=train_data.__len__(), b=valid_data.__len__()))
model.train(train_data, valid_data)
def train():
batch_size = TRAIN_BATCH_SIZE
num_labels = 10
#input labels
train_labels0 = np.fromfile("mnist_train_label",dtype=np.uint8)
test_labels = np.fromfile("mnist_test_label",dtype=np.uint8)
#train labels= (label,label) (120000=60000*2)
train_labels0 = np.hstack((train_labels0,train_labels0))
train_labels0 = one_hot(train_labels0)
#input data
train_total_data0 = np.load('120000_train.npy')
#regularizztion
train_total_data0 = (train_total_data0 - (255 / 2.0)) / 255
train_total_data0 = np.reshape(train_total_data0,(120000, 400))
#shuffle the train data and label at the same time
#permutation = np.random.permutation(train_total_data0.shape[0])
#train_total_data0 = train_total_data0[permutation, :]
#train_labels0= train_labels0[permutation]
#validation/train set split, train:val=5:1
train_total_data = train_total_data0[20000:,]
validation_data = train_total_data0[:20000,]
train_labels = train_labels0[20000:,]
validation_labels = train_labels0[:20000,]
train_total_data = np.concatenate((train_total_data, train_labels),axis=1)
train_size = train_total_data.shape[0]
#print(train_size)
test_data = np.load('10000_test.npy')
test_data = (test_data - (255 / 2.0)) / 255
test_data = np.reshape(test_data,(10000, 400))
is_training = tf.placeholder(tf.bool, name='MODE')
x = tf.placeholder(tf.float32, [None, 400])
y_ = tf.placeholder(tf.float32, [None, 10])
#train the model
y = cnn_model.CNN(x)
#Calculate the loss
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y,y_)
# Create a summary to monitor loss tensor
tf.summary.scalar('loss', loss)
# Define optimizer
with tf.name_scope("ADAM"):
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(
1e-4, #learning rate
batch * batch_size,
train_size,
0.95, # Decay rate.
staircase=True)
# Use simple momentum for the optimization.
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss,global_step=batch)
# Calculate learning rate
tf.summary.scalar('learning_rate', learning_rate)
# Calculate accuracy
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('acc', accuracy)
# Merge
merged_summary_op = tf.summary.merge_all()
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
total_batch = int(train_size / batch_size)
#Write into the log
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY, graph=tf.get_default_graph())
max_acc = 0.
#train
for epoch in range(training_epochs)
#shuffling
np.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-num_labels]
train_labels_ = train_total_data[:, -num_labels:]
for i in range(total_batch):
#get the train x and y
offset = (i * batch_size) % (train_size)
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
#run the session
_, train_accuracy, summary = sess.run([train_step, accuracy, merged_summary_op] , feed_dict={x: batch_xs, y_: batch_ys, is_training: True})
summary_writer.add_summary(summary, epoch * total_batch + i)
if i % display_step == 0:
print("Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, training accuracy %.5f" % (i, total_batch, train_accuracy))
# display validation accuracy
if i % validation_step == 0:
validation_accuracy = sess.run(accuracy,
feed_dict={x: validation_data, y_: validation_labels, is_training: False})
print("Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, validation accuracy %.5f" % (i, total_batch, validation_accuracy))
# Save the model
if validation_accuracy > max_acc:
max_acc = validation_accuracy
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model updated and saved in file: %s" % save_path)
print("Optimization Finished!")
saver.restore(sess, MODEL_DIRECTORY)
# Calculate test accuracy
test_size = test_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
acc_buffer = []
for i in range(total_batch):
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y, feed_dict={x: batch_xs, y_: batch_ys, is_training: False})
correct_prediction = np.equal(np.argmax(y_final, 1), np.argmax(batch_ys, 1))
acc_buffer.append(np.sum(correct_prediction) / batch_size)
print("test accuray for the stored model: %.5f" % np.mean(acc_buffer))
def train():
# Some parameters
batch_size = TRAIN_BATCH_SIZE
num_labels = data.NUM_LABELS
# Prepare mnist data
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = data.prepare_MNIST_data(
True)
# Boolean for MODE of train or test
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 35]) #answer
# Predict
y = cnn_model.CNN(x)
# Get loss of model
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
# Create a summary to monitor loss tensor
tf.summary.scalar('loss', loss)
# Define optimizer
with tf.name_scope("ADAM"):
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(
1e-4, # Base learning rate.
batch * batch_size, # Current index into the dataset.
train_size, # Decay step.
0.95, # Decay rate.
staircase=True)
# Use simple momentum for the optimization.
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
loss, global_step=batch)
# Create a summary to monitor learning_rate tensor
tf.summary.scalar('learning_rate', learning_rate)
# Get accuracy of model
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Create a summary to monitor accuracy tensor
tf.summary.scalar('acc', accuracy)
# Merge all summaries into a single op
merged_summary_op = tf.summary.merge_all()
# Add ops to save and restore all the variables
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Training cycle
total_batch = int(train_size / batch_size)
# op to write logs to Tensorboard
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY,
graph=tf.get_default_graph())
# Save the maximum accuracy value for validation data
max_acc = 0.
# Loop for epoch
for epoch in range(training_epochs):
# Random shuffling
numpy.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-num_labels]
train_labels_ = train_total_data[:, -num_labels:]
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (train_size)
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
# Run optimization op (backprop), loss op (to get loss value)
# and summary nodes
_, train_accuracy, summary = sess.run(
[train_step, accuracy, merged_summary_op],
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: True
})
# Write logs at every iteration
summary_writer.add_summary(summary, epoch * total_batch + i)
# Display logs
if i % display_step == 0:
print(
"Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, training accuracy %.5f" %
(i, total_batch, train_accuracy))
# Get accuracy for validation data
if i % validation_step == 0:
# Calculate accuracy
validation_accuracy = sess.run(accuracy,
feed_dict={
x: validation_data,
y_: validation_labels,
is_training: False
})
print(
"Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, validation accuracy %.5f" %
(i, total_batch, validation_accuracy))
# Save the current model if the maximum accuracy is updated
if validation_accuracy > max_acc:
max_acc = validation_accuracy
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model updated and saved in file: %s" % save_path)
print("Optimization Finished!")
# Restore variables from disk
saver.restore(sess, MODEL_DIRECTORY)
# Calculate accuracy for all mnist test images
test_size = test_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
def train():
# Prepare data
T_train, W_train, T_val, W_val, T_test, W_test = prepare_data.getalldata(
rootpath)
train_size = T_train.shape[0]
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 8, 8, 39])
y_ = tf.placeholder(tf.float32, [None, 2])
# Predict
y = cnn_model.CNN(x, is_training)
# Get loss of model
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
print(loss)
# Create a summary to monitor loss tensor
tf.summary.scalar('loss', loss)
# Define optimizer
with tf.name_scope("ADAM"):
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(
1e-4, # Base learning rate.
batch * batch_size, # Current index into the dataset.
train_size, # Decay step.
0.95, # Decay rate.
staircase=True)
# Use simple momentum for the optimization.
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
loss, global_step=batch)
# Create a summary to monitor learning_rate tensor
tf.summary.scalar('learning_rate', learning_rate)
# Get accuracy of model
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Create a summary to monitor accuracy tensor
tf.summary.scalar('acc', accuracy)
# Merge all summaries into a single op
merged_summary_op = tf.summary.merge_all()
# Add ops to save and restore all the variables
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Training cycle
total_batch = int(train_size / batch_size)
# op to write logs to Tensorboard
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY,
graph=tf.get_default_graph())
# Save the maximum accuracy value for validation data
max_acc = 0.
# Loop for epoch
for epoch in range(training_epochs):
# Loop over all batches
for batch_T, batch_W in prepare_data.minibatches(T_train,
W_train,
batch_size,
shuffle=True):
i = 0
_, train_loss, train_accuracy, summary = sess.run(
[train_step, loss, accuracy, merged_summary_op],
feed_dict={
x: batch_T,
y_: batch_W,
is_training: True
})
# Write logs at every iteration
summary_writer.add_summary(summary, epoch * total_batch + i)
# Display logs
if i % display_step == 0:
print(
"Epoch:", '%4d,' % (epoch),
"batch_index %4d/%4d,training loss %.5f, training accuracy %.5f"
% (i, total_batch, train_loss, train_accuracy))
# Get accuracy for validation data
if i % validation_step == 0:
# Calculate accuracy
score, validation_loss, validation_accuracy = sess.run(
[y, loss, accuracy],
feed_dict={
x: T_val,
y_: W_val,
is_training: False
})
print(
"Epoch:", '%4d,' % (epoch),
"batch_index %4d/%4d, validation loss %.5f,validation accuracy %.5f"
% (i, total_batch, validation_loss, validation_accuracy))
i += 1
# Save the current model if the maximum accuracy is updated
if validation_accuracy > max_acc:
max_acc = validation_accuracy
#best_y_score=score
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model updated and saved in file: %s" % save_path)
#打乱
index = [i for i in range(train_size)]
random.shuffle(index)
X_train = X_train[index]
Y_train = Y_train[index]
print("Max acc: %.5f" % max_acc)
print("Optimization Finished!")
# Restore variables from disk
saver.restore(sess, MODEL_DIRECTORY)
y_final = sess.run(y,
feed_dict={
x: T_test,
y_: W_test,
is_training: False
})
correct_prediction = np.equal(np.argmax(y_final, 1), np.argmax(W_test, 1))
print("test accuracy for the stored model: %f" %
np.mean(correct_prediction))
sess.close()
#AUC
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(2):
fpr[i], tpr[i], _ = roc_curve(W_test[:, i], y_final[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
print("auc of player0:%f" % roc_auc[0])
print("auc of player1:%f" % roc_auc[1])
# micro average
fpr["micro"], tpr["micro"], _ = roc_curve(W_test.ravel(), y_final.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
print("auc of micro:%f" % roc_auc["micro"])
plt.figure()
plt.plot(fpr["micro"],
tpr["micro"],
label='CNNs roc of micro (auc = {0:0.2f})'
''.format(roc_auc["micro"]),
color='green',
linestyle='-',
linewidth=1.5)
plt.plot([0, 1], [0, 1], 'k--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.title('ROC Curves and AUC values')
plt.legend(loc="lower right")
plt.show()
def train(f_maps,
conv_stride,
maxp_stride,
use_augmentation=True,
use_downsampling=True,
training_epochs=training_epochs):
batch_size = TRAIN_BATCH_SIZE
num_labels = mnist_data.NUM_LABELS
total_train_data, train_size, validation_data, validation_labels = mnist_data.read_mnist_data(
use_augmentation)
is_training = tf.placeholder(tf.bool, name='MODE')
# Tensorflow variables should be initialized.
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])
y = cnn_model.CNN(x,
feature_maps=f_maps,
conv_stride=conv_stride,
maxp_stride=maxp_stride,
use_downsampling=use_downsampling)
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
tf.summary.scalar('loss', loss)
with tf.name_scope("ADAM"):
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(1e-4,
batch * batch_size,
train_size,
0.95,
staircase=True)
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
loss, global_step=batch)
tf.summary.scalar('learning_rate', learning_rate)
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('acc', accuracy)
merged_summary_op = tf.summary.merge_all()
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
total_batch = int(train_size / batch_size)
# Writing a log file is optional
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY,
graph=tf.get_default_graph())
for epoch in range(training_epochs):
np.random.shuffle(total_train_data)
train_data_ = total_train_data[:, :-num_labels]
train_labels_ = total_train_data[:, -num_labels:]
for i in range(total_batch):
offset = (i * batch_size) % train_size
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
_, train_accuracy, summary = sess.run(
[train_step, accuracy, merged_summary_op],
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: True
})
# Optional
summary_writer.add_summary(summary, epoch * total_batch + i)
if i % display_step == 0:
print(
"Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, Training accuracy: %.5f" %
(i, total_batch, train_accuracy))
saver.save(sess, MODEL_DIRECTORY)
test_size = validation_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
saver.restore(sess, MODEL_DIRECTORY)
acc_buffer = []
for i in range(total_batch):
offset = (i * batch_size) % test_size
batch_xs = validation_data[offset:(offset + batch_size), :]
batch_ys = validation_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = np.equal(np.argmax(y_final, 1),
np.argmax(batch_ys, 1))
acc_buffer.append(np.sum(correct_prediction) / batch_size)
print("Test accuracy for this model: %g" % np.mean(acc_buffer))
# 混淆矩阵
print("Confusion Matrix...")
cm = metrics.confusion_matrix(y_test_cls, y_pred_cls)
print(cm)
time_dif = get_time_dif(start_time)
print("Time usage:", time_dif)
if __name__ == '__main__':
if len(sys.argv) != 2 or sys.argv[1] not in ['train', 'test']:
raise ValueError("""usage: python run_cnn.py [train / test]""")
print('Configuring CNN model...')
config = cnn_model.CNNConfig()
test_set = 9
val_set = 0
if not os.path.exists(vocab_dir): # 如果不存在词汇表，重建
build_vocab(val_set, test_set, image_add, vocab_dir, config.vocab_size)
categories, cat_to_id = read_category()
words, word_to_id = read_vocab(vocab_dir)
config.vocab_size = len(words)
model = cnn_model.CNN(config)
if sys.argv[1] == 'train':
train(val_set, test_set)
else:
test(val_set, test_set)
#input=morphology.dilation(mask,morphology.square(2))
#outfile = open('image_3.txt', 'rb')
#input = np.load(outfile)
#input=np.reshape(input,(28,28))
plt.subplot(2, 2, 4)
plt.imshow(input, cmap='gray')
input = np.reshape(input, (1, 784))
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
#tf.reset_default_graph()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
saver.restore(sess, '.\\model\\model.ckpt')
acc_buffer = []
# Loop over all batches
y_final = sess.run(y, feed_dict={x: input, is_training: False})
print(y_final)
print('final result is :{0}'.format(np.argmax(y_final, 1)))
def main(params):
#ハイパーパラメータの表示
print("")
print('# gpu: {}'.format(params["gpu"]))
print('# unit: {}'.format(params["unit"]))
print('# batch-size: {}'.format(params["batchsize"]))
print('# epoch: {}'.format(params["epoch"]))
print('# number of category: {}'.format(params["output-dimensions"]))
print('# embedding dimension: {}'.format(params["embedding-dimensions"]))
print('# current layer: {}'.format(params["currentDepth"]))
print('# model-type: {}'.format(params["model-type"]))
print('')
#ハイパーパラメータの書き出し
f = open('./CNN/LOG/configuration_' + params["currentDepth"] + '.txt', 'w')
f.write('# gpu: {}'.format(params["gpu"])+"\n")
f.write('# unit: {}'.format(params["unit"])+"\n")
f.write('# batch-size: {}'.format(params["batchsize"])+"\n")
f.write('# epoch: {}'.format(params["epoch"])+"\n")
f.write('# number of category: {}'.format(params["output-dimensions"])+"\n")
f.write('# embedding dimension: {}'.format(params["embedding-dimensions"])+"\n")
f.write('# current layer: {}'.format(params["currentDepth"])+"\n")
f.write('# model-type: {}'.format(params["model-type"])+"\n")
f.write("\n")
f.close()
#分散表現
embeddingWeights = params["embeddingWeights"]
embeddingDimensions = params["embedding-dimensions"]
#訓練データと検証データxがテキスト、yが正解クラス
inputData = params["inputData"]
x_train = inputData['X_trn']
x_test = inputData['X_val']
y_train = inputData['Y_trn']
y_test = inputData['Y_val']
y_train_e = inputData['origin_Y_trn']
#CNNのハイパーパラメータ
cnn_params = {"cudnn":USE_CUDNN,
"out_channels":params["outchannels"],
"row_dim":embeddingDimensions,
"batch_size":params["batchsize"],
"hidden_dim":params["unit"],
"n_classes":params["output-dimensions"],
"embeddingWeights":embeddingWeights,
}
#CNNのモデルを定義
if params["fineTuning"] == 0:
cnn_params['mode'] = 'scratch'
elif params["fineTuning"] == 1:
cnn_params['mode'] = 'fine-tuning'
cnn_params['load_param_node_name'] = params['upperDepth']
if params["model-type"] == "XML-CNN":
model = xml_cnn_model.CNN(**cnn_params)
else:
model = cnn_model.CNN(**cnn_params)
if params["gpu"] >= 0:
chainer.cuda.get_device_from_id(params["gpu"]).use()
model.to_gpu()
#optimizerの設定
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
#テキストデータと正解クラスのタプルを作成する
train = tuple_dataset.TupleDataset(x_train, y_train)
test = tuple_dataset.TupleDataset(x_test, y_test)
#ミニバッチを自動で生成する
train_iter = chainer.iterators.SerialIterator(train, params["batchsize"], repeat=True, shuffle=False)
test_iter = chainer.iterators.SerialIterator(test, params["batchsize"], repeat = False, shuffle=False)
#早期終了の設定
#過学習を起こしてきたら学習を早めに切り上げる
stop_trigger = training.triggers.EarlyStoppingTrigger(
monitor='validation/main/loss',
max_trigger=(params["epoch"], 'epoch'))
#Updaterは学習の核となるもの
from MyUpdater import MyUpdater
updater = MyUpdater(train_iter, optimizer, params["output-dimensions"], device=params["gpu"])
trainer = training.Trainer(updater, stop_trigger, out='./CNN/')
#拡張機能
from MyEvaluator import MyEvaluator
trainer.extend(MyEvaluator(test_iter, model, class_dim=params["output-dimensions"], device=params["gpu"]))
trainer.extend(extensions.dump_graph('main/loss'))
#modelのパラメータ保存に関する部分
#誤差が最小になった時に全パラメータを保存
trainer.extend(extensions.snapshot_object(model, 'parameters_for_multi_label_model_' + params["value"] + '.npz'),trigger=training.triggers.MinValueTrigger('validation/main/loss',trigger=(1,'epoch')))
#学習のログを出力
trainer.extend(extensions.LogReport(log_name='LOG/log_' + params["currentDepth"] + ".txt", trigger=(1, 'epoch')))
#端末画面に表示させる
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'elapsed_time']))
trainer.extend(extensions.ProgressBar())
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch', file_name='LOG/loss_' + params["currentDepth"] + '.png'))
#学習開始
trainer.run()
#保存されるパラメータのパスの指定
filename = 'parameters_for_multi_label_model_' + params["currentDepth"] + '.npz'
src = './CNN/'
dst = './CNN/PARAMS'
shutil.move(os.path.join(src, filename), os.path.join(dst, filename))
#テスト（推論）
print ("-"*50)
print ("Testing...")
X_tst = inputData['X_tst']
Y_tst = inputData['Y_tst']
N_eval = len(X_tst)
#上の層の学習でのパラメータを読み込む
cnn_params['mode'] = 'test-predict'
cnn_params['load_param_node_name'] = params["currentDepth"]
#モデルの指定
if params["model-type"] == "XML-CNN":
model = xml_cnn_model.CNN(**cnn_params)
else:
model = cnn_model.CNN(**cnn_params)
model.to_gpu()
#ネットワークの出力を保存する行列を確保
output = np.zeros([N_eval,params["output-dimensions"]],dtype=np.int8)
#予測確率を書き出すためのファイル手続き
output_probability_file_name = "CNN/RESULT/probability_" + params["currentDepth"] + ".csv"
with open(output_probability_file_name, 'w') as f:
f.write(','.join(params["learning_categories"])+"\n")
#推論本体
test_batch_size = params["batchsize"]
with chainer.using_config('train', False), chainer.no_backprop_mode():
for i in tqdm(six.moves.range(0, N_eval, test_batch_size),desc="Predict Test loop"):
x = chainer.Variable(chainer.cuda.to_gpu(X_tst[i:i + test_batch_size]))
t = Y_tst[i:i + test_batch_size]
net_output = F.sigmoid(model(x))
output[i: i + test_batch_size] = select_function(net_output.data)
with open(output_probability_file_name , 'a') as f:
tmp = chainer.cuda.to_cpu(net_output.data)
low_values_flags = tmp < 0.001
tmp[low_values_flags] = 0
np.savetxt(f,tmp,fmt='%.4g',delimiter=",")
return output
def main_relabel(params):
print("")
print('# gpu: {}'.format(params["gpu"]))
print('# unit: {}'.format(params["unit"]))
print('# batch-size: {}'.format(params["batchsize"]))
print('# epoch: {}'.format(params["epoch"]))
print('# number of category: {}'.format(params["output-dimensions"]))
print('# embedding dimension: {}'.format(params["embedding-dimensions"]))
print('# current layer: {}'.format(params["currentDepth"]))
print('# model-type: {}'.format(params["model-type"]))
print('')
f = open('./CNN/LOG/configuration_' + params["currentDepth"] + '.txt', 'w')
f.write('# gpu: {}'.format(params["gpu"])+"\n")
f.write('# unit: {}'.format(params["unit"])+"\n")
f.write('# batch-size: {}'.format(params["batchsize"])+"\n")
f.write('# epoch: {}'.format(params["epoch"])+"\n")
f.write('# number of category: {}'.format(params["output-dimensions"])+"\n")
f.write('# embedding dimension: {}'.format(params["embedding-dimensions"])+"\n")
f.write('# current layer: {}'.format(params["currentDepth"])+"\n")
f.write('# model-type: {}'.format(params["model-type"])+"\n")
f.write("\n")
f.close()
embeddingWeights = params["embeddingWeights"]
embeddingDimensions = params["embedding-dimensions"]
value = params["value"]#現在のカテゴリー
inputData = params["inputData"]
x_train = inputData['X_trn']
x_test = inputData['X_val']
y_train = inputData['Y_trn']
y_test = inputData['Y_val']
changeflag = inputData['changeflag']#ラベルを変更するかどうかのフラグ
y_train_e = inputData['origin_Y_trn']#訓練データのテキスト
cnn_params = {"cudnn":USE_CUDNN,
"out_channels":params["outchannels"],
"row_dim":embeddingDimensions,
"batch_size":params["batchsize"],
"hidden_dim":params["unit"],
"n_classes":params["output-dimensions"],
"embeddingWeights":embeddingWeights,
}
if params["fineTuning"] == 0:
cnn_params['mode'] = 'scratch'
elif params["fineTuning"] == 1:
cnn_params['mode'] = 'fine-tuning'
cnn_params['load_param_node_name'] = params['upperDepth']
if params["model-type"] == "XML-CNN":
model = xml_cnn_model.CNN(**cnn_params)
else:
model = cnn_model.CNN(**cnn_params)
if params["gpu"] >= 0:
chainer.cuda.get_device_from_id(params["gpu"]).use()
model.to_gpu()
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
train = tuple_dataset.TupleDataset(x_train, y_train,y_train_e,changeflag)#y_train_e, changeflagを含めたタプルを作成
test = tuple_dataset.TupleDataset(x_test, y_test)
train_iter = chainer.iterators.SerialIterator(train, params["batchsize"], repeat=True, shuffle=False)
test_iter = chainer.iterators.SerialIterator(test, params["batchsize"], repeat = False, shuffle=False)
stop_trigger = training.triggers.EarlyStoppingTrigger(
monitor='validation/main/loss',
max_trigger=(params["epoch"], 'epoch'))
value = params["value"]
from MyUpdater import MyUpdater_relabel
updater = MyUpdater_relabel(train_iter, optimizer, params["output-dimensions"], value, device=params["gpu"])
trainer = training.Trainer(updater, stop_trigger, out='./CNN/')
from MyEvaluator import MyEvaluator
trainer.extend(MyEvaluator(test_iter, model, class_dim=params["output-dimensions"], device=params["gpu"]))
trainer.extend(extensions.dump_graph('main/loss'))
#valueごとにパラメータを保存
trainer.extend(extensions.snapshot_object(model, 'parameters_for_multi_label_model_' + params["value"] + '.npz'),trigger=training.triggers.MinValueTrigger('validation/main/loss',trigger=(1,'epoch')))
trainer.extend(extensions.LogReport(log_name='LOG/log_' + params["currentDepth"] + ".txt", trigger=(1, 'epoch')))
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'elapsed_time']))
trainer.extend(extensions.ProgressBar())
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch', file_name='LOG/loss_' + params["currentDepth"] + '.png'))
trainer.run()
filename = 'parameters_for_multi_label_model_' + params["value"] + '.npz'
src = './CNN/'
dst = './CNN/PARAMS'
shutil.move(os.path.join(src, filename), os.path.join(dst, filename))
print ("-"*50)
print ("Testing...")
X_tst = inputData['X_tst']
Y_tst = inputData['Y_tst']
N_eval = len(X_tst)
cnn_params['mode'] = 'test-predict'
cnn_params['load_param_node_name'] = params["currentDepth"]
if params["model-type"] == "XML-CNN":
model = xml_cnn_model.CNN(**cnn_params)
else:
model = cnn_model.CNN(**cnn_params)
model.to_gpu()
output = np.zeros([N_eval,params["output-dimensions"]],dtype=np.int8)
output_probability_file_name = "CNN/RESULT/probability_" + params["currentDepth"] + ".csv"
with open(output_probability_file_name, 'w') as f:
f.write(','.join(params["learning_categories"])+"\n")
test_batch_size = params["batchsize"]
with chainer.using_config('train', False), chainer.no_backprop_mode():
for i in tqdm(six.moves.range(0, N_eval, test_batch_size),desc="Predict Test loop"):
x = chainer.Variable(chainer.cuda.to_gpu(X_tst[i:i + test_batch_size]))
t = Y_tst[i:i + test_batch_size]
net_output = F.sigmoid(model(x))
output[i: i + test_batch_size] = select_function(net_output.data)
with open(output_probability_file_name , 'a') as f:
tmp = chainer.cuda.to_cpu(net_output.data)
low_values_flags = tmp < 0.001
tmp[low_values_flags] = 0
np.savetxt(f,tmp,fmt='%.4g',delimiter=",")
return output
def train(X_train, X_test, Y_train, Y_test, epoch=5):
# tf Graph input i[-1, 128, 64, 1]
x = tf.placeholder(tf.float32, [None, 128, 64, 3])
y_ = tf.placeholder(tf.float32, [None, 4]) #answer
keep_prob = tf.placeholder(tf.float32)
# Predict
y = cnn_model.CNN(x)
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
with tf.name_scope("ADAM"):
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)
learning_rate = 1e-4
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
train_size = len(Y_train)
batch_size = 50
total_batch = int(train_size / batch_size)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.global_variables_initializer())
num = 1
for i in range(epoch):
# Random shuffling
X_train, Y_train = shuffle(X_train, Y_train)
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (train_size)
batch_x = X_train[offset:(offset + batch_size)]
batch_y = Y_train[offset:(offset + batch_size)]
_, train_accuracy = sess.run([train_step, accuracy],
feed_dict={
x: batch_x,
y_: batch_y,
keep_prob: 0.8
})
print num, " train_accuracy: ", train_accuracy
num += 1
test_accuracy = sess.run([accuracy],
feed_dict={
x: X_test,
y_: Y_test,
keep_prob: 1.0
})
print num, "-----Test_accuracy: ", test_accuracy
save_path = saver.save(sess, 'model/model.ckpt')
def train(f_maps, conv_stride, maxp_stride, training_epochs):
batch_size = TRAIN_BATCH_SIZE
num_labels = 5
data = read_data()
labels = read_labels()
print('Applying contrast streching manipulation...')
contrasted_data, contrasted_labels = data_manipulation.apply_contrast(
data, labels)
contrasted_data = np.asarray(contrasted_data)
print('Size of contrasted data: %d' % len(contrasted_data))
print('Shape of contrasted data: %s' % str(contrasted_data.shape))
print('Applying rotation manipulation...')
rotated_data, rotated_labels = data_manipulation.apply_rotation(
contrasted_data, labels)
rotated_data = np.asarray(rotated_data)
print('Size of rotated data: %d' % len(rotated_data))
print('Shape of rotated data: %s' % str(rotated_data.shape))
print('Applying shifting manipulation...')
shifted_data, shifted_labels = data_manipulation.apply_shifting(
contrasted_data, labels)
shifted_data = np.asarray(shifted_data)
print('Size of shifted data: %d' % len(shifted_data))
print('Shape of shifted data: %s' % str(shifted_data.shape))
print('Applying flipping manipulation...')
flipped_data, flipped_labels = data_manipulation.apply_horizontal_flip(
contrasted_data, labels)
flipped_data = np.asarray(flipped_data)
print('Size of flipped data: %d' % len(flipped_data))
print('Shape of flipped data: %s' % str(flipped_data.shape))
print('Concatenating manipulated data')
concat_data = np.concatenate(
(rotated_data, contrasted_data, flipped_data, shifted_data), axis=0)
print("Size of total data: %s" % str(len(concat_data)))
print("Size of labels: %s" % str(len(labels)))
from sklearn.preprocessing import LabelBinarizer
le = LabelBinarizer()
encoded_labels = le.fit_transform(labels)
concat_data = np.asarray(concat_data)
print("Shape of data: %s" % str(concat_data.shape))
concat_data = concat_data.reshape(-1, 4800)
print("Size of encoded labels: %s" % str(encoded_labels))
X_train, X_test, y_train, y_test = split_dataset(
concat_data, encoded_labels[:len(concat_data)])
print("Size of data: %s" % str(X_train.shape))
print("Length of data: %s" % str(len(X_train)))
print("Size of labels: %s" % str(y_train.shape))
print("Length of labels: %s" % str(len(y_train)))
total_train_data = np.concatenate((X_train, y_train), axis=1)
print("Size of total data: %s" % str(total_train_data.shape))
train_size = total_train_data.shape[0]
validation_data = X_test
validation_labels = y_test
is_training = tf.placeholder(tf.bool, name='MODE')
# Tensorflow variables should be initialized.
x = tf.placeholder(tf.float32, [None, 4800])
y_ = tf.placeholder(tf.float32, [None, 5])
y = cnn_model.CNN(x,
feature_maps=f_maps,
conv_stride=conv_stride,
maxp_stride=maxp_stride)
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
tf.summary.scalar('loss', loss)
with tf.name_scope("ADAM"):
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(1e-4,
batch * batch_size,
train_size,
0.95,
staircase=True)
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
loss, global_step=batch)
tf.summary.scalar('learning_rate', learning_rate)
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('acc', accuracy)
merged_summary_op = tf.summary.merge_all()
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
total_batch = int(train_size / batch_size)
# Writing a log file is optional
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY,
graph=tf.get_default_graph())
for epoch in range(training_epochs):
np.random.shuffle(total_train_data)
train_data_ = total_train_data[:, :-num_labels]
train_labels_ = total_train_data[:, -num_labels:]
for i in range(total_batch):
offset = (i * batch_size) % train_size
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
_, train_accuracy, summary = sess.run(
[train_step, accuracy, merged_summary_op],
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: True
})
# Optional
summary_writer.add_summary(summary, epoch * total_batch + i)
if i % display_step == 0:
format_str = '%s: step %d, accuracy = %.3f'
print(format_str % (datetime.now(),
(epoch + 1), train_accuracy))
saver.save(sess, MODEL_DIRECTORY)
test_size = validation_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
saver.restore(sess, MODEL_DIRECTORY)
acc_buffer = []
for i in range(total_batch):
offset = (i * batch_size) % test_size
batch_xs = validation_data[offset:(offset + batch_size), :]
batch_ys = validation_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = np.equal(np.argmax(y_final, 1),
np.argmax(batch_ys, 1))
acc_buffer.append(np.sum(correct_prediction) / batch_size)
print("Test accuracy for this model: %g" % np.mean(acc_buffer))
def train(args):
# Some parameters
batch_size = args.batch_size
input_size = args.input_size
num_classes = args.num_classes
# Prepare data
if args.dataset == "mnist":
train_total_data, train_size, validation_data, validation_y, test_data, test_y = load_data.prepare_MNIST_data(args)
else:
train_total_data, train_size, validation_data, validation_y, test_data, test_y = load_data.prepare_cosmology_data(args)
# Boolean for MODE of train or test
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, input_size*input_size])
y_ = tf.placeholder(tf.float32, [None, num_classes]) #answer
# Predict
y = cnn_model.CNN(args, x)
# Get loss of model
with tf.name_scope("LOSS"):
if args.num_classes > 1:
loss = slim.losses.softmax_cross_entropy(y,y_)
else: # mean square loss for regression
loss = tf.reduce_mean(tf.pow(y-y_, 2))
# Create a summary to monitor loss tensor
tf.summary.scalar('loss', loss)
# Define optimizer
with tf.name_scope("ADAM"):
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(
1e-4, # Base learning rate.
batch * batch_size, # Current index into the dataset.
train_size, # Decay step.
0.95, # Decay rate.
staircase=True)
# Use simple momentum for the optimization.
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss,global_step=batch)
# Create a summary to monitor learning_rate tensor
tf.summary.scalar('learning_rate', learning_rate)
# Get accuracy of model
with tf.name_scope("ACC"):
if args.num_classes > 1:
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
else:
accuracy = tf.scalar_mul(-1.0, loss)
# Create a summary to monitor accuracy tensor
tf.summary.scalar('acc', accuracy)
# Merge all summaries into a single op
merged_summary_op = tf.summary.merge_all()
# Add ops to save and restore all the variables
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Training cycle
total_batch = int(train_size / batch_size)
# op to write logs to Tensorboard
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY, graph=tf.get_default_graph())
# Save the maximum accuracy value for validation data
max_acc = -np.inf
# Loop for epoch
for epoch in range(training_epochs):
# Random shuffling
np.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-num_classes]
train_y = train_total_data[:, -num_classes:]
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (train_size)
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_y[offset:(offset + batch_size), :]
# Run optimization op (backprop), loss op (to get loss value)
# and summary nodes
_, train_accuracy, summary = sess.run([train_step, accuracy, merged_summary_op] , feed_dict={x: batch_xs, y_: batch_ys, is_training: True})
# Write logs at every iteration
summary_writer.add_summary(summary, epoch * total_batch + i)
# Display logs
if i % display_step == 0:
# Calculate accuracy
validation_accuracy = sess.run(accuracy,
feed_dict={x: validation_data, y_: validation_y, is_training: False})
print("Epoch: {}, batch_index: {}/{}, training accuracy: {}, validation accuracy: {}".format(epoch + 1, i, total_batch, train_accuracy, validation_accuracy))
with open("log.out", "a") as log_file:
log_file.write("Epoch: {}, batch_index: {}/{}, training accuracy: {}, validation accuracy: {}\n".format(epoch + 1, i, total_batch, train_accuracy, validation_accuracy))
'''
# Get accuracy for validation data
if i % validation_step == 0:
# Calculate accuracy
validation_accuracy = sess.run(accuracy,
feed_dict={x: validation_data, y_: validation_y, is_training: False})
print("Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, validation accuracy %.5f" % (i, total_batch, validation_accuracy))
# with open("log.out", "a") as log_file:
# log_file.write("Epoch: {}, batch_index: {}/{}, validation accuracy: {}\n".format(epoch + 1, i, total_batch, validation_accuracy))
'''
# Save the current model if the maximum accuracy is updated
if validation_accuracy > max_acc:
max_acc = validation_accuracy
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model updated and saved in file: %s" % save_path)
print("Optimization Finished!")
# Restore variables from disk
saver.restore(sess, MODEL_DIRECTORY)
# Calculate accuracy for all mnist test images
test_size = test_y.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_y[offset:(offset + batch_size), :]
y_final = sess.run(y, feed_dict={x: batch_xs, y_: batch_ys, is_training: False})
if args.num_classes > 1:
correct_prediction = np.equal(np.argmax(y_final, 1), np.argmax(batch_ys, 1))
acc_buffer.append(np.sum(correct_prediction) / batch_size)
else:
acc_buffer.append(y_final)
test_accuracy = -1.*np.mean(acc_buffer)
print("test accuracy for the stored model: {}".format(test_accuracy))
with open("log.out", "a") as log_file:
log_file.write("test accuracy: {}\n".format(test_accuracy))
test_data, img_prefixes = load_data.prepare_cosmology_test_data(args)
res = []
y_final = sess.run(y, feed_dict={x: test_data, is_training: False})
pred = dict(zip(img_prefixes, y_final.flatten().tolist()))
print(pred)
df = pd.DataFrame.from_dict(pred, orient="index")
df = df.reset_index()
df.to_csv(os.path.join(args.data_dir, "prediction.csv"), header=["Id", "Predicted"], index=False)
def train(categories, X, y, f_maps, conv_stride, maxp_stride, training_epochs):
batch_size = TRAIN_BATCH_SIZE
num_labels = 5
X_train, X_test, y_train, y_test = get_data.split_data(X, y)
print("Size of data: %s" % str(X_train.shape))
print("Length of data: %s" % str(len(X_train)))
print("Size of labels: %s" % str(y_train.shape))
print("Length of labels: %s" % str(len(y_train)))
train_size = len(X_train)
validation_data = X_test
validation_labels = y_test
is_training = tf.placeholder(tf.bool, name='MODE')
# Tensorflow variables should be initialized.
x = tf.placeholder(tf.float32, [None, 4800])
y_ = tf.placeholder(tf.float32, [None, num_labels])
y = cnn_model.CNN(x,
feature_maps=f_maps,
conv_stride=conv_stride,
maxp_stride=maxp_stride)
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
tf.summary.scalar('loss', loss)
with tf.name_scope("ADAM"):
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(1e-4,
batch * batch_size,
train_size,
0.95,
staircase=True)
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
loss, global_step=batch)
tf.summary.scalar('learning_rate', learning_rate)
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
tf.summary.scalar('acc', accuracy)
merged_summary_op = tf.summary.merge_all()
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
total_batch = int(train_size / batch_size)
# Writing a log file is optional
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY,
graph=tf.get_default_graph())
for epoch in range(training_epochs):
train_data_ = X_train
train_labels_ = y_train
for i in range(total_batch):
offset = (i * batch_size) % train_size
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
_, train_accuracy, summary = sess.run(
[train_step, accuracy, merged_summary_op],
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: True
})
# Optional
summary_writer.add_summary(summary, epoch * total_batch + i)
if i % display_step == 0:
format_str = '%s: step %d, accuracy = %.3f'
print(format_str % (datetime.now(),
(epoch + 1), train_accuracy))
saver.save(sess, MODEL_DIRECTORY)
test_size = validation_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
saver.restore(sess, MODEL_DIRECTORY)
acc_buffer = []
for i in range(total_batch):
offset = (i * batch_size) % test_size
batch_xs = validation_data[offset:(offset + batch_size), :]
batch_ys = validation_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = np.equal(np.argmax(y_final, 1),
np.argmax(batch_ys, 1))
acc_buffer.append(np.sum(correct_prediction) / batch_size)
print("Test accuracy for this model: %g" % np.mean(acc_buffer))
