def optimize(self): utils.create_log_dir(self.hp_utils.save_path) if not self.restart: utils.check_conflict(self.hp_utils.save_path, check=self.check) utils.create_log_dir(self.hp_utils.save_path) dy = {y_name: None for y_name in self.hp_utils.y_names} self.hp_utils.save_hp_conf(list(range(len(self.hp_utils.var_names))), dy, None, record=False) self.n_jobs = self.get_n_jobs() self.check_double_submission() save_time = utils.save_elapsed_time(self.hp_utils.save_path, self.hp_utils.lock, self.verbose, self.print_freq) if self.n_parallels <= 1: self._optimize_sequential(save_time) else: self._optimize_parallel(save_time) hps_conf, losses = self.hp_utils.load_hps_conf(do_sort=True) best_hp_conf, best_performance = hps_conf[0], losses[0][0] self.print_optimized_result(best_hp_conf, best_performance) return best_hp_conf, best_performance
def optimize(self): utils.create_log_dir(self.hp_utils.save_path) if not self.restart: utils.check_conflict(self.hp_utils.save_path) utils.create_log_dir(self.hp_utils.save_path) self.n_jobs = self.get_n_jobs() if self.n_parallels <= 1: self._optimize_sequential() else: self._optimize_parallel() hps_conf, losses = self.hp_utils.load_hps_conf(do_sort=True) best_hp_conf, best_performance = hps_conf[0], losses[0] self.print_optimized_result(best_hp_conf, best_performance[0]) return best_hp_conf, best_performance
def main(args): # I/O config_file = args.config_file config = utils.import_file(config_file, 'config') #trainset = utils.Dataset(config.train_dataset_path) testset = utils.Dataset(config.test_dataset_path) network = BaseNetwork() network.initialize(config, 0 ) #trainset.num_classes # Initalization for running log_dir = utils.create_log_dir(config, config_file) summary_writer = tf.summary.FileWriter(log_dir, network.graph) if config.restore_model is not None: network.restore_model(config.restore_model, config.restore_scopes) # Set up LFW test protocol and load images print('Loading images...') lfwtest = LFWTest(testset.images) lfwtest.init_standard_proto(config.lfw_pairs_file) lfwtest.images = utils.preprocess(lfwtest.image_paths, config, is_training=False) #trainset.start_batch_queue(config, True) # # Main Loop # print('\nStart Training\nname: %s\n# epochs: %d\nepoch_size: %d\nbatch_size: %d\n'\ % (config.name, config.num_epochs, config.epoch_size, config.batch_size)) global_step = 0 # Testing on LFW print('Testing on Neetis LFW protocol...') embeddings = network.extract_feature(lfwtest.images, config.batch_size) print(type(embeddings)) accuracy_embeddings, threshold_embeddings = lfwtest.test_standard_proto(embeddings) print('Embeddings Accuracy: %2.4f Threshold %2.3f' % (accuracy_embeddings, threshold_embeddings)) with open(os.path.join(log_dir,'lfw_result.txt'),'at') as f: f.write('%d\t%.5f\n' % (global_step,accuracy_embeddings)) summary = tf.Summary() summary.value.add(tag='lfw/accuracy', simple_value=accuracy_embeddings) summary_writer.add_summary(summary, global_step)
def run(): args = argparser() path = utils.create_log_dir(sys.argv) utils.start(args.http_port) env = Env(args) agents = [Agent(args) for _ in range(args.n_agent)] master = Master(args) for agent in agents: master.add_agent(agent) master.add_env(env) success_list = [] time_list = [] for idx in range(args.n_episode): print('=' * 80) print("Episode {}".format(idx + 1)) # 서버의 stack, timer 초기화 print("서버를 초기화하는중...") master.reset(path) # 에피소드 시작 master.start() # 에이전트 학습 master.train() print('=' * 80) success_list.append(master.infos["is_success"]) time_list.append(master.infos["end_time"] - master.infos["start_time"]) if (idx + 1) % args.print_interval == 0: print("=" * 80) print("EPISODE {}: Avg. Success Rate / Time: {:.2} / {:.2}".format( idx + 1, np.mean(success_list), np.mean(time_list))) success_list.clear() time_list.clear() print("=" * 80) if (idx + 1) % args.checkpoint_interval == 0: utils.save_checkpoints(path, agents, idx + 1) if args.visual: visualize(path, args) print("끝") utils.close()
def main(args): # I/O config_file = args.config_file config = utils.import_file(config_file, 'config') trainset = utils.Dataset(config.train_dataset_path) testset = utils.Dataset(config.test_dataset_path) network = BaseNetwork() network.initialize(config, trainset.num_classes) # Initalization for running log_dir = utils.create_log_dir(config, config_file) summary_writer = tf.summary.FileWriter(log_dir, network.graph) if config.restore_model is not None: network.restore_model(config.restore_model, config.restore_scopes) # Set up LFW test protocol and load images print('Loading images...') lfwtest = LFWTest(testset.images) lfwtest.init_standard_proto(config.lfw_pairs_file) lfwtest.images = utils.preprocess(lfwtest.image_paths, config, is_training=False) trainset.start_batch_queue(config, True) # # Main Loop # print('\nStart Training\nname: %s\n# epochs: %d\nepoch_size: %d\nbatch_size: %d\n'\ % (config.name, config.num_epochs, config.epoch_size, config.batch_size)) global_step = 0 start_time = time.time() for epoch in range(config.num_epochs): # Training for step in range(config.epoch_size): # Prepare input learning_rate = utils.get_updated_learning_rate( global_step, config) batch = trainset.pop_batch_queue() wl, sm, global_step = network.train(batch['images'], batch['labels'], learning_rate, config.keep_prob) # Display if step % config.summary_interval == 0: duration = time.time() - start_time start_time = time.time() utils.display_info(epoch, step, duration, wl) summary_writer.add_summary(sm, global_step=global_step) # Testing on LFW print('Testing on standard LFW protocol...') embeddings = network.extract_feature(lfwtest.images, config.batch_size) accuracy_embeddings, threshold_embeddings = lfwtest.test_standard_proto( embeddings) print('Embeddings Accuracy: %2.4f Threshold %2.3f' % (accuracy_embeddings, threshold_embeddings)) with open(os.path.join(log_dir, 'lfw_result.txt'), 'at') as f: f.write('%d\t%.5f\n' % (global_step, accuracy_embeddings)) summary = tf.Summary() summary.value.add(tag='lfw/accuracy', simple_value=accuracy_embeddings) summary_writer.add_summary(summary, global_step) # Save the model network.save_model(log_dir, global_step)
help='Number of projections to test') parser.add_argument('-e', '--eps', nargs='?', default=0.001, type=float, help='Epsilon for entropic gw') args = parser.parse_args() all_samples = args.all_samples numItermax = args.nitermax projs = args.proj epsilon = args.eps niterentro = args.it_entro log_dir = utils.create_log_dir(args) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') results = {} results['all_samples'] = all_samples results['projs'] = projs results['epsilon'] = epsilon results['all_gw'] = [] results['t_all_gw'] = [] results['all_converged'] = [] results['all_entro_gw'] = [] results['t_all_entro_gw'] = []
from os.path import join import utils import builders import args from core.base import Trainer from core.plugins.logging import TrainLogger, MetricFileLogger, HeaderPrinter from core.plugins.storage import BestModelSaver, ModelLoader from metrics import KNNF1ScoreMetric, Evaluator # Script arguments args = args.get_args() # Create directory to save plots, models, results, etc log_path = utils.create_log_dir(args.exp_path, args) print(f"Logging to {log_path}") # Dump all script arguments utils.dump_params(join(log_path, 'config.cfg'), args) # Set custom seed utils.set_custom_seed(args.seed) # Load dataset and create model print(f"[Model: {args.model.upper()}]") print(f"[Loss: {args.loss.upper()}]") print('[Loading Dataset and Model...]') # Embedding dim is 768 based on BERT, we use the same for LSTM to be fair # Classes are 6 because we include a 'non-misogyny class' nfeat, nclass = 768, 6 config = builders.build_config(args, nfeat, nclass)
def main(args): # I/O config_file = args.config_file config = utils.import_file(config_file, 'config') trainset = utils.Dataset(config.train_dataset_path) testset = utils.Dataset(config.test_dataset_path) network = SiblingNetwork() network.initialize(config, trainset.num_classes) # Initalization for running log_dir = utils.create_log_dir(config, config_file) summary_writer = tf.summary.FileWriter(log_dir, network.graph) if config.restore_model: network.restore_model(config.restore_model, config.restore_scopes) # Set up test protocol and load images print('Loading images...') testset.separate_template_and_probes() testset.images = utils.preprocess(testset.images, config, is_training=False) trainset.start_batch_queue(config, True) # # Main Loop # print('\nStart Training\nname: %s\n# epochs: %d\nepoch_size: %d\nbatch_size: %d\n'\ % (config.name, config.num_epochs, config.epoch_size, config.batch_size)) global_step = 0 start_time = time.time() for epoch in range(config.num_epochs): # Training for step in range(config.epoch_size): # Prepare input learning_rate = utils.get_updated_learning_rate(global_step, config) image_batch, label_batch = trainset.pop_batch_queue() switch_batch = utils.zero_one_switch(len(image_batch)) wl, sm, global_step = network.train(image_batch, label_batch, switch_batch, learning_rate, config.keep_prob) # Display if step % config.summary_interval == 0: duration = time.time() - start_time start_time = time.time() utils.display_info(epoch, step, duration, wl) summary_writer.add_summary(sm, global_step=global_step) # Testing print('Testing...') switch = utils.zero_one_switch(len(testset.images)) embeddings = network.extract_feature(testset.images, switch, config.batch_size) tars, fars, _ = utils.test_roc(embeddings, FARs=[1e-4, 1e-3, 1e-2]) with open(os.path.join(log_dir,'result.txt'),'at') as f: for i in range(len(tars)): print('[%d] TAR: %2.4f FAR %2.3f' % (epoch+1, tars[i], fars[i])) f.write('[%d] TAR: %2.4f FAR %2.3f\n' % (epoch+1, tars[i], fars[i])) summary = tf.Summary() summary.value.add(tag='test/tar_%d'%i, simple_value=tars[i]) summary_writer.add_summary(summary, global_step) # Save the model network.save_model(log_dir, global_step)
parser.add_argument('--config_file', help='Path to training configuration file', type=str) config_file = parser.parse_args().config_file # I/O config = utils.import_file(config_file, 'config') trainset = utils.Dataset(config.splits_path + '/train_' + str(config.fold_number) + '.txt') trainset.images = utils.preprocess(trainset.images, config, True) network = Network() network.initialize(config, trainset.num_classes) # Initalization for running log_dir = utils.create_log_dir(config, config_file) summary_writer = tf.summary.FileWriter(log_dir, network.graph) if config.restore_model: network.restore_model(config.restore_model, config.restore_scopes) # Load gallery and probe file_list print('Loading images...') probes = [] gal = [] with open( config.splits_path + '/fold_' + str(config.fold_number) + '/probe_1.txt', 'r') as f: for line in f: probes.append(line.strip()) probe_set = evaluate.ImageSet(probes, config)
if args.alpha==-8000 and not args.automatic_cv_alpha: raise AlphaMustBeDefinedError('You must set alpha via -a or use automatic grid via -cva') name='fgw'+'_'+args.dataset_name+'_feature_metric_'+args.feature_metric+'_structure_metric_'+args.structure_metric if args.wl_feature>0: name=name+'_wl_'+str(args.wl_feature) name=name+args.optionnal_name try: if not os.path.exists(args.log_dir): os.makedirs(args.log_dir) except OSError: raise log_dir=create_log_dir(args) if args.Csvm !=-1: Clist=[args.Csvm] else: Clist=list(np.logspace(-4,4,15)) if args.automatic_cv_alpha : nb=15 N=int(15/3) a=np.logspace(-6,-1,N) c=1-a b=np.array(list(set(np.linspace(a[0],c[0],N)).difference(set((a[0],c[0]))))) alphalist=np.concatenate((a,b,c)) alpha_list=list(np.sort(np.append([0,1],alphalist))) else:
def main(_): # We want to see all the logging messages for this tutorial. # 记录日志 tf.logging.set_verbosity(tf.logging.INFO) # Start a new TensorFlow session. # 启动会话 sess = tf.InteractiveSession() # 将日志写入指定文件 # get TF logger import utils utils.create_log_dir(FLAGS.train_dir, FLAGS.log_path) # Begin by making sure we have the training data we need. If you already have # training data of your own, use `--data_url= ` on the command line to avoid # downloading. # 模型设置:单词切割、采样率、时长、窗长、帧移、mfcc系数 model_settings = models.prepare_model_settings( len(input_data.prepare_words_list(FLAGS.wanted_words.split(','))), FLAGS.sample_rate, FLAGS.clip_duration_ms, FLAGS.window_size_ms, FLAGS.window_stride_ms, FLAGS.dct_coefficient_count) # 数据网址、本地文件夹、静音比重、干扰词比重、验证集占比、测试集占比 audio_processor = input_data.AudioProcessor(FLAGS.data_url, FLAGS.data_dir, FLAGS.silence_percentage, FLAGS.unknown_percentage, FLAGS.wanted_words.split(','), FLAGS.validation_percentage, FLAGS.testing_percentage, model_settings) # 数据输入格式 fingerprint_size = model_settings['fingerprint_size'] # 标签数量 label_count = model_settings['label_count'] # 采样率 time_shift_samples = int((FLAGS.time_shift_ms * FLAGS.sample_rate) / 1000) # Figure out the learning rates for each training phase. Since it's often # effective to have high learning rates at the start of training, followed by # lower levels towards the end, the number of steps and learning rates can be # specified as comma-separated lists to define the rate at each stage. For # example --how_many_training_steps=10000,3000 --learning_rate=0.001,0.0001 # will run 13,000 training loops in total, with a rate of 0.001 for the first # 10,000, and 0.0001 for the final 3,000. # 实验发现:在训练的开始,能很快到达很高的准确率,即训练速度快;但在接近最高点的时候,学习效率就会降低; # 因此为了适应前后训练的不同,需要根据时间调整前后的学习率:前面大,后面小; # 比如整个循环有13000次,前10000次使用0.001的学习率;后3000次使用0.0001的学习率 # training_steps_list=10000,10000,10000 # learning_rates_list=0.0005, 0.0001, 0.00002 training_steps_list = list( map(int, FLAGS.how_many_training_steps.split(','))) learning_rates_list = list(map(float, FLAGS.learning_rate.split(','))) if len(training_steps_list) != len(learning_rates_list): raise Exception( '--how_many_training_steps and --learning_rate must be equal length ' 'lists, but are %d and %d long instead' % (len(training_steps_list), len(learning_rates_list))) # 数据输入占位符 fingerprint_input = tf.placeholder(tf.float32, [None, fingerprint_size], name='fingerprint_input') # 创建模型 # logits:预测标签结果;dropout_prob:丢弃率 logits, dropout_prob = models.create_model(fingerprint_input, model_settings, FLAGS.model_architecture, FLAGS.model_size_info, is_training=True) # Define loss and optimizer # 输出维度占位符---真实标签 ground_truth_input = tf.placeholder(tf.float32, [None, label_count], name='groundtruth_input') # Optionally we can add runtime checks to spot when NaNs or other symptoms of # numerical errors start occurring during training. control_dependencies = [] if FLAGS.check_nans: checks = tf.add_check_numerics_ops() control_dependencies = [checks] # Create the back propagation and training evaluation machinery in the graph. # 交叉验证,即优化函数 with tf.name_scope('cross_entropy'): cross_entropy_mean = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(labels=ground_truth_input, logits=logits)) # summary概要:主要用于数据可视化,scalar将数据转化为标量 tf.summary.scalar('cross_entropy', cross_entropy_mean) # 使用BN,即批量更新 update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.name_scope('train'), tf.control_dependencies( update_ops), tf.control_dependencies(control_dependencies): # 学习率 learning_rate_input = tf.placeholder(tf.float32, [], name='learning_rate_input') # 优化函数 train_op = tf.train.AdamOptimizer(learning_rate_input) # 交叉验证函数+优化函数 进行训练 train_step = slim.learning.create_train_op(cross_entropy_mean, train_op) # train_step = tf.train.GradientDescentOptimizer( # learning_rate_input).minimize(cross_entropy_mean) # 返回概率最大的标签下标:分别为预测值-真实值 predicted_indices = tf.argmax(logits, 1) expected_indices = tf.argmax(ground_truth_input, 1) # 正确与否,0-1值矩阵 correct_prediction = tf.equal(predicted_indices, expected_indices) # 计算混淆矩阵:直接显示模型的效果,越集中于对角线,表示效果越好 # https: // www.zhihu.com / question / 36883196 confusion_matrix = tf.confusion_matrix(expected_indices, predicted_indices, num_classes=label_count) # 正确率:计算平均值,因为由0-1组成,所以平均值即正确率 evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar('accuracy', evaluation_step) # 全局步数记录 global_step = tf.train.get_or_create_global_step() # 全局步数+1 increment_global_step = tf.assign(global_step, global_step + 1) # 模型存储 saver = tf.train.Saver(tf.global_variables()) # Merge all the summaries and write them out to /Users/zoutai/ML_KWS/retrain_logs (by default) # 将所有的数据概要保存到文件 merged_summaries = tf.summary.merge_all() train_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/train', sess.graph) validation_writer = tf.summary.FileWriter(FLAGS.summaries_dir + '/validation') # 初始化全局变量 tf.global_variables_initializer().run() # Parameter counts # 记录参数量 params = tf.trainable_variables() num_params = sum(map(lambda t: np.prod(tf.shape(t.value()).eval()), params)) # print('Total number of Parameters: ', num_params) tf.logging.info('Total number of Parameters: %d ', num_params) start_step = 1 # 是否有初始模型,如果有从初始模型开始;否则,重新开始训练 if FLAGS.start_checkpoint: models.load_variables_from_checkpoint(sess, FLAGS.start_checkpoint) start_step = global_step.eval(session=sess) start_step = start_step // 2 tf.logging.info('Training from step: %d ', start_step) # Save graph.pbtxt. # 存储模型 tf.train.write_graph(sess.graph_def, FLAGS.train_dir, FLAGS.model_architecture + '.pbtxt') # Save list of words. # 记录标签 with gfile.GFile( os.path.join(FLAGS.train_dir, FLAGS.model_architecture + '_labels.txt'), 'w') as f: f.write('\n'.join(audio_processor.words_list)) # 开启训练 # Training loop. best_accuracy = 0 # 总训练步数 training_steps_max = np.sum(training_steps_list) for training_step in range(start_step, training_steps_max + 1): # Figure out what the current learning rate is. # 每一阶段的总步数 training_steps_sum = 0 # 三个阶段 for i in range(len(training_steps_list)): training_steps_sum += training_steps_list[i] if training_step <= training_steps_sum: learning_rate_value = learning_rates_list[i] break # Pull the audio samples we'll use for training. # 读取输入数据 train_fingerprints, train_ground_truth = audio_processor.get_data( FLAGS.batch_size, 0, model_settings, FLAGS.background_frequency, FLAGS.background_volume, time_shift_samples, 'training', sess) # 1.训练部分 # Run the graph with this batch of training data. # 开启训练会话 train_summary, train_accuracy, cross_entropy_value, _, _ = sess.run( [ merged_summaries, evaluation_step, cross_entropy_mean, train_step, increment_global_step ], feed_dict={ fingerprint_input: train_fingerprints, ground_truth_input: train_ground_truth, learning_rate_input: learning_rate_value, dropout_prob: 1.0 }) train_writer.add_summary(train_summary, training_step) tf.logging.info( 'Step #%d: rate %f, accuracy %.2f%%, cross entropy %f' % (training_step, learning_rate_value, train_accuracy * 100, cross_entropy_value)) # 2.验证部分 # 最后一步,训练完成 is_last_step = (training_step == training_steps_max) # 达到一定步数进行一次记录,一般为500次;或者到达最终步数记录一次 if (training_step % FLAGS.eval_step_interval) == 0 or is_last_step: # 读取验证集,进行验证 set_size = audio_processor.set_size('validation') total_accuracy = 0 total_conf_matrix = None for i in range(0, set_size, FLAGS.batch_size): validation_fingerprints, validation_ground_truth = ( audio_processor.get_data(FLAGS.batch_size, i, model_settings, 0.0, 0.0, 0, 'validation', sess)) # Run a validation step and capture training summaries for TensorBoard # with the `merged` op. validation_summary, validation_accuracy, conf_matrix = sess.run( [merged_summaries, evaluation_step, confusion_matrix], feed_dict={ fingerprint_input: validation_fingerprints, ground_truth_input: validation_ground_truth, dropout_prob: 1.0 }) validation_writer.add_summary(validation_summary, training_step) batch_size = min(FLAGS.batch_size, set_size - i) total_accuracy += (validation_accuracy * batch_size) / set_size if total_conf_matrix is None: total_conf_matrix = conf_matrix else: total_conf_matrix += conf_matrix tf.logging.info('Confusion Matrix:\n %s' % (total_conf_matrix)) tf.logging.info('Step %d: Validation accuracy = %.2f%% (N=%d)' % (training_step, total_accuracy * 100, set_size)) # Save the model checkpoint when validation accuracy improves # 存储当前模型 if total_accuracy > best_accuracy: best_accuracy = total_accuracy checkpoint_path = os.path.join( FLAGS.train_dir, 'best', FLAGS.model_architecture + '_' + str(int(best_accuracy * 10000)) + '.ckpt') tf.logging.info('Saving best model to "%s-%d"', checkpoint_path, training_step) saver.save(sess, checkpoint_path, global_step=training_step) tf.logging.info('So far the best validation accuracy is %.2f%%' % (best_accuracy * 100)) # 3.测试部分 set_size = audio_processor.set_size('testing') tf.logging.info('set_size=%d', set_size) total_accuracy = 0 total_conf_matrix = None for i in range(0, set_size, FLAGS.batch_size): test_fingerprints, test_ground_truth = audio_processor.get_data( FLAGS.batch_size, i, model_settings, 0.0, 0.0, 0, 'testing', sess) test_accuracy, conf_matrix = sess.run( [evaluation_step, confusion_matrix], feed_dict={ fingerprint_input: test_fingerprints, ground_truth_input: test_ground_truth, dropout_prob: 1.0 }) batch_size = min(FLAGS.batch_size, set_size - i) total_accuracy += (test_accuracy * batch_size) / set_size if total_conf_matrix is None: total_conf_matrix = conf_matrix else: total_conf_matrix += conf_matrix tf.logging.info('Confusion Matrix:\n %s' % (total_conf_matrix)) tf.logging.info('Final test accuracy = %.2f%% (N=%d)' % (total_accuracy * 100, set_size))
def train(config_file, counter): # I/O config = utils.import_file(config_file, 'config') splits_path = config.splits_path + '/split{}'.format(counter) trainset = utils.Dataset(splits_path + '/train_' + str(config.fold_number) + '.txt') trainset.images = utils.preprocess(trainset.images, config, True) network = Network() network.initialize(config, trainset.num_classes) # Initalization for running log_dir = utils.create_log_dir(config, config_file) summary_writer = tf.compat.v1.summary.FileWriter(log_dir, network.graph) if config.restore_model: network.restore_model(config.restore_model, config.restore_scopes) # Load gallery and probe file_list print('Loading images...') probes = [] gal = [] with open(splits_path + '/fold_' + str(config.fold_number) + '/probe_1.txt' ,'r') as f: for line in f: probes.append(line.strip()) probe_set = evaluate.ImageSet(probes, config) #probe_set.extract_features(network, len(probes)) # with open(splits_path + '/fold_'+ str(config.fold_number) + '/gal_1.txt', 'r') as f: for line in f: gal.append(line.strip()) gal_set = evaluate.ImageSet(gal, config) #gal_set.extract_features(network, len(gal)) trainset.start_batch_queue(config, True) # # Main Loop # print('\nStart Training\n# epochs: {}\nepoch_size: {}\nbatch_size: {}\n'.\ format(config.num_epochs, config.epoch_size, config.batch_size)) global_step = 0 start_time = time.time() for epoch in range(config.num_epochs): # Training for step in range(config.epoch_size): # Prepare input learning_rate = utils.get_updated_learning_rate(global_step, config) image_batch, label_batch = trainset.pop_batch_queue() wl, sm, global_step = network.train(image_batch, label_batch, learning_rate, config.keep_prob) # Display if step % config.summary_interval == 0: # visualize.scatter2D(_prelogits[:,:2], _label_batch, _pgrads[0][:,:2]) duration = time.time() - start_time start_time = time.time() utils.display_info(epoch, step, duration, wl) summary_writer.add_summary(sm, global_step=global_step) # Testing print('Testing...') probe_set.extract_features(network, len(probes)) gal_set.extract_features(network, len(gal)) rank1, rank5 = evaluate.identify(log_dir, probe_set, gal_set) print('rank-1: {:.3f}, rank-5: {:.3f}'.format(rank1[0], rank5[0])) # Output test result summary = tf.Summary() summary.value.add(tag='identification/rank1', simple_value=rank1[0]) summary.value.add(tag='identification/rank5', simple_value=rank5[0]) summary_writer.add_summary(summary, global_step) # Save the model network.save_model(log_dir, global_step) results_copy = os.path.join('log/result_{}_{}.txt'.format(config.model_version, counter)) shutil.copyfile(os.path.join(log_dir,'result.txt'), results_copy)