def run(self):
if(self.action=='training'):
clf=self.train().fit(self.mats1, self.spams1)
predict1 = clf.predict(self.mats1)
predict2 = clf.predict(self.mats2)
print util.validation(predict1, self.spams1), util.validation(predict2, self.spams2)
joblib.dump(clf, self.modelDir)
else:
predict2 = self.clf.predict(self.mats2)
print util.validation(predict2, self.spams2)
import sys import numpy as np import json import util from sklearn.externals import joblib from sklearn import svm from sklearn.ensemble import AdaBoostClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.ensemble import RandomForestClassifier from sklearn.ensemble import GradientBoostingClassifier mats1, spams1, mats2, spams2 =util.getRawData(sys.argv[1], sys.argv[2]) clf = GradientBoostingClassifier(max_leaf_nodes=3, random_state=1, n_estimators=200).fit(mats1, spams1) predict1 = clf.predict(mats1) predict2 = clf.predict(mats2) print util.validation(predict1, spams1), util.validation(predict2, spams2)
def main(args_parser):
#Dataset
parser = args_parser
args = parser.parse_args()
train_image_data, train_label_data, train_filename, valid_image_data, valid_label_data, valid_filename, unique_classes = get_data(
)
#tf.reset_default_graph()
DATASET_PATH = args.datasetPath
LEARNING_RATE_1 = args.learningRate
EPOCHS = args.epochs
BATCH_SIZE = args.batchSize
NUM_CLASSES = len(unique_classes)
Z_SCORE = args.zScore
WEIGHT_DECAY_1 = args.weightDecay
print("Current Setup:-")
print(
"Starting Learning Rate: {}, Epochs: {}, Batch Size: {}, Confidence Interval Z-Score {}, Number of classes: {}, Starting Weight Decay: {}"
.format(LEARNING_RATE_1, EPOCHS, BATCH_SIZE, Z_SCORE, NUM_CLASSES,
WEIGHT_DECAY_1))
#Placeholders
learning_rate = tf.placeholder(tf.float32, shape=[], name='learning_rate')
weight_decay = tf.placeholder(tf.float32, shape=[], name="weight_decay")
#Dataset
training_dataset = tf.data.Dataset.from_generator(
lambda: itertools.zip_longest(train_image_data, train_label_data,
train_filename),
output_types=(tf.float32, tf.float32),
output_shapes=(tf.TensorShape([None, None, 3]), tf.TensorShape([None]),
tf.TensorShape([None])))
training_dataset = training_dataset.repeat(EPOCHS).batch(
BATCH_SIZE).prefetch(1)
train_iterator = training_dataset.make_initializable_iterator()
train_features, train_labels, train_filename = train_iterator.get_next()
valid_dataset = tf.data.Dataset.from_generator(
lambda: itertools.zip_longest(valid_image_data, valid_label_data,
valid_filename),
output_types=(tf.float32, tf.float32),
output_shapes=(tf.TensorShape([None, None, 3]), tf.TensorShape([None]),
tf.TensorShape([None])))
valid_dataset = valid_dataset.repeat(EPOCHS).batch(BATCH_SIZE).prefetch(1)
valid_iterator = valid_dataset.make_initializable_iterator()
valid_features, valid_labels, valid_filename = valid_iterator.get_next()
#Model
_, train_op, train_cross_entropy, train_conf_matrix_op, train_accuracy = initiate_vgg_model(
train_features,
train_labels,
train_filename,
NUM_CLASSES,
weight_decay,
learning_rate,
handle="training",
reuse_model=None)
_, _, valid_cross_entropy, valid_conf_matrix_op, valid_accuracy = initiate_vgg_model(
valid_features,
valid_labels,
valid_filename,
NUM_CLASSES,
weight_decay,
learning_rate,
handle="validation",
reuse_model=True)
saver = tf.train.Saver()
if not os.path.exists(os.path.join("./short_dl_research_train/")):
os.mkdir(os.path.join("./short_dl_research_train/"))
with tf.Session() as sess:
with np.printoptions(threshold=np.inf):
train_writer = tf.summary.FileWriter(
"./short_tensorboard_training_logs/")
valid_writer = tf.summary.FileWriter(
"./short_tensorboard_validation_logs/")
train_writer.add_graph(sess.graph)
valid_writer.add_graph(sess.graph)
train_highest_acc = 0
valid_highest_acc = 0
sess.run([
tf.global_variables_initializer(),
tf.local_variables_initializer()
])
for epoch in range(EPOCHS):
print("Current Epoch: {}/{}".format(epoch, EPOCHS))
i = 0
try:
sess.run(train_iterator.initializer)
while True:
print("Current Training Iteration : {}/{}".format(
i, floor(int(157252) / BATCH_SIZE)))
train_acc, _, _, train_ce = util.training(
BATCH_SIZE, NUM_CLASSES, learning_rate,
weight_decay, sess, train_op, train_conf_matrix_op,
LEARNING_RATE_1, WEIGHT_DECAY_1,
train_cross_entropy, train_accuracy)
train_value1, train_value2 = util.confidence_interval(
train_acc, Z_SCORE, BATCH_SIZE)
print("Training Accuracy : {}".format(train_acc))
print("Training Loss (Cross Entropy) : {}".format(
train_ce))
print("Training Confidence Interval: [{} , {}]".format(
train_value2, train_value1))
if train_highest_acc <= train_acc:
train_highest_acc = train_acc
print(
"Highest Training Accuracy Reached: {}".format(
train_highest_acc))
#For every epoch, we will save the model
saver.save(
sess,
os.path.join("./short_dl_research_train/",
"model.ckpt"))
print(
"Latest Model is saving and Tensorboard Logs are updated"
)
train_writer.add_summary(
tf.summary.merge_all().eval(),
epoch * (floor(int(157252) / BATCH_SIZE)) + i)
i = i + 1
except tf.errors.OutOfRangeError:
print("End of the training dataset, proceed to validation")
pass
j = 0
try:
sess.run(valid_iterator.initializer)
while True:
print("Current Validation Iteration : {}/{}".format(
j, floor(int(19657) / BATCH_SIZE)))
valid_acc, _, valid_ce = util.validation(
BATCH_SIZE, NUM_CLASSES, learning_rate,
weight_decay, sess, valid_conf_matrix_op,
LEARNING_RATE_1, WEIGHT_DECAY_1,
valid_cross_entropy, valid_accuracy)
valid_value1, valid_value2 = util.confidence_interval(
valid_acc, Z_SCORE, BATCH_SIZE)
print("Validation Accuracy : {}".format(valid_acc))
print("validation Loss (Cross Entropy) : {}".format(
valid_ce))
print(
"Validation Confidence Interval: [{} , {}]".format(
valid_value2, valid_value1))
if valid_highest_acc <= valid_acc:
valid_highest_acc = valid_acc
print("Highest Validation Accuracy Reached: {}".
format(valid_highest_acc))
valid_writer.add_summary(
tf.summary.merge_all().eval(),
epoch * (floor(int(19657) / BATCH_SIZE)) + j)
j = j + 1
except tf.errors.OutOfRangeError:
print("End of validation dataset, go to the next epoch")
pass
# data
train_data, val_data = load_data(data_config, exp_config['batch_size'])
eval_length = data_config['eval_length']
# logger
# model
model = Model(**model_config).to(0)
# optimizer
optimizer = AdamOptimizer(params=model.parameters(), lr=exp_config['lr'],
grad_clip_value=exp_config['grad_clip_value'],
grad_clip_norm=exp_config['grad_clip_norm'])
logger_on = True
if logger_on:
logger = Logger(exp_config, model_config, data_config)
# train / val loop
for epoch in range(exp_config['n_epochs']):
print('Epoch:', epoch)
if logger_on:
logger.log(train(train_data, model, optimizer, eval_length), 'train')
logger.log(validation(val_data, model, eval_length), 'val')
logger.save(model)
else:
train(train_data, model, optimizer, eval_length)
validation(val_data, model, eval_length)
def main(cli_args):
parser = argparse.ArgumentParser(
description="CSCE 496 HW 2, Classify Cifar data")
parser.add_argument('--input_dir',
type=str,
default='/work/cse496dl/shared/homework/02',
help='Numpy datafile input')
parser.add_argument(
'--model_dir',
type=str,
default='./homework_2/',
help='directory where model graph and weights are saved')
parser.add_argument('--epoch',
type=int,
default=100,
help="Epoch : number of iterations for the model")
parser.add_argument('--batch_size',
type=int,
default=32,
help="Batch Size")
parser.add_argument('--model',
type=int,
help=" '1' for basic model, '2' for best model")
parser.add_argument(
'--stopCount',
type=int,
default=100,
help="Number of times for dropping accuracy before early stopping")
args_input = parser.parse_args(cli_args)
if args_input.input_dir:
input_dir = args_input.input_dir
else:
raise ValueError("Provide a valid input data path")
if args_input.model_dir:
model_dir = args_input.model_dir
else:
raise ValueError("Provide a valid model data path")
if args_input.epoch:
epochs = args_input.epoch
else:
raise ValueError("Epoch value cannot be null and has to be an integer")
if args_input.batch_size:
batch_size = args_input.batch_size
else:
raise ValueError(
"Batch Size value cannot be null and has to be an integer")
if args_input.model:
model = args_input.model
else:
raise ValueError("Model selection must not be empty")
if args_input.stopCount:
stop_counter = args_input.stopCount
else:
raise ValueError("StopCount have to be an int")
input_dir = '/work/cse496dl/shared/homework/02'
#Make output model dir
if os.path.exists(model_dir) == False:
os.mkdir(model_dir)
#Load Data
x = tf.placeholder(tf.float32, [None, 32, 32, 3], name='input_placeholder')
y = tf.placeholder(tf.float32, [None, 100], name='labels')
#Specify Model
if (str(model) == '1'):
train_images, train_labels, test_images, test_labels, val_images, val_labels = util.load_data(
"")
_, outputLayer = initiate_basic_model(x)
#Run Training with early stopping and save output
counter = stop_counter
prev_winner = 0
curr_winner = 0
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001)
cross_entropy = util.cross_entropy_op(y, outputLayer)
global_step_tensor = util.global_step_tensor('global_step_tensor')
train_op = util.train_op_basic(cross_entropy, global_step_tensor,
optimizer)
conf_matrix = util.confusion_matrix_op(y, outputLayer, 100)
saver = tf.train.Saver()
with tf.Session() as session:
session.run(tf.global_variables_initializer())
counter = stop_counter
for epoch in range(epochs):
if counter > 0:
print("Epoch : " + str(epoch))
util.training(batch_size, x, y, train_images, train_labels,
session, train_op, conf_matrix, 100)
accuracy = util.validation(batch_size, x, y, val_images,
val_labels, session,
cross_entropy, conf_matrix, 100)
if epoch == 0:
prev_winner = accuracy
print("Saving.......")
saver.save(session,
os.path.join("./homework_2/", "homework_2"))
else:
curr_winner = accuracy
if (curr_winner > prev_winner) and (counter > 0):
prev_winner = curr_winner
print("Saving.......")
saver.save(
session,
os.path.join("./homework_2/", "homework_2"))
else:
counter -= 1
test_accuracy = util.test(batch_size, x, y, test_images,
test_labels, session,
cross_entropy, conf_matrix, 100)
#Calculate the confidence interval
value1, value2 = util.confidence_interval(
test_accuracy, 1.96, test_images.shape[0])
print("Confidence Interval : " + str(value1) + " , " +
str(value2))
else:
break
elif (str(model) == '2'):
sparsity_weight = 5e-3
#Load the data and reshape it
train_data = np.load(
os.path.join(os.path.join(input_dir, 'imagenet_images.npy')))
train_images, train_labels, test_images, test_labels, val_images, val_labels = util.load_data(
"")
#train_data = np.reshape(train_data, [-1,32,32,1])
#Add noise to the data
noise_level = 0.2
x_noise = x + noise_level * tf.random_normal(tf.shape(x))
code, outputs = initiate_autoencoder(x_noise, 100)
#Optimizer for Autoencoder
sparsity_loss = tf.norm(code, ord=1, axis=1)
reconstruction_loss = tf.reduce_mean(tf.square(outputs -
x)) # Mean Square Error
total_loss = reconstruction_loss + sparsity_weight * sparsity_loss
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001)
train_op = optimizer.minimize(total_loss)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
util.autoencoder_training(x, code, epochs, batch_size, train_data,
sess, train_op)
saver.save(sess, os.path.join("./homework_2/", "homework_2"))
print("Done : " + str(code))
_, outputLayer = initiate_dense_model(code)
#Run Training with early stopping and save output
counter = stop_counter
prev_winner = 0
curr_winner = 0
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001)
cross_entropy = util.cross_entropy_op(y, outputLayer)
global_step_tensor = util.global_step_tensor('global_step_tensor')
#train_op = util.train_op_encoder(cross_entropy, global_step_tensor, optimizer, var_list=tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, "code_layer"))
train_op = util.train_op_basic(cross_entropy, global_step_tensor,
optimizer)
conf_matrix = util.confusion_matrix_op(y, outputLayer, 100)
with tf.Session() as session:
session.run(tf.global_variables_initializer())
if os.path.isfile(os.path.join("./homework_2/", "homework_2")):
saver = tf.train.import_meta_graph("homework_2.meta")
saver.restore(session, "./homework_2/homework_2")
code_encode = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
"code_layer")
session.run(
tf.variables_initializer(code_encode,
name="init_encoded_layer"))
tf.stop_gradient(
tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
"init_encoded_layer"))
counter = stop_counter
for epoch in range(epochs):
if counter > 0:
print("Epoch : " + str(epoch))
util.training(batch_size, x, y, train_images, train_labels,
session, train_op, conf_matrix, 100)
accuracy = util.validation(batch_size, x, y, val_images,
val_labels, session,
cross_entropy, conf_matrix, 100)
if epoch == 0:
prev_winner = accuracy
print("Saving.......")
saver.save(session,
os.path.join("./homework_2/", "homework_2"))
else:
curr_winner = accuracy
if (curr_winner > prev_winner) and (counter > 0):
prev_winner = curr_winner
print("Saving.......")
saver.save(
session,
os.path.join("./homework_2/", "homework_2"))
else:
print("Validation Loss : " +
str(curr_winner - prev_winner))
counter -= 1
test_accuracy = util.test(batch_size, x, y, test_images,
test_labels, session,
cross_entropy, conf_matrix, 100)
#Calculate the confidence interval
value1, value2 = util.confidence_interval(
test_accuracy, 1.96, test_images.shape[0])
print("Confidence Interval : " + str(value1) + " , " +
str(value2))
else:
break
# logger
# model
model = Model(**model_config).to(0)
# optimizer
optimizer = AdamOptimizer(params=model.parameters(),
lr=exp_config['lr'],
grad_clip_value=exp_config['grad_clip_value'],
grad_clip_norm=exp_config['grad_clip_norm'])
logger_on = True
if logger_on:
logger = Logger(exp_config, model_config, data_config)
# train / val loop
for epoch in range(exp_config['n_epochs']):
print('Epoch:', epoch)
if logger_on:
logger.log(train(train_data, model, optimizer, eval_length), 'train')
logger.log(
validation(val_data, model, eval_length, use_mean_pred=True),
'val')
logger.save(model)
else:
train(train_data, model, optimizer, eval_length)
validation(val_data, model, eval_length)
eval_length = data_config['eval_length']
train_epoch_size = data_config['train_epoch_size']
val_epoch_size = data_config['val_epoch_size']
# logger
# model
model = Model(**model_config).to(0)
# optimizer
optimizer = AdamOptimizer(params=model.parameters(), lr=exp_config['lr'],
grad_clip_value=exp_config['grad_clip_value'],
grad_clip_norm=exp_config['grad_clip_norm'])
logger_on = True
if logger_on:
logger = Logger(exp_config, model_config, data_config)
# train / val loop
for epoch in range(exp_config['n_epochs']):
print('Epoch:', epoch)
if logger_on:
logger.log(train(train_data, model, optimizer, eval_length, train_epoch_size), 'train')
logger.log(validation(val_data, model, eval_length, val_epoch_size, use_mean_pred=True), 'val')
logger.save(model)
else:
train(train_data, model, optimizer, eval_length, train_epoch_size)
validation(val_data, model, eval_length, val_epoch_size)
def main(args_parser):
parser = args_parser
args = parser.parse_args()
#tf.reset_default_graph()
DATASET_PATH = args.datasetPath
LEARNING_RATE_1 = 0.01#(args.learningRate)
EPOCHS = 4 #int(args.epochs)
BATCH_SIZE = 32 #int(args.batchSize)
NUM_CLASSES = 5 #int(args.numClasses)
Z_SCORE = 1.96 #(args.zScore)
WEIGHT_DECAY_1 = 0.0005#(args.weightDecay)
print("Current Setup:-")
print("Starting Learning Rate: {}, Epochs: {}, Batch Size: {}, Confidence Interval Z-Score {}, Number of classes: {}, Starting Weight Decay: {}".format(LEARNING_RATE_1, EPOCHS, BATCH_SIZE, Z_SCORE, NUM_CLASSES, WEIGHT_DECAY_1))
#Placeholders
learning_rate = tf.placeholder(tf.float32, shape=[], name='learning_rate')
weight_decay = tf.placeholder(tf.float32, shape=[], name="weight_decay")
#Dataset
train_next_element, train_iterator = util.train_input_fn(DATASET_PATH, BATCH_SIZE, EPOCHS)
valid_next_element, valid_iterator = util.valid_input_fn(DATASET_PATH, BATCH_SIZE, EPOCHS)
#dataset_len = 157252
#Model
_, train_op, train_cross_entropy, train_conf_matrix_op, train_accuracy = initiate_vgg_model(train_next_element[0], train_next_element[1], train_next_element[2], NUM_CLASSES, weight_decay, learning_rate, handle="training", reuse_model=None)
_, _, valid_cross_entropy, valid_conf_matrix_op, valid_accuracy = initiate_vgg_model(valid_next_element[0], valid_next_element[1], valid_next_element[2], NUM_CLASSES, weight_decay, learning_rate, handle="validation", reuse_model=True)
#tf.summary.scalar("training_confusion_matrix", tf.reshape(tf.cast(conf_matrix_op, tf.float32),[1, NUM_CLASSES, NUM_CLASSES, 1]))
saver = tf.train.Saver()
if not os.path.exists(os.path.join("./short_dl_research_train/")):
os.mkdir(os.path.join("./short_dl_research_train/"))
with tf.Session() as sess:
with np.printoptions(threshold=np.inf):
train_writer = tf.summary.FileWriter("./short_tensorboard_training_logs/")
valid_writer = tf.summary.FileWriter("./short_tensorboard_validation_logs/")
train_writer.add_graph(sess.graph)
valid_writer.add_graph(sess.graph)
train_highest_acc = 0
valid_highest_acc = 0
sess.run([tf.global_variables_initializer(), tf.local_variables_initializer()])
for epoch in range(EPOCHS):
sess.run([train_iterator.initializer, valid_iterator.initializer])
print("Train iterator and valid iterator are initialized")
print("Current Epoch: {}/{}".format(epoch, EPOCHS))
i = 0
try:
while True:
print("Current Training Iteration : {}/{}".format(i, floor(int(157252)/BATCH_SIZE)))
train_acc, _, _, train_ce = util.training(BATCH_SIZE, NUM_CLASSES,learning_rate, weight_decay, sess, train_op, train_conf_matrix_op, LEARNING_RATE_1, WEIGHT_DECAY_1, train_cross_entropy, train_accuracy)
train_value1, train_value2 = util.confidence_interval(train_acc, Z_SCORE, BATCH_SIZE)
print("Training Accuracy : {}".format(train_acc))
print("Training Loss (Cross Entropy) : {}".format(train_ce))
print("Training Confidence Interval: [{} , {}]".format(train_value2, train_value1))
if train_highest_acc <= train_acc:
train_highest_acc = train_acc
print("Highest Training Accuracy Reached: {}".format(train_highest_acc))
#For every epoch, we will save the model
saver.save(sess, os.path.join("./short_dl_research_train/", "model.ckpt"))
print("Latest Model is saving and Tensorboard Logs are updated")
train_writer.add_summary(tf.summary.merge_all().eval(), epoch * (floor(int(157252)/BATCH_SIZE)) + i)
i = i + 1
except tf.errors.OutOfRangeError:
print("End of the training dataset, proceed to validation")
pass
j = 0
try:
while True:
print("Current Validation Iteration : {}/{}".format(j, floor(int(19657)/BATCH_SIZE)))
valid_acc, _, valid_ce = util.validation(BATCH_SIZE, NUM_CLASSES,learning_rate, weight_decay, sess, valid_conf_matrix_op, LEARNING_RATE_1, WEIGHT_DECAY_1, valid_cross_entropy, valid_accuracy)
valid_value1, valid_value2 = util.confidence_interval(valid_acc, Z_SCORE, BATCH_SIZE)
print("Validation Accuracy : {}".format(valid_acc))
print("validation Loss (Cross Entropy) : {}".format(valid_ce))
print("Validation Confidence Interval: [{} , {}]".format(valid_value2, valid_value1))
if valid_highest_acc <= valid_acc:
valid_highest_acc = valid_acc
print("Highest Validation Accuracy Reached: {}".format(valid_highest_acc))
valid_writer.add_summary(tf.summary.merge_all().eval(), epoch * (floor(int(19657)/BATCH_SIZE)) + j)
j = j + 1
except tf.errors.OutOfRangeError:
print("End of validation dataset, go to the next epoch")
pass
# data
train_data, val_data = load_data(data_config, exp_config['batch_size'])
eval_length = data_config['eval_length']
# logger
# model
model = Model(**model_config).to(0)
# optimizer
optimizer = AdamOptimizer(params=model.parameters(), lr=exp_config['lr'],
grad_clip_value=exp_config['grad_clip_value'],
grad_clip_norm=exp_config['grad_clip_norm'])
logger_on = True
if logger_on:
logger = Logger(exp_config, model_config, data_config)
# train / val loop
for epoch in range(exp_config['n_epochs']):
print('Epoch:', epoch)
if logger_on:
logger.log(train(train_data, model, optimizer, eval_length), 'train')
logger.log(validation(val_data, model, eval_length, use_mean_pred=True), 'val')
logger.save(model)
else:
train(train_data, model, optimizer, eval_length)
validation(val_data, model, eval_length)
optimizer.zero_grad()
output = model(inputs)
_, preds = torch.max(output.data, 1)
loss = criterion(output, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
ps = torch.exp(output)
equality = (labels.data == ps.max(dim=1)[1])
accuracy += equality.type(torch.FloatTensor).mean()
if steps % print_every == 0:
test_loss, test_accuracy = validation(model, dataloaders['valid'], criterion, device)
print("Epoch: {}/{}".format(epoch+1, args.epochs),
"Train Loss: {:.4f}".format(running_loss/print_every),
"Train Accuracy : {:.4f}".format(accuracy/print_every),
"Validation Loss : {:.4f}".format(test_loss),
"Validation Accuracy : {:.4f}".format(test_accuracy))
model.train()
accuracy = 0
running_loss = 0
# Do validation on the test set, print results
test_loss, test_accuracy = validation(model, dataloaders['test'], criterion, device)
print("Test Loss : {:.4f}".format(test_loss),
"Test Accuracy : {:.4f}".format(test_accuracy))
# Save the checkpoint
def main(cli_args):
parser = argparse.ArgumentParser(
description="CSCE 496 HW 1, Classify Fashion MNIST data")
parser.add_argument('--input_dir',
type=str,
default='/work/cse496dl/shared/homework/01',
help='Numpy datafile input')
parser.add_argument(
'--model_dir',
type=str,
default='./homework_1/',
help='directory where model graph and weights are saved')
parser.add_argument('--epoch',
type=int,
default=100,
help="Epoch : number of iterations for the model")
parser.add_argument('--batch_size',
type=int,
default=32,
help="Batch Size")
parser.add_argument('--model',
type=int,
help=" '1' for basic model, '2' for best model")
parser.add_argument(
'--stopCount',
type=int,
default=100,
help="Number of times for dropping accuracy before early stopping")
args_input = parser.parse_args(cli_args)
if args_input.input_dir:
input_dir = args_input.input_dir
else:
raise ValueError("Provide a valid input data path")
if args_input.model_dir:
model_dir = args_input.model_dir
else:
raise ValueError("Provide a valid model data path")
if args_input.epoch:
epochs = args_input.epoch
else:
raise ValueError("Epoch value cannot be null and has to be an integer")
if args_input.batch_size:
batch_size = args_input.batch_size
else:
raise ValueError(
"Batch Size value cannot be null and has to be an integer")
if args_input.model:
model = args_input.model
else:
raise ValueError("Model selection must not be empty")
if args_input.stopCount:
stop_counter = args_input.stopCount
else:
raise ValueError("StopCount have to be an int")
input_dir = '/work/cse496dl/shared/homework/01'
#Make output model dir
if os.path.exists(model_dir) == False:
os.mkdir(model_dir)
#Load Data
train_images, train_labels, test_images, test_labels, val_images, val_labels = util.load_data(
input_dir)
x = tf.placeholder(tf.float32, [None, 784], name='input_placeholder')
y = tf.placeholder(tf.float32, [None, 10], name='labels')
#Specify Model
if (str(model) == '1'):
_, outputLayer = initiate_basic_model(x)
elif (str(model) == '2'):
_, outputLayer = initiate_better_model(x)
#Run Training with early stopping and save output
counter = stop_counter
prev_winner = 0
curr_winner = 0
optimizer = tf.train.AdamOptimizer(learning_rate=0.0001)
cross_entropy = util.cross_entropy_op(y, outputLayer)
global_step_tensor = util.global_step_tensor('global_step_tensor')
train_op = util.train_op(cross_entropy, global_step_tensor, optimizer)
conf_matrix = util.confusion_matrix_op(y, outputLayer, 10)
saver = tf.train.Saver()
with tf.Session() as session:
session.run(tf.global_variables_initializer())
for i in range(10):
print("KFold : " + str(i))
counter = stop_counter
for epoch in range(epochs):
if counter > 0:
print("Epoch : " + str(epoch))
util.training(batch_size, x, y, train_images[i],
train_labels[i], session, train_op,
conf_matrix, 10)
accuracy = util.validation(batch_size, x, y, val_images[i],
val_labels[i], session,
cross_entropy, conf_matrix, 10)
if epoch == 0:
prev_winner = accuracy
else:
curr_winner = accuracy
if (curr_winner > prev_winner) and (counter > 0):
prev_winner = curr_winner
else:
counter -= 1
test_accuracy = util.test(batch_size, x, y, test_images[i],
test_labels[i], session,
cross_entropy, conf_matrix, 10)
#Calculate the confidence interval
value1, value2 = util.confidence_interval(
test_accuracy, 1.96, test_images[i].shape[0])
print("Confidence Interval : " + str(value1) + " , " +
str(value2))
else:
break
print("Saving.......")
saver.save(session, os.path.join("./homework_1/", "homework_1"))
from config import model_config, data_config, exp_config
from data import load_data
from lib.model import Model
from util import Logger, train, validation, AdamOptimizer
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(exp_config['device'])
torch.cuda.set_device(0)
# data
train_data, val_data = load_data(data_config, exp_config['batch_size'])
# logger
logger = Logger(exp_config, model_config, data_config)
# model
model = Model(**model_config).to(0)
# optimizer
optimizer = AdamOptimizer(params=model.parameters(),
lr=exp_config['lr'],
grad_clip_value=exp_config['grad_clip_value'],
grad_clip_norm=exp_config['grad_clip_norm'])
# train / val loop
for epoch in range(exp_config['n_epochs']):
print('Epoch:', epoch)
logger.log(train(train_data, model, optimizer), 'train')
logger.log(validation(val_data, model), 'val')
logger.save(model)
