def create_kth_fold(k):
logger.info('Generating %d-th data for training...' % k)
config = my_utils.load_config()
ic = my_utils.load_config('image_config.json')
dermis = inputs.load_raw_data('dermis', config)
dermquest = inputs.load_raw_data('dermquest', config)
train_data = inputs.get_kth_fold(dermquest,
k,
ic['n_folds'],
seed=ic['split_seed'])
if ic['use_dermis']:
train_data = train_data + dermis
train_df = to_csv(train_data)
train_df.to_csv(ic['train_csv_file'], index=None)
logger.info('Successfully convert %d examples to %s' %
(len(train_df), ic['train_csv_file']))
test_data = inputs.get_kth_fold(dermquest,
k,
ic['n_folds'],
seed=ic['split_seed'],
type_='test')
test_df = to_csv(test_data)
test_df.to_csv(ic['test_csv_file'], index=None)
logger.info('Successfully convert %d examples to %s' %
(len(test_df), ic['test_csv_file']))
def main():
logger.info('Creating csv file...')
config = my_utils.load_config()
image_config = my_utils.load_config('./image_config.json')
k = image_config['k']
n_folds = image_config['n_folds']
split_seed = image_config['split_seed']
use_dermis = image_config['use_dermis']
train_csv_file = image_config['train_csv_file']
test_csv_file = image_config['test_csv_file']
dermquest = inputs.load_raw_data('dermquest', config)
dermis = inputs.load_raw_data('dermis', config)
train_data = inputs.get_kth_fold(dermquest, k, n_folds, seed=split_seed)
if use_dermis:
train_data = train_data + dermis
train_df = to_csv(train_data)
train_df.to_csv(train_csv_file, index=None)
logger.info('Successfully convert %d examples to %s' %
(len(train_data), train_csv_file))
test_data = inputs.get_kth_fold(dermquest,
k,
n_folds,
seed=split_seed,
type_='test')
test_df = to_csv(test_data)
test_df.to_csv(test_csv_file, index=None)
logger.info('Successfully convert %d examples to %s' %
(len(test_data), test_csv_file))
logger.info('CSV file created!')
def kfold_evaluation(eval_one_func):
results = []
logger.info('K-fold evaluation process...')
config = my_utils.load_config()
dermquest = inputs.load_training_data('dermquest', config)
n_folds = config['n_folds']
for i in range(n_folds):
test_data = inputs.get_kth_fold(dermquest,
i,
n_folds,
type_='test',
seed=config['split_seed'])
kfold_config = my_utils.get_config_for_kfold(config,
train_dir=os.path.join(
config['train_dir'],
str(i)))
logger.info('Evaluating for %i-th fold data...' % i)
mm = evaluation.SegRestoredModel(
tf.train.latest_checkpoint(config['train_dir']))
result = test_one_model(mm, test_data.listing, kfold_config,
eval_one_func)
results.append(result)
logger.info('************************************\n\n')
logger.info('Done evaluation')
return results
def create_dermis_for_train_dermquest_for_test():
logger.info('Creating dermis for training and dermquest for testing...')
config = my_utils.load_config()
image_config = my_utils.load_config('image_config.json')
dermis = inputs.load_raw_data('dermis', config)
dermquest = inputs.load_raw_data('dermquest', config)
train_df = to_csv(dermis)
train_df.to_csv(image_config['train_csv_file'], index=None)
logger.info('Successfully convert %d examples to %s' %
(len(train_df), image_config['train_csv_file']))
test_df = to_csv(dermquest)
test_df.to_csv(image_config['test_csv_file'], index=None)
logger.info('Successfully convert %d examples to %s' %
(len(test_df), image_config['test_csv_file']))
def kfold_evaluation():
final_result = []
logger.info('K-fold evaluation process...')
config = my_utils.load_config()
dermis = inputs.load_training_data('dermis', config)
dermquest = inputs.load_training_data('dermquest', config)
n_folds = config['n_folds']
for i in range(n_folds):
test_data = inputs.get_kth_fold(dermquest,
i,
n_folds,
type_='test',
seed=config['split_seed'])
kfold_config = my_utils.get_config_for_kfold(config,
train_dir=os.path.join(
config['train_dir'],
str(i)))
logger.info('Evaluating for %i-th fold data...' % i)
result = evaluate_one_fold(test_data, kfold_config)
final_result.append(result)
logger.info('Result for %d-th: \n%s' %
(i, json.dumps(result, indent=2)))
logger.info('************************************\n\n')
logger.info('Done evaluation')
return final_result
def main(_):
logger.info('Creating Tf-record files...')
image_config = my_utils.load_config('./image_config.json')
create_one_record_file(image_config['train_csv_file'],
image_config['train_record_file'])
create_one_record_file(image_config['test_csv_file'],
image_config['test_record_file'])
logger.info('Tf-record file created!')
def eval_seg_model(eval_one_func):
logger.info('K-fold evaluation process...')
config = my_utils.load_config()
dermquest = inputs.load_raw_data(FLAGS.db, config)
mm = evaluation.SegRestoredModel(
tf.train.latest_checkpoint(config['train_dir']))
result = test_one_model(mm, dermquest.listing, config, eval_one_func)
logger.info('Done evaluation')
return result
def aggregate_all_result():
results = []
config = my_utils.load_config()
for i in range(config['n_folds']):
result_i = my_utils.load_obj(OUT_PATH % i)
logger.info('***********************Result %d******************' % i)
logger.info(result_i)
results.append(result_i)
final_result = aggregate_result(results)
logger.info('**********************Final Result********************')
logger.info(final_result)
def __init__(self, ckpt_path):
super().__init__()
with tf.Graph().as_default() as g:
config = my_utils.load_config()
config['batch_size'] = 1
image_ph, label_ph = seg_model.model_placeholders(config)
self.image_ph = image_ph
self.model = seg_model.SegModel(image_ph, True)
saver = tf.train.Saver()
self.session = tf.Session(
graph=g, config=tf.ConfigProto(device_count={'GPU': 1}))
saver.restore(self.session, ckpt_path)
def kfold_training():
logger.info('K-fold training...')
config = my_utils.load_config()
dermis = inputs.load_raw_data('dermis', config)
dermquest = inputs.load_raw_data('dermquest', config)
n_folds = config['n_folds']
for i in range(n_folds):
kfold_data = inputs.get_kth_fold(dermquest,
i,
n_folds,
seed=config['split_seed'])
train_data = dermis + kfold_data
kfold_config = my_utils.get_config_for_kfold(
config,
train_dir=os.path.join(config['train_dir'], str(i)),
n_examples_for_train=len(train_data))
logger.info('Training for %i-th fold data...' % i)
train_one_fold(train_data, kfold_config)
logger.info('Done training')
def eval_one_fold(fold, ckpt_path, out_path, ignore_iou=None):
if ignore_iou:
logger.warning('Will ignore images with IoU small than %.3f' % ignore_iou)
config = my_utils.load_config()
net = RestoredModel(ckpt_path)
dermquest = inputs.load_raw_data('dermquest', config)
# train_data = inputs.get_kth_fold(dermquest, fold, config['n_folds'], seed=config['split_seed'])
test_data = inputs.get_kth_fold(dermquest, fold, config['n_folds'], seed=config['split_seed'], type_='test')
with net.graph.as_default() as g:
result = {
'TP': 0,
'TN': 0,
'FP': 0,
'FN': 0
}
def update_dict(target, to_update):
for key in to_update:
target[key] += to_update[key]
with tf.Session(graph=g, config=tf.ConfigProto(device_count={'GPU': 0})):
counter = 0
for i, base in enumerate(test_data.listing):
image, label, bbox_gt = inputs.load_one_example(base, highest_to=800)
result_i, _ = evaluation.inference_with_restored_model(net, image, label,
bbox_gt=bbox_gt,
verbose=False,
times=3,
gt_prob=0.51)
if ignore_iou and _['IoU'] < ignore_iou:
counter += 1
print(i, base, '---->')
continue
update_dict(result, result_i)
result_i.update(my_utils.metric_many_from_counter(result_i))
result.update(my_utils.metric_many_from_counter(result))
logger.warning('%d of the images are ignored' % counter)
logger.info(result)
my_utils.dump_obj(out_path, result)
logger.info('Result saved at %s' % out_path)
def inference_one_image_from_prob(image):
config = my_utils.load_config()
with tf.Graph().as_default():
global_step = tf.train.get_or_create_global_step()
image_ph, _, _ = model.model_placeholder(config)
mm = model.Model(image_ph, config['input_size'])
def build_feed_dict(x):
return {image_ph: x}
saver = tf.train.Saver()
with tf.Session() as sess:
my_utils.load_model(saver, config)
logger.info('Model-%i restored successfully!' %
sess.run(global_step, ))
ops = [
mm.endpoints['bbox'], mm.endpoints['lesion_mask'],
mm.endpoints['lesion_prob']
]
bbox, lesion_mask, lesion_prob = sess.run(ops,
build_feed_dict(image))
cnn_result = get_cnn_result(image.shape[:-1], bbox, lesion_mask)
cnn_crf_result = get_cnn_crf_result(image, bbox, lesion_prob)
return bbox, cnn_result, cnn_crf_result
import my_utils as mu
import tensorflow as tf
from experiment import Experiment
parser = mu.get_default_parser()
def main():
experiment = Experiment(config)
experiment.eval()
if __name__ == '__main__':
tf.logging.set_verbosity(tf.logging.INFO)
config = mu.load_config()
main()
default='cv',
type=str,
help='Dataset for evaluation')
def main():
def eval_input_fn():
return input_fn(*data[config['data']],
batch_size=config['batch_size'],
shuffle=False)
data = inputs.load_data(config['n_examples_for_cv'])
estimator = tf.estimator.Estimator(model_fn=model_fn,
params=config,
model_dir=config['model_dir'])
for ckpt in tf.train.get_checkpoint_state(
config['model_dir']).all_model_checkpoint_paths:
with mu.Timer() as timer:
result = estimator.evaluate(eval_input_fn, checkpoint_path=ckpt)
result['data'] = config['data']
logger.info('Done in %.fs', timer.eclipsed)
logger.info('\n%s\n%s%s%s\n', data, '*' * 10, result, '*' * 10)
if __name__ == '__main__':
tf.logging.set_verbosity(tf.logging.INFO)
FLAGS = parser.parse_args()
config = mu.load_config(path=None, **FLAGS.__dict__)
logger.info('\n%s\n', mu.json_out(config))
main()
def train_from_scratch():
logger.info('Training from scratch...')
config = my_utils.load_config()
# data = inputs.load_raw_data(config['database'], config)
# dermis_data = inputs.load_raw_data('dermis', config)
# data = data + dermis_data
dermis = inputs.load_raw_data('dermis', config)
dermquest = inputs.load_raw_data('dermquest', config)
kfold_train_data = inputs.get_kth_fold(dermquest,
0,
config['n_folds'],
seed=config['split_seed'])
data = dermis + kfold_train_data
n_examples_for_train = len(data)
n_steps_for_train = my_utils.calc_training_steps(
config['n_epochs_for_train'], config['batch_size'],
n_examples_for_train)
config['n_examples_for_train'] = n_examples_for_train
with tf.Graph().as_default() as g:
image_ph, label_ph, bbox_ph = bbox_model.model_placeholder(config)
def build_feed_dict(image_, label_, bbox_):
return {image_ph: image_, label_ph: label_, bbox_ph: bbox_}
global_step = tf.train.get_or_create_global_step()
mm = bbox_model.Model(image_ph, config['input_size'])
train_op, summary_op, debug = build_train(mm, label_ph, bbox_ph,
config)
logger.info('Done loading data set `%s`, %i examples in total' %
(config['database'], len(data)))
my_utils.create_and_delete_if_exists(config['train_dir'])
saver = tf.train.Saver()
writer = tf.summary.FileWriter(config['train_dir'], graph=g)
with tf.Session() as sess:
tf.global_variables_initializer().run()
for i, (images, labels,
bboxes) in enumerate(data.aug_train_batch(config)):
# image, label, bbox = data[0]
feed_dict = build_feed_dict(images, labels, bboxes)
ops = [debug['bbox_loss'], debug['total_loss'], train_op]
bbox_loss_val, total_loss_val, _ = sess.run(
ops, feed_dict=feed_dict)
if i % config['log_every'] == 0:
fmt = 'step {:>5}/{} bbox_loss {:.5f}, total_loss {:.5f}'
logger.info(
fmt.format(i, n_steps_for_train, bbox_loss_val,
total_loss_val))
if i % config['checkpoint_every'] == 0:
my_utils.save_model(saver, config)
logger.info('Model saved at step-%i' %
sess.run(global_step))
if config['save_summary_every'] and i % config[
'save_summary_every'] == 0:
my_utils.add_summary(writer, summary_op, feed_dict)
logger.info('Summary saved at step-%i' %
sess.run(global_step))
save_path = my_utils.save_model(saver, config)
logger.info('Done training, model saved at %s' % (save_path, ))
import my_utils
import model
import inputs
import bbox_model
import evaluation
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from scipy.misc import imresize
config = my_utils.load_config()
logger = my_utils.get_default_logger()
def test_model():
image = tf.placeholder(dtype=tf.uint8,
name='images',
shape=config['input_size'] + [3])
mm = model.Model(image, config['input_size'])
logger.info(mm)
def test_huber_loss():
x = np.linspace(4, -4, 50)
with tf.Graph().as_default():
xx = tf.constant(x)
yy = my_utils.huber_loss(xx)
with tf.Session() as sess:
a, b = sess.run([xx, yy])
plt.plot(a, b)
import my_utils as mu print(mu.load_config())
