def test_model(data_name, cfg_name, trained_model_name):
cfg = get_config(cfg_name)
print('Config:')
print(cfg)
data_provider = get_data_provider(data_name)
meta_path = os.path.join(Paths.output_path,
'{}.meta'.format(trained_model_name))
assert os.path.exists(meta_path), \
'{} is not existed'.format(meta_path)
saver = tf.train.import_meta_graph(meta_path)
test_scores = np.ndarray(data_provider.test_size, dtype=np.float)
with tf.Session() as sess:
# Load trained model
checkpoint_path = os.path.join(Paths.output_path, trained_model_name)
print('checkpoint path: {}'.format(checkpoint_path))
saver.restore(sess, checkpoint_path)
graph = tf.get_default_graph()
x = graph.get_tensor_by_name("x:0")
is_training = graph.get_tensor_by_name("is_training:0")
dropout_keep_prob = graph.get_tensor_by_name("dropout_keep_prob:0")
predicts = graph.get_tensor_by_name("predicts:0")
iter_num = int((data_provider.test_size - 1) / cfg.batch_size + 1)
for i in range(iter_num):
print("{} Iter {}".format(datetime.now(), i))
batch_size = min(cfg.batch_size,
data_provider.test_size - cfg.batch_size * i)
batch_data, _ = data_provider.next_batch(batch_size, 'test')
batch_predicts = sess.run(predicts,
feed_dict={
x: batch_data,
is_training: False,
dropout_keep_prob:
cfg.dropout_keep_prob
})
for j in range(batch_size):
test_scores[i * cfg.batch_size + j] = batch_predicts[j][1]
print('scores:')
for test_score in test_scores:
print(test_score)
print('finish!')
def test_model(data_name, cfg_name, trained_model_name):
cfg = get_config(cfg_name)
print('Config:')
print(cfg)
data_provider = get_data_provider(data_name, cfg)
meta_path = os.path.join(Paths.output_path,
'{}.meta'.format(trained_model_name))
assert os.path.exists(meta_path), \
'{} is not existed'.format(meta_path)
saver = tf.train.import_meta_graph(meta_path)
with tf.Session() as sess:
# Load trained model
checkpoint_path = os.path.join(Paths.output_path, trained_model_name)
print('checkpoint path: {}'.format(checkpoint_path))
saver.restore(sess, checkpoint_path)
graph = tf.get_default_graph()
x = graph.get_tensor_by_name("x:0")
y = graph.get_tensor_by_name("y:0")
is_training = graph.get_tensor_by_name("is_training:0")
dropout_keep_prob = graph.get_tensor_by_name("dropout_keep_prob:0")
accuracy = graph.get_tensor_by_name("accuracy:0")
predicts = graph.get_tensor_by_name("not_pretrained/predicts:0")
test_accuracy = 0.
test_num = int(data_provider.test_size / cfg.batch_size)
for image_id in range(test_num):
images, labels = data_provider.next_batch(cfg.batch_size, 'test')
acc, pred = sess.run(
[accuracy, predicts],
feed_dict={
x: images,
y: labels,
is_training: False,
dropout_keep_prob: cfg.dropout_keep_prob
})
test_accuracy += acc
for i in range(cfg.batch_size):
print('{},{},{}'.format(image_id, labels[i], pred[i][1]))
test_accuracy /= test_num
print("Testing Accuracy = {:.4f}".format(test_accuracy))
print('Finish!')
def get_auth_store(self):
"""
# Structure of Auth
# {
# 'clients': {
# '< client id >': {
# 'clientSecret': '< value >',
# 'uid': '< value >'
# }
# },
# 'tokens': {
# '< token id >': {
# '< uid >': {}
# },
# },
# 'users': {
# '< uid >': {
# 'name': '< username >',
# 'password': '******',
# 'tokens': [ '< token id >', ],
# 'clients': [ '< client id >', ]
# }
# }
# }
:return: Auth
"""
if self.auth_store is not None:
return self.auth_store
config = get_config()
self.auth_store = {
'clients': {},
'tokens': {},
'users': {},
}
self.auth_store['clients'][config.get('google_client_id')] = {
'client_id': config.get('google_client_id'),
'client_secret': config.get('google_client_secret')
}
return self.auth_store
def train_model(model_name, data_name, cfg_name):
cfg = get_config(cfg_name)
print('Config:')
print(cfg)
data_provider = get_data_provider(data_name)
x = tf.placeholder(tf.float32, shape=[None, data_provider.input_length], name='x')
y = tf.placeholder(tf.int64, shape=[None], name='y') # labels: 0, not repeat buyer; 1, is repeat buyer
is_training = tf.placeholder(tf.bool, name='is_training')
dropout_keep_prob = tf.placeholder(tf.float32, name='dropout_keep_prob')
logits = build_model(model_name, x, is_training, dropout_keep_prob)
predicts = tf.nn.softmax(logits, name='predicts')
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))
global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(cfg.initial_learning_rate,
global_step=global_step,
decay_steps=1,
decay_rate=cfg.decay_rate)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)
global_step_increment = global_step.assign_add(1)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
print('Start training')
train_loss = 0.
train_labels = np.ndarray(cfg.display_step * cfg.batch_size, dtype=np.int)
train_scores = np.ndarray(cfg.display_step * cfg.batch_size, dtype=np.float)
for step in range(1, cfg.train_iters + 1):
if step % cfg.decay_step == 0:
sess.run(global_step_increment)
data, labels = data_provider.next_batch(cfg.batch_size, 'train')
batch_loss, _, batch_predict = sess.run([loss, optimizer, predicts],
feed_dict={x: data,
y: labels,
is_training: True,
dropout_keep_prob: cfg.dropout_keep_prob})
for train_index_y in range(cfg.batch_size):
train_index = ((step-1) % cfg.display_step) * cfg.batch_size + train_index_y
train_labels[train_index] = labels[train_index_y]
train_scores[train_index] = batch_predict[train_index_y][1]
train_loss += batch_loss
# Display training status
if step % cfg.display_step == 0:
train_accuracy = roc_auc_score(train_labels, train_scores)
print("{} Iter {}: Training Loss = {:.4f}, Accuracy = {:.4f}"
.format(datetime.now(), step, train_loss / cfg.display_step, train_accuracy))
train_loss = 0.
# Snapshot
if step % cfg.snapshot_step == 0:
save_path = os.path.join(Paths.output_path,
'{}_{}_{}'.format(data_name, model_name, step))
saver.save(sess, save_path)
# Display validation status
if step % cfg.val_step == 0:
val_num = int(data_provider.val_size / cfg.batch_size)
val_labels = np.ndarray(val_num * cfg.batch_size, dtype=np.int)
val_scores = np.ndarray(val_num * cfg.batch_size, dtype=np.float)
for val_index_x in range(val_num):
data, labels = data_provider.next_batch(cfg.batch_size, 'val')
val_predicts = sess.run(predicts, feed_dict={x: data,
y: labels,
is_training: False,
dropout_keep_prob: cfg.dropout_keep_prob})
for val_index_y in range(cfg.batch_size):
val_index = val_index_x * cfg.batch_size + val_index_y
val_labels[val_index] = labels[val_index_y]
val_scores[val_index] = val_predicts[val_index_y][1]
val_accuracy = roc_auc_score(val_labels, val_scores)
print("{} Iter {}: Validation Accuracy = {:.4f}".format(datetime.now(), step, val_accuracy))
fp_rate, tp_rate, _ = roc_curve(val_labels, val_scores)
plt.plot(fp_rate, tp_rate)
figure_path = os.path.join(Paths.output_path, 'val_roc_curve.jpg')
plt.savefig(figure_path)
print('Finish!')
def parse_args():
"""
Parse input arguments
"""
parser = argparse.ArgumentParser(description='Cross Validation')
parser.add_argument('--model', dest='model_name',
help='model to use',
default='lr', type=str)
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
print('Called with args:')
print(args)
model_name = args.model_name
cfg = get_config(model_name)
print('Config:')
print(cfg)
provider = DataProvider()
for i in range(5):
train_data, train_label, val_data, val_label = provider.get_cv_data(i)
model = train_model(model_name, train_data, train_label, cfg)
predict = eval_model(model, val_data)
accuracy = compute_accuracy(predict, val_label)
print('accuracy: {}'.format(accuracy))
def train_model(model_name, data_name, cfg_name):
cfg = get_config(cfg_name)
print('Config:')
print(cfg)
data_provider = get_data_provider(data_name, cfg)
x = tf.placeholder(
tf.float32,
shape=[cfg.batch_size, cfg.resize_length, cfg.resize_length, 3],
name='x') # images
y = tf.placeholder(tf.int64, shape=[cfg.batch_size],
name='y') # labels: 0, not cancer; 1, has cancer
is_training = tf.placeholder(tf.bool, name='is_training')
dropout_keep_prob = tf.placeholder(tf.float32, name='dropout_keep_prob')
labels = tf.one_hot(y,
depth=2,
on_value=1.,
off_value=0.,
dtype=tf.float32)
predicts = build_model(model_name, x, 2, is_training, dropout_keep_prob)
loss = -tf.reduce_mean(tf.reduce_sum(labels * tf.log(predicts + 1e-10),
1)) # add 1e-10 to avoid log(0) = NaN
optimizer = tf.train.GradientDescentOptimizer(
learning_rate=cfg.learning_rate).minimize(loss)
correct_predict = tf.equal(tf.argmax(predicts, 1), y)
accuracy = tf.reduce_mean(tf.cast(correct_predict, tf.float32),
name='accuracy')
restore_vars = get_restore_vars(model_name)
restorer = tf.train.Saver(restore_vars)
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# Load pretrained model
pretrain_model_path = get_pretrain_model_path(model_name)
restorer.restore(sess, pretrain_model_path)
print('Start training')
train_loss = 0.
train_accuracy = 0.
for step in range(1, cfg.train_iters + 1):
images, labels = data_provider.next_batch(cfg.batch_size, 'train')
batch_loss, _, batch_accuracy, batch_predict = sess.run(
[loss, optimizer, accuracy, predicts],
feed_dict={
x: images,
y: labels,
is_training: True,
dropout_keep_prob: cfg.dropout_keep_prob
})
train_loss += batch_loss
train_accuracy += batch_accuracy
# Display training status
if step % cfg.display_step == 0:
print("{} Iter {}: Training Loss = {:.4f}, Accuracy = {:.4f}".
format(datetime.now(), step,
train_loss / cfg.display_step,
train_accuracy / cfg.display_step))
train_loss = 0.
train_accuracy = 0.
# Snapshot
if step % cfg.snapshot_step == 0:
timestamp = time.strftime('%Y%m%d%H%M%S', time.localtime())
save_path = os.path.join(
'output', '{}_{}_{}'.format(data_name, model_name, step))
saver.save(sess, save_path)
# Display testing status
if step % cfg.test_step == 0:
test_accuracy = 0.
test_num = int(data_provider.test_size / cfg.batch_size)
for _ in range(test_num):
images, labels = data_provider.next_batch(
cfg.batch_size, 'test')
acc = sess.run(accuracy,
feed_dict={
x: images,
y: labels,
is_training: False,
dropout_keep_prob: cfg.dropout_keep_prob
})
test_accuracy += acc
test_accuracy /= test_num
print("{} Iter {}: Testing Accuracy = {:.4f}".format(
datetime.now(), step, test_accuracy))
print('Finish!')