def train_new_model(model, train_queue, valid_queue, test_queue): ori_model = model.module if args.distributed else model optimizer = get_optimizer(model, args) scheduler = get_scheduler(optimizer, args) drop_layers = ori_model.drop_layers() criterion = get_criterion(args.classes, args.label_smoothing) for epoch in range(args.epochs): scheduler.step() if args.warmup and epoch < args.warmup_epochs: lr = args.learning_rate * epoch / args.warmup_epochs + args.warmup_lr for param_group in optimizer.param_groups: param_group['lr'] = lr cond_logging('epoch %d lr %e', epoch, lr) else: lr = scheduler.get_lr()[0] cond_logging('epoch %d lr %e', epoch, lr) if args.distributed: train_queue.sampler.set_epoch(epoch) if args.epd: drop_rate = args.drop_rate * epoch / args.epochs else: drop_rate = args.drop_rate drop_rates = [drop_rate] * drop_layers if args.layerd: for i in range(drop_layers): drop_rates[i] = drop_rates[i] * (i + 1) / drop_layers ori_model.set_drop_rates(drop_rates) cond_logging('drop rates:') cond_logging(ori_model.drop_rates) #training train_acc, train_obj = train(train_queue, model, criterion, optimizer, lr, args.report_freq, args.world_size, args.distributed, args.local_rank) cond_logging('train acc %f', train_acc) #validation drop_rates = [0] * drop_layers ori_model.set_drop_rates(drop_rates) valid_acc, valid_obj = infer(valid_queue, model, criterion, args.report_freq, args.world_size, args.distributed, args.local_rank) cond_logging('valid acc %f', valid_acc) test_acc, test_obj = infer(test_queue, model, criterion, args.report_freq, args.world_size, args.distributed, args.local_rank) cond_logging('test acc %f', test_acc) return model
def main(argv): frames = 16 batch_size = 1 input_shape = [320, 180, 3] model = model.build(input_shape, None, None, frames=frames) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) iterations = 100 input_shape = model.input_shape.as_list()[1:] print("Creating inputs with shape", input_shape) start_time = time.monotonic() for i in range(iterations): output = model.infer(sess, {model.input: [np.random.rand(*input_shape)]}) print(output) end_time = time.monotonic() total_time = end_time - start_time inference_time = total_time / iterations print(iterations, "inferences in", total_time, "s") print(inference_time, "s per inference") print(1 / inference_time, "inferences per second") print("up to", frames / inference_time, "frames per second without skip")
def start_page(): if request.method == 'POST': context = request.form['context'] question = request.form['question'] result = model.infer(context=context, question=question) return result else: return render_template('start.html', name=None)
def hello_world(): print('request received') model = load() content = request.get_json() query = content['query'] # TODO try-except blocks to check that everything is correct print('returning ans') output = {'answer': infer(model, query)} return jsonify(output)
def api_v1_infer(): """API Function""" j = request.get_json() default_txt = "Please write something" r = ( ( infer(j['text']) if len(j['text']) > 0 else default_txt ) if 'text' in j else default_txt ) if j is not None else default_txt print(r) return jsonify(dict(input='YOU: ' + j['text'], output='CHATBOT: ' + r))
from util import to_spec, to_wav_file, bss_eval_sdr import librosa from statistics import median batchSize = 1 # Model print('Initialize network model') with tf.device('/device:GPU:0'): x_mixed = tf.placeholder(tf.float32, shape=(batchSize, 512, 64, 1), name='x_mixed') y_mixed = tf.placeholder(tf.float32, shape=(batchSize, 512, 64, 2), name='y_mixed') y_pred = infer(x_mixed, 4) #y_output = tf.multiply(x_mixed,y_pred) net = tf.make_template('net', y_pred) x_input = np.zeros((batchSize, 512, 64, 1), dtype=np.float32) #y_input = np.zeros((batchSize, 512, 64, 2),dtype=np.float32) sdr_vocal = [] sdr_other = [] sdr_bass = [] sdr_drum = [] with tf.Session(config=NetConfig_DSD_100.session_conf) as sess: # Initialized, Load state sess.run(tf.global_variables_initializer())
def main(params): with tf.Session() as sess: model = infer(sess, params) model.test(params)
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('-ckpt', '--checkpoint_path', type=str, required=True, help='trained checkpoint path') parser.add_argument('--model_name', type=str, default='345K', help='model (architecture) name') parser.add_argument("--device", type=int, default=1) parser.add_argument("--seed", type=int, default=None) parser.add_argument("--nsamples", type=int, default=2) parser.add_argument("--batch_size", type=int, default=1) parser.add_argument("--tok_length", type=int, default=128) parser.add_argument("--sent_length", type=int, default=3) parser.add_argument("--top_k", type=int, default=0) parser.add_argument("--top_p", type=float, default=.0) parser.add_argument("--context", type=str, default="북한의 발사체 도발은 지난달 25일 단거리 탄도미사일로 추정되는 발사체를 쏜 이후 13일 동안 4번째입니다.") args = parser.parse_args() model = GPT(args.checkpoint_path, args.model_name, args.device, args.seed, args.nsamples, args.batch_size, args.tok_length, args.sent_length, args.top_k, args.top_p) out = model.infer(args.context) print(out)
parser.add_argument( '--output_dir', help='GCS location to write checkpoints and export models', required=True) parser.add_argument('--train_steps', help='How many batches to run training job for', type=int, default=20000) args = parser.parse_args() arguments = args.__dict__ # unused args provided by service arguments.pop('job_dir', None) arguments.pop('job-dir', None) output_dir = arguments.pop('output_dir') model.init(arguments.pop('train_steps')) # Append trial_id to path if we are doing hptuning # This code can be removed if you are not using hyperparameter tuning output_dir = os.path.join( output_dir, json.loads(os.environ.get('TF_CONFIG', '{}')).get('task', {}).get('trail', '')) # Run the training job #shutil.rmtree(output_dir, ignore_errors=True) # start fresh each time learn_runner.run(model.experiment_fn, output_dir) model.infer(output_dir)
def do_nearest(model, sess, stream_input, restore_path, dataset, split, k=4): """ From encoding of images, find the nearest neighbor of each image Args: model : model sess : tensorflow session stream_input : data manager restore_path : where is the restore file dataset : which dataset split : which split (valid, test, etc.) k : number of closest """ print('------------------------------------------------------') print('Computing the %d nearest neighbors of images of %s from %s ...' % (k, dataset, split)) print('------------------------------------------------------\n') images, labels, name = stream_input.get_inputs() guess, _, inter_feature = model.infer(images, inter_layer=True) num_iter = int(stream_input.size_epoch / stream_input.batch_size) num_examples = num_iter * stream_input.batch_size dimension = inter_feature.get_shape()[1].value index_representation = np.empty((num_examples), dtype='a1000') representation = np.zeros((num_examples, dimension)) closest = np.zeros((num_examples, k + 1)) print('------------------------------------------------------' ) #Initialisation of weights sess.run(tf.global_variables_initializer()) print('Restoring from previous checkpoint...') ret = restore_model(model, sess, restore_path) tf.train.start_queue_runners(sess=sess) stream_input.start_threads(sess) print('------------------------------------------------------') print('Done! Training ended at step %s' % (ret)) print('------------------------------------------------------ \n') print('------------------------------------------------------') print('There are %d data to process in %d iterations' % (num_examples, num_iter)) print('------------------------------------------------------ \n') for step in range(num_iter): sys.stdout.write('%d out of %d \r' % (step, num_iter)) sys.stdout.flush() code, name_ret = sess.run([inter_feature, name]) for i in range(stream_input.batch_size): for j in range(dimension): representation[i + step * stream_input.batch_size, j] = code[i, j] index_representation[i + step * stream_input.batch_size] = name_ret[i] print('------------------------------------------------------ ') print('Step 1: Done!') print('------------------------------------------------------ \n') path = restore_path + '/' + model.name path += '/neighbour_' + dataset + '_' + split + '/' if tf.gfile.Exists(path): tf.gfile.DeleteRecursively(path) tf.gfile.MakeDirs(path) for i in range(num_examples): sys.stdout.write('%d out of %d \r' % (i, num_examples)) sys.stdout.flush() ret = np.reshape(np.tile(representation[i], num_examples), (num_examples, dimension)) distance = np.sum(np.square(representation - ret), axis=1) closest[i] = np.argsort(distance)[0:k + 1] shutil.copy2( os.path.join(stream_input.f1, str(index_representation[i])), path + str(index_representation[i]).split('.')[0] + '_im' + '.jpg') for j in range(k + 1): if j > 0: shutil.copy2( os.path.join(stream_input.f1, str(index_representation[int(closest[i, j])])), path + str(index_representation[i]).split('.')[0] + '_neighbour_' + str(j) + '_' + str(index_representation[int( closest[i, j])]).split('.')[0] + '.jpg') print('------------------------------------------------------ ') print('Step 2: Done!') print('------------------------------------------------------ \n')
def compute_inter(model, sess, stream_input, restore_path, dataset, split, arithmetic): """ From real encoding of images, comoute new encodign and save the final results Args: model : model sess : tensorflow session stream_input : data manager restore_path : where is the restore file dataset : which dataset split : which split (valid, test, etc.) arithmetic : how to transform encoding (1 is add, 2 subtract, 3 is linear combination) """ print('------------------------------------------------------') print('Computing operations on encoding of images of %s from %s ...' % (dataset, split)) print('------------------------------------------------------') if arithmetic == 1: print('Operation is addition') elif arithmetic == 2: print('Operation is subtraction') elif arithmetic == 3: print('Operation is linear combination') print('------------------------------------------------------\n') images, labels, name = stream_input.get_inputs() guess, _, _ = model.infer(images, arithmetic=arithmetic) print('------------------------------------------------------' ) #Initialisation of weights sess.run(tf.global_variables_initializer()) print('Restoring from previous checkpoint...') ret_bis = restore_model(model, sess, restore_path) tf.train.start_queue_runners(sess=sess) stream_input.start_threads(sess) print('------------------------------------------------------') print('Done! Training ended at step %s' % (ret_bis)) print('------------------------------------------------------ \n') path = restore_path + '/' + model.name path += '/results_arith_' + dataset + '_' + split + '_' + str( arithmetic) + '/' if tf.gfile.Exists(path): tf.gfile.DeleteRecursively(path) tf.gfile.MakeDirs(path) num_iter = int(stream_input.size_epoch / stream_input.batch_size) print('------------------------------------------------------') print('There are %d data to process in %d iterations' % (int(stream_input.size_epoch), num_iter)) print('------------------------------------------------------ \n') for step in range(num_iter): sys.stdout.write('%d out of %d \r' % (step, num_iter)) sys.stdout.flush() images_ret, labels_ret, guess_ret, name_ret = sess.run( [images, labels, guess, name]) for i in range(model.batch_size): ret_path = path + str(i + step * model.batch_size) + '_' + str( name_ret[i]) ret = np.asarray(images_ret[i] * 255, dtype="int8") Image.fromarray(ret, 'RGB').save(ret_path + '_' + 'im' + '.jpg') ret = np.asarray(labels_ret[i] * 255, dtype="int8") Image.fromarray(ret, 'P').save(ret_path + '_' + 'lab' + '.png') ret = np.asarray(guess_ret[i] * 255, dtype="int8") Image.fromarray(ret, 'P').save(ret_path + '_' + 'guess' + '.png') print('------------------------------------------------------ ') print('Done!') print('------------------------------------------------------ \n')
def visual_tracking(model, sess, restore_path, folder_data): """ Compute the tracking boundig boxe naively for each frame of the given sequence Args: model : model sess : tensorflow session restore_path : where is the restore file folder_data : the sequence location """ print('------------------------------------------------------') print('Performing tracking on given sequence %s ...' % (folder_data)) print('------------------------------------------------------\n') batch_size = model.batch_size images = tf.placeholder(tf.float32, shape=(batch_size, 224, 224, 3)) guess, _, _ = model.infer(images) zeros = tf.zeros_like(guess) ones = tf.ones_like(guess) threshold = 2 * tf.reduce_mean(guess, keep_dims=True) #Adaptive threshold output = tf.select(guess > threshold, ones, zeros) print('------------------------------------------------------' ) #Initialisation of weights sess.run(tf.global_variables_initializer()) print('Restoring from previous checkpoint...') ret_bis = restore_model(model, sess, restore_path) print('------------------------------------------------------') print('Done! Training ended at step %s' % (ret_bis)) print('------------------------------------------------------ \n') path = folder_data + '/results_tracking/' #Output folder if tf.gfile.Exists(path): tf.gfile.DeleteRecursively(path) tf.gfile.MakeDirs(path) tf.gfile.MakeDirs(path + 'out/') tf.gfile.MakeDirs(path + 'binary/') tf.gfile.MakeDirs(path + 'bb/') images_batch = np.empty((0, 224, 224, 3)) index_representation = np.empty((batch_size), dtype='a1000') index = 0 current = 0 tot = len([f for f in os.listdir(folder_data + '/img/') if ".jpg" in f]) print('------------------------------------------------------') for e in np.array( [f for f in os.listdir(folder_data + '/img/') if ".jpg" in f]): current += 1 sys.stdout.write('%d out of %d \r' % (current, tot)) sys.stdout.flush() im = Image.open( os.path.join(folder_data + '/img/', e)) #Read image one by one and add them to the batch im.load() w, h = im.size im = im.resize((224, 224)) im_a = np.asarray(im, dtype="int8") images_batch = np.append(images_batch, [im_a], axis=0) index_representation[index] = e index += 1 if index == batch_size: #Ready to be processed guess_ret, threshold_ret, output_ret = sess.run( [guess, threshold, output], feed_dict={images: images_batch / 255}) for i in range(batch_size): ret_out = np.asarray(guess_ret[i] * 255, dtype="int8") #Score output Image.fromarray(ret_out, 'P').save(path + 'out/' + index_representation[i] + '_out' + '.png') ret_out_b = np.asarray(output_ret[i] * 255, dtype="int8") #Binary output Image.fromarray(ret_out_b, 'P').save(path + 'binary/' + index_representation[i] + '_binary' + '.png') im = Image.fromarray( np.asarray(images_batch[i], dtype=np.uint8), 'RGB') draw = ImageDraw.Draw(im) #Bounding box ret_mask = np.nonzero(ret_out_b) x0 = np.amin(ret_mask, axis=1)[1] y0 = np.amin(ret_mask, axis=1)[0] x1 = np.amax(ret_mask, axis=1)[1] y1 = np.amax(ret_mask, axis=1)[0] draw.rectangle([x0, y0, x1, y1], outline='red') im_b = im.resize((2 * w, 2 * h)) im_b.save(path + 'bb/' + index_representation[i] + '_final' + '.png') del draw images_batch = np.empty((0, 224, 224, 3)) index_representation = np.empty((batch_size), dtype='a1000') index = 0 print('------------------------------------------------------ \n') if index != 0: #Last batch not processed number = index while index != batch_size: im = np.zeros((224, 224, 3)) images_batch = np.append(images_batch, [im], axis=0) index += 1 guess_ret, threshold_ret, output_ret = sess.run( [guess, threshold, output], feed_dict={images: images_batch / 255}) for i in range(number): ret_out = np.asarray(guess_ret[i] * 255, dtype="int8") #Score output Image.fromarray(ret_out, 'P').save(path + 'out/' + index_representation[i] + '_out' + '.png') ret_out_b = np.asarray(output_ret[i] * 255, dtype="int8") #Binary output Image.fromarray(ret_out_b, 'P').save(path + 'binary/' + index_representation[i] + '_binary' + '.png') im = Image.fromarray(np.asarray(images_batch[i], dtype=np.uint8), 'RGB') draw = ImageDraw.Draw(im) #Bounding box ret_mask = np.nonzero(ret_out_b) x0 = np.amin(ret_mask, axis=1)[1] y0 = np.amin(ret_mask, axis=1)[0] x1 = np.amax(ret_mask, axis=1)[1] y1 = np.amax(ret_mask, axis=1)[0] draw.rectangle([x0, y0, x1, y1], outline='red') im_b = im.resize((2 * w, 2 * h)) im_b.save(path + 'bb/' + index_representation[i] + '_final' + '.png') del draw print('------------------------------------------------------ ') print('Done!') print('------------------------------------------------------ \n')
def do_train(model, sess, stream_input, stream_input_aux, max_step, log_folder, mode, weight_file=None, model_to_copy=None, model_copy_is_concat=False, valid=True, dataset=None, save_copy=False): """ Train the model Args: model : model to compute the score of sess : tensorflow session stream_input : data manager stream_input_aux : data manager for auxiliary dataset (valdiation) max_step : numbers of step to train log_folder : where is the log of the model mode : how to initialize weights weight_file : location of vgg model if pretraining model_to_copy : weights of model to copy if restoring only weight (from another model) model_copy_is_concat : whether the model to copy has direct connections valid : whether to use validation dataset : dataset for the auxiliary data using during validation save_copy : whether to save a copy of the model at the end with the weight only """ print('------------------------------------------------------') print('Starting training the model (number of steps is %d) ...' % (max_step)) print('------------------------------------------------------\n') global_step = tf.Variable(0, trainable=False) images, labels, _ = stream_input.get_inputs() guess, control, _ = model.infer(images, debug=True) loss = model.loss(guess, labels) train_op = model.train(loss, global_step) if valid: images_aux, labels_aux, _ = stream_input_aux.get_inputs() guess_aux, _, _ = model.infer(images_aux) loss_aux = model.loss(guess_aux, labels_aux, loss_bis=True) zeros = tf.zeros_like(labels_aux) ones = tf.ones_like(labels_aux) threshold = [i for i in range(255)] liste = [] for thres in threshold: predicted_class = tf.select(guess_aux * 255 > thres, ones, zeros) true_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, ones), tf.equal(labels_aux, ones)), tf.float32), [1, 2]) false_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, ones), tf.equal(labels_aux, zeros)), tf.float32), [1, 2]) true_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, zeros), tf.equal(labels_aux, zeros)), tf.float32), [1, 2]) false_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, zeros), tf.equal(labels_aux, ones)), tf.float32), [1, 2]) precision = tf.reduce_sum(true_positive / (1e-8 + true_positive + false_positive)) recall = tf.reduce_sum(true_positive / (1e-8 + true_positive + false_negative)) liste.append(tf.pack([precision, recall])) result = tf.pack(liste) adaptive_threshold = ( 2 * tf.reduce_mean(guess_aux, [0, 1], keep_dims=True)) adaptive_output = tf.select(guess_aux > adaptive_threshold, ones, zeros) adaptive_true_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, ones), tf.equal(labels_aux, ones)), tf.float32), [1, 2]) adaptive_false_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, ones), tf.equal(labels_aux, zeros)), tf.float32), [1, 2]) adaptive_true_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, zeros), tf.equal(labels_aux, zeros)), tf.float32), [1, 2]) adaptive_false_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, zeros), tf.equal(labels_aux, ones)), tf.float32), [1, 2]) adaptive_precision = tf.reduce_sum( adaptive_true_positive / (1e-8 + adaptive_true_positive + adaptive_false_positive)) adaptive_recall = tf.reduce_sum( adaptive_true_positive / (1e-8 + adaptive_true_positive + adaptive_false_negative)) adaptive_f_measure = tf.reduce_sum( 1.3 * adaptive_precision * adaptive_recall / (1e-8 + 0.3 * adaptive_precision + adaptive_recall)) print('------------------------------------------------------' ) #Initialisation of weights sess.run(tf.global_variables_initializer()) if mode == 'pretrain': print('Loading weights from vgg file...') load_weights(model, sess, weight_file) elif mode == 'restore': print('Restoring from previous checkpoint...') sess.run( global_step.assign(int(restore_model(model, sess, log_folder)))) elif mode == 'restore_w_only': print('Restoring (weights only) from model %s ...' % (model_to_copy)) restore_weight_from(model, model_to_copy, sess, log_folder, copy_concat=model_copy_is_concat) elif mode == 'scratch': print('Initializing the weights from scratch') print('------------------------------------------------------') print('Done!') print('------------------------------------------------------ \n') tf.train.start_queue_runners(sess=sess) stream_input.start_threads(sess) if valid: stream_input_aux.start_threads(sess) if tf.gfile.Exists(log_folder + '/' + model.name + '_validation_log'): tf.gfile.DeleteRecursively(log_folder + '/' + model.name + '_validation_log') tf.gfile.MakeDirs(log_folder + '/' + model.name + '_validation_log') for step in range(max_step): start_time = time.time() _, loss_value, control_value, step_b = sess.run( [train_op, loss, control, tf.to_int32(global_step)]) duration = time.time() - start_time if step % 5 == 0: #Display progress print( '%s: step %d out of %d, loss = %.5f (%.1f examples/sec; %.3f sec/batch) --- control value is %.12f' % (datetime.now(), step_b, max_step - step + step_b, loss_value, stream_input.batch_size / duration, float(duration), control_value)) if step % 1000 == 0 and step != 0: #Save model save_model(model, sess, log_folder, step_b) if valid and step % 5000 == 0: #Validation print('------------------------------------------------------') print('Doing validation ...') print('------------------------------------------------------ \n') loss_tot = 0 num_iter = int(stream_input_aux.size_epoch / stream_input_aux.batch_size) counter = np.zeros((256, 3)) for step1 in range(num_iter): sys.stdout.write('%d out of %d \r' % (step1, num_iter)) sys.stdout.flush() result_ret, adaptive_precision_ret, adaptive_recall_ret, adaptive_f_measure_ret, loss_value = sess.run( [ result, adaptive_precision, adaptive_recall, adaptive_f_measure, loss_aux ]) loss_tot += loss_value loss_mean = loss_tot / (step1 + 1) for i in range(255): for j in range(2): counter[i, j] += result_ret[i, j] counter[255, 0] += adaptive_precision_ret counter[255, 1] += adaptive_recall_ret counter[255, 2] += adaptive_f_measure_ret file = open( log_folder + '/' + model.name + '_validation_log/' + str(step_b) + ".txt", 'w') file.write('model name is ' + model.name + '\n') file.write('number trained step is ' + str(step_b) + '\n') file.write('aux dataset is ' + str(dataset) + '\n') file.write('loss mean is ' + str(loss_mean) + '\n') file.write('split of dataset is valid\n') for i in range(256): precision = counter[i, 0] / (num_iter * stream_input_aux.batch_size) recall = counter[i, 1] / (num_iter * stream_input_aux.batch_size) file.write( 'Precision %0.02f percent -- Recall %0.02f percent\n' % (precision * 100, recall * 100)) if i == 255: f = counter[i, 2] / (num_iter * stream_input_aux.batch_size) file.write('fscore %0.04f\n' % (f)) if i % 20 == 0: print('Precision %0.02f percent -- Recall %0.02f percent' % (precision * 100, recall * 100)) file.close() print('\n------------------------------------------------------') print('Done!') print('------------------------------------------------------ \n') save_model(model, sess, log_folder, step_b) #Final save print('------------------------------------------------------') print('Save done!') if save_copy: save_weight_only(model, sess, log_folder, step_b) #Final save print('Saving weights onlt done!') print('------------------------------------------------------ \n')
def compute_score(model, sess, stream_input, restore_path, dataset, split, write=False, save=False): """ Compute the precision recall score for a given model, with the addition of the F1 score. Args: model : model to compute the score of sess : tensorflow session stream_input : data manager restore_path : where is the restore file dataset : dataset tested split : which split (valid, test, etc.) write : whether to write the result in a file save : whether to save the resulting saliency maps """ print('------------------------------------------------------') print('Computing score of the model on %s from %s ...' % (dataset, split)) print('Write result file : %r -- Save images : %r' % (write, save)) print('------------------------------------------------------\n') images, labels, names = stream_input.get_inputs() guess, _, _ = model.infer(images) zeros = tf.zeros_like(labels) ones = tf.ones_like(labels) threshold = [i for i in range(255)] liste = [] for t in threshold: predicted_class = tf.select(guess * 255 > t, ones, zeros) true_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, ones), tf.equal(labels, ones)), tf.float32), [1, 2]) false_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, ones), tf.equal(labels, zeros)), tf.float32), [1, 2]) true_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, zeros), tf.equal(labels, zeros)), tf.float32), [1, 2]) false_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(predicted_class, zeros), tf.equal(labels, ones)), tf.float32), [1, 2]) precision = tf.reduce_sum(true_positive / (1e-8 + true_positive + false_positive)) recall = tf.reduce_sum(true_positive / (1e-8 + true_positive + false_negative)) liste.append(tf.pack([precision, recall])) result = tf.pack(liste) adaptive_threshold = 2 * tf.reduce_mean(guess, [1, 2], keep_dims=True) adaptive_output = tf.select(guess > adaptive_threshold, ones, zeros) adaptive_true_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, ones), tf.equal(labels, ones)), tf.float32), [1, 2]) adaptive_false_positive = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, ones), tf.equal(labels, zeros)), tf.float32), [1, 2]) adaptive_true_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, zeros), tf.equal(labels, zeros)), tf.float32), [1, 2]) adaptive_false_negative = tf.reduce_sum( tf.cast( tf.logical_and(tf.equal(adaptive_output, zeros), tf.equal(labels, ones)), tf.float32), [1, 2]) adaptive_precision = tf.reduce_sum( adaptive_true_positive / (1e-8 + adaptive_true_positive + adaptive_false_positive)) adaptive_recall = tf.reduce_sum( adaptive_true_positive / (1e-8 + adaptive_true_positive + adaptive_false_negative)) adaptive_f_measure = tf.reduce_sum( 1.3 * adaptive_precision * adaptive_recall / (1e-8 + 0.3 * adaptive_precision + adaptive_recall)) print('------------------------------------------------------' ) #Initialisation of weights sess.run(tf.global_variables_initializer()) print('Restoring from previous checkpoint...') ret_bis = restore_model(model, sess, restore_path) tf.train.start_queue_runners(sess=sess) stream_input.start_threads(sess) print('------------------------------------------------------') print('Done! Training ended at step %s' % (ret_bis)) print('------------------------------------------------------ \n') if save: #Save result images path = restore_path + '/' + model.name path += '/result_' + dataset + '/' if tf.gfile.Exists(path): tf.gfile.DeleteRecursively(path) tf.gfile.MakeDirs(path) num_iter = int(stream_input.size_epoch / stream_input.batch_size) counter = np.zeros((256, 3)) print('------------------------------------------------------') for step in range(num_iter): #Compute score sys.stdout.write('%d out of %d \r' % (step, num_iter)) sys.stdout.flush() result_ret, adaptive_precision_ret, adaptive_recall_ret, adaptive_f_measure_ret, names_ret, images_ret, labels_ret, guess_ret = sess.run( [ result, adaptive_precision, adaptive_recall, adaptive_f_measure, names, images, labels, guess ]) for i in range(stream_input.batch_size): if save: #Save result images ret_path = path + names_ret[i] ret = np.asarray(images_ret[i] * 255, dtype="int8") Image.fromarray(ret, 'RGB').save(ret_path + '_' + 'im' + '.png') ret = np.asarray(labels_ret[i] * 255, dtype="int8") Image.fromarray(ret, 'P').save(ret_path + '_' + 'lab' + '.png') ret = np.asarray(guess_ret[i] * 255, dtype="int8") Image.fromarray(ret, 'P').save(ret_path + '_' + 'guess' + '.png') for i in range(255): for j in range(2): counter[i, j] += result_ret[i, j] counter[255, 0] += adaptive_precision_ret counter[255, 1] += adaptive_recall_ret counter[255, 2] += adaptive_f_measure_ret print('------------------------------------------------------ \n') for i in range(256): if i == 255: print('\n------------------------------------------------------') precision = counter[i, 0] / (num_iter * stream_input.batch_size) recall = counter[i, 1] / (num_iter * stream_input.batch_size) print('Precision %0.02f percent -- Recall %0.02f percent' % (precision * 100, recall * 100)) if i == 255: print('fscore %0.04f' % (counter[i, 2] / (num_iter * stream_input.batch_size))) print('------------------------------------------------------ \n') if write: #Save score file = open(restore_path + '/' + model.name + "/" + dataset + ".txt", 'w') file.write('model name is ' + model.name + '\n') file.write('number trained step is ' + str(ret_bis) + '\n') file.write('test dataset is ' + str(dataset) + '\n') file.write('split of dataset is ' + str(split) + '\n') for i in range(255): file.write( 'Precision %0.02f percent -- Recall %0.02f percent\n' % (counter[i, 0] / (num_iter * stream_input.batch_size) * 100, counter[i, 1] / (num_iter * stream_input.batch_size) * 100)) file.write( 'Precision %0.02f percent -- Recall %0.02f percent\n' % (counter[255, 0] / (num_iter * stream_input.batch_size) * 100, counter[255, 1] / (num_iter * stream_input.batch_size) * 100)) file.write('fscore %0.04f\n' % (counter[255, 2] / (num_iter * stream_input.batch_size))) file.close() print('------------------------------------------------------') print('Log file written') print('------------------------------------------------------ \n')