| |
| import argparse |
| import os |
| import torch |
| import yaml |
| from tqdm import tqdm |
| import numpy as np |
| from trainer import Trainer |
| |
| from experiment import Structure, TrainSettings, ValidationSettings, Experiment |
| from concern.log import Logger |
| from data.data_loader import DataLoader |
| from data.image_dataset import ImageDataset |
| from training.checkpoint import Checkpoint |
| from training.learning_rate import ( |
| ConstantLearningRate, PriorityLearningRate, FileMonitorLearningRate |
| ) |
| from training.model_saver import ModelSaver |
| from training.optimizer_scheduler import OptimizerScheduler |
| from concern.config import Configurable, Config |
| import time |
|
|
| def main(): |
| parser = argparse.ArgumentParser(description='Text Recognition Training') |
| parser.add_argument('exp', type=str) |
| parser.add_argument('--batch_size', type=int, |
| help='Batch size for training') |
| parser.add_argument('--resume', type=str, help='Resume from checkpoint') |
| parser.add_argument('--result_dir', type=str, default='./results/', help='path to save results') |
| parser.add_argument('--epochs', type=int, help='Number of training epochs') |
| parser.add_argument('--start_iter', type=int, |
| help='Begin counting iterations starting from this value (should be used with resume)') |
| parser.add_argument('--start_epoch', type=int, |
| help='Begin counting epoch starting from this value (should be used with resume)') |
| parser.add_argument('--max_size', type=int, help='max length of label') |
| parser.add_argument('--data', type=str, |
| help='The name of dataloader which will be evaluated on.') |
| parser.add_argument('--thresh', type=float, |
| help='The threshold to replace it in the representers') |
| parser.add_argument('--box_thresh', type=float, default=0.6, |
| help='The threshold to replace it in the representers') |
| parser.add_argument('--verbose', action='store_true', |
| help='show verbose info') |
| parser.add_argument('--no-verbose', action='store_true', |
| help='show verbose info') |
| parser.add_argument('--visualize', action='store_true', |
| help='visualize maps in tensorboard') |
| parser.add_argument('--resize', action='store_true', |
| help='resize') |
| parser.add_argument('--polygon', action='store_true', |
| help='output polygons if true') |
| parser.add_argument('--eager', '--eager_show', action='store_true', dest='eager_show', |
| help='Show iamges eagerly') |
| parser.add_argument('--speed', action='store_true', dest='test_speed', |
| help='Test speed only') |
| parser.add_argument('--dest', type=str, |
| help='Specify which prediction will be used for decoding.') |
| parser.add_argument('--debug', action='store_true', dest='debug', |
| help='Run with debug mode, which hacks dataset num_samples to toy number') |
| parser.add_argument('--no-debug', action='store_false', |
| dest='debug', help='Run without debug mode') |
| parser.add_argument('-d', '--distributed', action='store_true', |
| dest='distributed', help='Use distributed training') |
| parser.add_argument('--local_rank', dest='local_rank', default=0, |
| type=int, help='Use distributed training') |
| parser.add_argument('-g', '--num_gpus', dest='num_gpus', default=1, |
| type=int, help='The number of accessible gpus') |
| parser.set_defaults(debug=False, verbose=False) |
|
|
| args = parser.parse_args() |
| args = vars(args) |
| args = {k: v for k, v in args.items() if v is not None} |
|
|
| conf = Config() |
| experiment_args = conf.compile(conf.load(args['exp']))['Experiment'] |
| experiment_args.update(cmd=args) |
| experiment = Configurable.construct_class_from_config(experiment_args) |
|
|
| Eval(experiment, experiment_args, cmd=args, verbose=args['verbose']).eval(args['visualize']) |
|
|
|
|
| class Eval: |
| def __init__(self, experiment, args, cmd=dict(), verbose=False): |
| self.experiment = experiment |
| experiment.load('evaluation', **args) |
| self.data_loaders = experiment.evaluation.data_loaders |
| self.args = cmd |
| self.logger = experiment.logger |
| model_saver = experiment.train.model_saver |
| self.structure = experiment.structure |
| self.model_path = cmd.get( |
| 'resume', os.path.join( |
| self.logger.save_dir(model_saver.dir_path), |
| 'final')) |
| self.verbose = verbose |
|
|
| def init_torch_tensor(self): |
| |
| torch.set_default_tensor_type('torch.FloatTensor') |
| if torch.cuda.is_available(): |
| self.device = torch.device('cuda') |
| torch.set_default_tensor_type('torch.cuda.FloatTensor') |
| else: |
| self.device = torch.device('cpu') |
|
|
| def init_model(self): |
| model = self.structure.builder.build(self.device) |
| return model |
|
|
| def resume(self, model, path): |
| if not os.path.exists(path): |
| self.logger.warning("Checkpoint not found: " + path) |
| return |
| self.logger.info("Resuming from " + path) |
| states = torch.load( |
| path, map_location=self.device) |
| model.load_state_dict(states, strict=False) |
| self.logger.info("Resumed from " + path) |
|
|
| def report_speed(self, model, batch, times=100): |
| data = {k: v[0:1]for k, v in batch.items()} |
| if torch.cuda.is_available(): |
| torch.cuda.synchronize() |
| start = time.time() |
| for _ in range(times): |
| pred = model.forward(data) |
| for _ in range(times): |
| output = self.structure.representer.represent(batch, pred, is_output_polygon=False) |
| time_cost = (time.time() - start) / times |
| self.logger.info('Params: %s, Inference speed: %fms, FPS: %f' % ( |
| str(sum(p.numel() for p in model.parameters() if p.requires_grad)), |
| time_cost * 1000, 1 / time_cost)) |
| |
| return time_cost |
| |
| def format_output(self, batch, output): |
| batch_boxes, batch_scores = output |
| for index in range(batch['image'].size(0)): |
| original_shape = batch['shape'][index] |
| filename = batch['filename'][index] |
| result_file_name = 'res_' + filename.split('/')[-1].split('.')[0] + '.txt' |
| result_file_path = os.path.join(self.args['result_dir'], result_file_name) |
| boxes = batch_boxes[index] |
| scores = batch_scores[index] |
| if self.args['polygon']: |
| with open(result_file_path, 'wt') as res: |
| for i, box in enumerate(boxes): |
| box = np.array(box).reshape(-1).tolist() |
| result = ",".join([str(int(x)) for x in box]) |
| score = scores[i] |
| res.write(result + ',' + str(score) + "\n") |
| else: |
| with open(result_file_path, 'wt') as res: |
| for i in range(boxes.shape[0]): |
| score = scores[i] |
| if score < self.args['box_thresh']: |
| continue |
| box = boxes[i,:,:].reshape(-1).tolist() |
| result = ",".join([str(int(x)) for x in box]) |
| res.write(result + ',' + str(score) + "\n") |
| |
| def eval(self, visualize=False): |
| self.init_torch_tensor() |
| model = self.init_model() |
| self.resume(model, self.model_path) |
| all_matircs = {} |
| model.eval() |
| vis_images = dict() |
| with torch.no_grad(): |
| for _, data_loader in self.data_loaders.items(): |
| raw_metrics = [] |
| for i, batch in tqdm(enumerate(data_loader), total=len(data_loader)): |
| if self.args['test_speed']: |
| time_cost = self.report_speed(model, batch, times=50) |
| continue |
| pred = model.forward(batch, training=False) |
| output = self.structure.representer.represent(batch, pred, is_output_polygon=self.args['polygon']) |
| if not os.path.isdir(self.args['result_dir']): |
| os.mkdir(self.args['result_dir']) |
| self.format_output(batch, output) |
| raw_metric = self.structure.measurer.validate_measure(batch, output, is_output_polygon=self.args['polygon'], box_thresh=self.args['box_thresh']) |
| raw_metrics.append(raw_metric) |
|
|
| if visualize and self.structure.visualizer: |
| vis_image = self.structure.visualizer.visualize(batch, output, pred) |
| self.logger.save_image_dict(vis_image) |
| vis_images.update(vis_image) |
| metrics = self.structure.measurer.gather_measure(raw_metrics, self.logger) |
| for key, metric in metrics.items(): |
| self.logger.info('%s : %f (%d)' % (key, metric.avg, metric.count)) |
|
|
| if __name__ == '__main__': |
| main() |
|
|
