def evaluate(args): """OCR inference""" if args.model == "crnn_ctc": eval = ctc_eval get_feeder_data = get_ctc_feeder_data else: eval = attention_eval get_feeder_data = get_attention_feeder_data num_classes = data_reader.num_classes() data_shape = data_reader.data_shape() # define network evaluator, cost = eval(data_shape, num_classes, use_cudnn=True if args.use_gpu else False) # data reader test_reader = data_reader.test(test_images_dir=args.input_images_dir, test_list_file=args.input_images_list, model=args.model) # prepare environment place = fluid.CPUPlace() if args.use_gpu: place = fluid.CUDAPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # load init model model_dir = args.model_path if os.path.isdir(args.model_path): raise Exception("{} should not be a directory".format(args.model_path)) fluid.load(program=fluid.default_main_program(), model_path=model_dir, executor=exe, var_list=fluid.io.get_program_parameter( fluid.default_main_program())) print("Init model from: %s." % args.model_path) evaluator.reset(exe) count = 0 for data in test_reader(): count += 1 exe.run(fluid.default_main_program(), feed=get_feeder_data(data, place)) avg_distance, avg_seq_error = evaluator.eval(exe) print("Read %d samples; avg_distance: %s; avg_seq_error: %s" % (count, avg_distance, avg_seq_error))
def evaluate(args): """OCR inference""" if args.model == "crnn_ctc": eval = ctc_eval get_feeder_data = get_ctc_feeder_data else: eval = attention_eval get_feeder_data = get_attention_feeder_data num_classes = data_reader.num_classes() data_shape = data_reader.data_shape() # define network evaluator, cost = eval(data_shape, num_classes) # data reader test_reader = data_reader.test( test_images_dir=args.input_images_dir, test_list_file=args.input_images_list, model=args.model) # prepare environment place = fluid.CPUPlace() if args.use_gpu: place = fluid.CUDAPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # load init model model_dir = args.model_path model_file_name = None if not os.path.isdir(args.model_path): model_dir = os.path.dirname(args.model_path) model_file_name = os.path.basename(args.model_path) fluid.io.load_params(exe, dirname=model_dir, filename=model_file_name) print("Init model from: %s." % args.model_path) evaluator.reset(exe) count = 0 for data in test_reader(): count += 1 exe.run(fluid.default_main_program(), feed=get_feeder_data(data, place)) avg_distance, avg_seq_error = evaluator.eval(exe) print("Read %d samples; avg_distance: %s; avg_seq_error: %s" % ( count, avg_distance, avg_seq_error))
def train(args): """OCR training""" if args.model == "crnn_ctc": train_net = ctc_train_net get_feeder_data = get_ctc_feeder_data else: train_net = attention_train_net get_feeder_data = get_attention_feeder_data num_classes = None num_classes = data_reader.num_classes( ) if num_classes is None else num_classes data_shape = data_reader.data_shape() # define network sum_cost, error_evaluator, inference_program, model_average = train_net( args, data_shape, num_classes) # data reader train_reader = data_reader.train(args.batch_size, train_images_dir=args.train_images, train_list_file=args.train_list, cycle=args.total_step > 0, model=args.model) test_reader = data_reader.test(test_images_dir=args.test_images, test_list_file=args.test_list, model=args.model) # prepare environment place = fluid.CPUPlace() if args.use_gpu: place = fluid.CUDAPlace(0) exe = fluid.Executor(place) if 'ce_mode' in os.environ: fluid.default_startup_program().random_seed = 90 exe.run(fluid.default_startup_program()) # load init model if args.init_model is not None: model_dir = args.init_model fluid.load(fluid.default_main_program(), model_dir, var_list=fluid.io.get_program_parameter( fluid.default_main_program())) print("Init model from: %s." % args.init_model) train_exe = exe error_evaluator.reset(exe) if args.parallel: train_exe = fluid.ParallelExecutor( use_cuda=True if args.use_gpu else False, loss_name=sum_cost.name) fetch_vars = [sum_cost] + error_evaluator.metrics def train_one_batch(data): var_names = [var.name for var in fetch_vars] if args.parallel: results = train_exe.run(var_names, feed=get_feeder_data(data, place)) results = [np.array(result).sum() for result in results] else: results = train_exe.run(feed=get_feeder_data(data, place), fetch_list=fetch_vars) results = [result[0] for result in results] return results def test(iter_num): error_evaluator.reset(exe) for data in test_reader(): exe.run(inference_program, feed=get_feeder_data(data, place)) _, test_seq_error = error_evaluator.eval(exe) print("\n[%s] - Iter[%d]; Test seq error: %s.\n" % (time.asctime( time.localtime(time.time())), iter_num, str(test_seq_error[0]))) #Note: The following logs are special for CE monitoring. #Other situations do not need to care about these logs. if 'ce_mode' in os.environ: print("kpis test_acc %f" % (1 - test_seq_error[0])) def save_model(args, exe, iter_num): filename = "model_%05d" % iter_num fluid.save(fluid.default_main_program(), os.path.join(args.save_model_dir, filename)) print("Saved model to: %s/%s." % (args.save_model_dir, filename)) iter_num = 0 stop = False start_time = time.time() while not stop: total_loss = 0.0 total_seq_error = 0.0 batch_times = [] # train a pass for data in train_reader(): if args.total_step > 0 and iter_num == args.total_step + args.skip_batch_num: stop = True break if iter_num < args.skip_batch_num: print("Warm-up iteration") if iter_num == args.skip_batch_num: profiler.reset_profiler() start = time.time() results = train_one_batch(data) batch_time = time.time() - start fps = args.batch_size / batch_time batch_times.append(batch_time) total_loss += results[0] total_seq_error += results[2] iter_num += 1 # training log if iter_num % args.log_period == 0: print("\n[%s] - Iter[%d]; Avg loss: %.3f; Avg seq err: %.3f" % (time.asctime(time.localtime( time.time())), iter_num, total_loss / (args.log_period * args.batch_size), total_seq_error / (args.log_period * args.batch_size))) if 'ce_mode' in os.environ: print("kpis train_cost %f" % (total_loss / (args.log_period * args.batch_size))) print("kpis train_acc %f" % (1 - total_seq_error / (args.log_period * args.batch_size))) total_loss = 0.0 total_seq_error = 0.0 # evaluate if not args.skip_test and iter_num % args.eval_period == 0: if model_average: with model_average.apply(exe): test(iter_num) else: test(iter_num) # save model if iter_num % args.save_model_period == 0: if model_average: with model_average.apply(exe): save_model(args, exe, iter_num) else: save_model(args, exe, iter_num) end_time = time.time() if 'ce_mode' in os.environ: print("kpis train_duration %f" % (end_time - start_time)) # Postprocess benchmark data latencies = batch_times[args.skip_batch_num:] latency_avg = np.average(latencies) latency_pc99 = np.percentile(latencies, 99) fpses = np.divide(args.batch_size, latencies) fps_avg = np.average(fpses) fps_pc99 = np.percentile(fpses, 1) # Benchmark output print('\nTotal examples (incl. warm-up): %d' % (iter_num * args.batch_size)) print('average latency: %.5f s, 99pc latency: %.5f s' % (latency_avg, latency_pc99)) print('average fps: %.5f, fps for 99pc latency: %.5f' % (fps_avg, fps_pc99))
def inference(args): """OCR inference""" if args.model == "crnn_ctc": infer = ctc_infer get_feeder_data = get_ctc_feeder_for_infer else: infer = attention_infer get_feeder_data = get_attention_feeder_for_infer eos = 1 sos = 0 num_classes = data_reader.num_classes() data_shape = data_reader.data_shape() # define network images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32') ids = infer(images, num_classes, use_cudnn=True if args.use_gpu else False) # data reader infer_reader = data_reader.inference( batch_size=args.batch_size, infer_images_dir=args.input_images_dir, infer_list_file=args.input_images_list, cycle=True if args.iterations > 0 else False, model=args.model) # prepare environment place = fluid.CPUPlace() if args.use_gpu: place = fluid.CUDAPlace(0) exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) # load dictionary dict_map = None if args.dict is not None and os.path.isfile(args.dict): dict_map = {} with open(args.dict) as dict_file: for i, word in enumerate(dict_file): dict_map[i] = word.strip() print("Loaded dict from %s" % args.dict) # load init model model_dir = args.model_path model_file_name = None if not os.path.isdir(args.model_path): model_dir = os.path.dirname(args.model_path) model_file_name = os.path.basename(args.model_path) fluid.io.load_params(exe, dirname=model_dir, filename=model_file_name) print("Init model from: %s." % args.model_path) batch_times = [] iters = 0 for data in infer_reader(): feed_dict = get_feeder_data(data, place) if args.iterations > 0 and iters == args.iterations + args.skip_batch_num: break if iters < args.skip_batch_num: print("Warm-up itaration") if iters == args.skip_batch_num: profiler.reset_profiler() start = time.time() result = exe.run(fluid.default_main_program(), feed=feed_dict, fetch_list=[ids], return_numpy=False) indexes = prune(np.array(result[0]).flatten(), 0, 1) batch_time = time.time() - start fps = args.batch_size / batch_time batch_times.append(batch_time) if dict_map is not None: print("Iteration %d, latency: %.5f s, fps: %f, result: %s" % ( iters, batch_time, fps, [dict_map[index] for index in indexes], )) else: print("Iteration %d, latency: %.5f s, fps: %f, result: %s" % ( iters, batch_time, fps, indexes, )) iters += 1 latencies = batch_times[args.skip_batch_num:] latency_avg = np.average(latencies) latency_pc99 = np.percentile(latencies, 99) fpses = np.divide(args.batch_size, latencies) fps_avg = np.average(fpses) fps_pc99 = np.percentile(fpses, 1) # Benchmark output print('\nTotal examples (incl. warm-up): %d' % (iters * args.batch_size)) print('average latency: %.5f s, 99pc latency: %.5f s' % (latency_avg, latency_pc99)) print('average fps: %.5f, fps for 99pc latency: %.5f' % (fps_avg, fps_pc99))