def _main(args): # Parse input arguments model_path = os.path.expanduser(args.model_path) data_path = os.path.expanduser(args.data_path) anchors_path = os.path.expanduser(args.anchors_path) classes_path = os.path.expanduser(args.classes_path) output_path = os.path.expanduser(args.output_path) batch = args.batch assert model_path.endswith('.h5'), 'model_path must have .h5 extension' assert output_path.endswith('.mat'), 'output_path must have .mat extension' # Extract anchors and classes from input files anchors = utils.get_anchors(anchors_path) classes = utils.get_classes(classes_path) images, boxes = utils.get_data(data_path) # Create model and load weights from file model_body, model = create_model(images.shape[1:-1], int(boxes.shape[-1]), anchors, classes) model_body.load_weights(model_path) model.summary() # Pass input data through the network in batches output = model_body.predict(images[0:batch, :, :, :, :]) for i in range(batch, images.shape[0], batch): output = np.concatenate((output, model_body.predict(images[i:i + batch, :, :, :, :]))) # Save output file if output_path != '': os.makedirs(os.path.dirname(output_path), exist_ok=True) scipy.io.savemat(output_path, mdict={'output': output}) print('Results saved to file: {}'.format(output_path))
def load(): """ 加载模型,回传模型和模型参数 """ # 模型参数 class_names = get_classes(classes_path) num_classes = len(class_names) anchors = get_anchors(anchors_path) num_anchors = len(anchors) input_shape = (416, 416) train_weights_path = log_dir + '/ep169-loss17.356-val_loss6.844.h5' # 获取模型结构,加载权重 image_input = Input(shape=(None, None, 3)) model = yolo_body(image_input, num_anchors//3, num_classes) print('Get YOLOv3 model with {} anchors and {} classes.'.format(num_anchors, num_classes)) model.load_weights(train_weights_path, by_name=True, skip_mismatch=True) print('Load weights {}.'.format(train_weights_path)) # 回传参数 param = [class_names, num_classes, anchors, input_shape] return model, param
def _main(args): os.chdir(os.path.join(os.getcwd(), 'yad2k-em3d')) # Parse input arguments anchors_path = os.path.expanduser(args.anchors_path) classes_path = os.path.expanduser(args.classes_path) data_path = os.path.expanduser(args.data_path) test_results = os.path.expanduser(args.test_results) # Extract anchors, classes, images, and boxes from input files anchors = utils.get_anchors(anchors_path) classes = utils.get_classes(classes_path) images, boxes = utils.get_data(data_path) test_results = scipy.io.loadmat(test_results) t = test_results['output'] cv2.imshow("TESTING", images[20]) cv2.waitKey(0) ipdb.set_trace() classes = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ] class_names = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' ] drawn = utils.draw_boxes(images[0], t[:1], classes, class_names, scores=t[2]) cv2.imshow('drawm', drawn) cv2.waitKey(0)
def main(): args = make_args() config = configparser.ConfigParser() utils.load_config(config, args.config) for cmd in args.modify: utils.modify_config(config, cmd) with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f: logging.config.dictConfig(yaml.load(f)) cache_dir = utils.get_cache_dir(config) model_dir = utils.get_model_dir(config) category = utils.get_category( config, cache_dir if os.path.exists(cache_dir) else None) anchors = utils.get_anchors(config) anchors = torch.from_numpy(anchors).contiguous() path, step, epoch = utils.train.load_model(model_dir) state_dict = torch.load(path, map_location=lambda storage, loc: storage) dnn = utils.parse_attr(config.get('model', 'dnn'))(model.ConfigChannels( config, state_dict), anchors, len(category)) dnn.load_state_dict(state_dict) height, width = tuple(map(int, config.get('image', 'size').split())) resize = transform.parse_transform(config, config.get('transform', 'resize_test')) transform_image = transform.get_transform( config, config.get('transform', 'image_test').split()) transform_tensor = transform.get_transform( config, config.get('transform', 'tensor').split()) # load image image_bgr = cv2.imread('image.jpg') image_resized = resize(image_bgr, height, width) image = transform_image(image_resized) tensor = transform_tensor(image).unsqueeze(0) # Checksum for key, var in dnn.state_dict().items(): a = var.cpu().numpy() print('\t'.join( map(str, [ key, a.shape, utils.abs_mean(a), hashlib.md5(a.tostring()).hexdigest() ]))) output = dnn(torch.autograd.Variable(tensor, volatile=True)).data for key, a in [ ('image_bgr', image_bgr), ('image_resized', image_resized), ('tensor', tensor.cpu().numpy()), ('output', output.cpu().numpy()), ]: print('\t'.join( map(str, [ key, a.shape, utils.abs_mean(a), hashlib.md5(a.tostring()).hexdigest() ])))
def generate_ngram_candidates(document, ontology): """ Generate keyword candidates by building an ontology trie and performing a fuzzy match over it with ngrams extracted from the text. :param document - Document object :param ontology - Ontology object :return set of KeywordTokens """ all_words = document.get_meaningful_words() tokens = set() # 1-grams anchors = get_anchors(all_words, ontology) tokens |= set(anchors) # 2-grams n = 2 ngram_tokens = dict() for position, ngram in get_ngrams_around_anchors(n, all_words, anchors): # TODO potential filtering of ngrams e.g. for linguistic purposes form = " ".join(ngram) for hit in ontology.fuzzy_match(form): uri = ontology.get_uri_from_label(hit) add_token(uri, ngram_tokens, position, ontology, form=form) tokens |= set(ngram_tokens.values()) # 3-grams n = 3 ngram_tokens = dict() for position, ngram in get_ngrams_around_anchors(n, all_words, anchors): # TODO potential filtering of ngrams e.g. for linguistic purposes form = " ".join(ngram) for hit in ontology.fuzzy_match(form): uri = ontology.get_uri_from_label(hit) add_token(uri, ngram_tokens, position, ontology, form=form) tokens |= set(ngram_tokens.values()) # 4-grams # n = 4 # ngram_tokens = dict() # for position, ngram in get_ngrams_around_anchors(n, all_words, anchors): # # TODO potential filtering of ngrams e.g. for linguistic purposes # form = " ".join(ngram) # for hit in ontology.fuzzy_match(form): # uri = ontology.get_uri_from_label(hit) # add_token(uri, ngram_tokens, position, ontology, form=form) # tokens |= set(ngram_tokens.values()) tokens = remove_not_considered_keywords(tokens) return remove_nostandalone_candidates(tokens, ontology)
def generate_ngram_candidates(document, ontology): """ Generate keyword candidates by building an ontology trie and performing a fuzzy match over it with ngrams extracted from the text. :param document - Document object :param ontology - Ontology object :return set of KeywordTokens """ all_words = document.get_meaningful_words() tokens = set() # 1-grams anchors = get_anchors(all_words, ontology) tokens |= set(anchors) # 2-grams n = 2 ngram_tokens = dict() for position, ngram in get_ngrams_around_anchors(n, all_words, anchors): # TODO potential filtering of ngrams e.g. for linguistic purposes form = " ".join(ngram) for hit in ontology.fuzzy_match(form): uri = ontology.get_uri_from_label(hit) add_token(uri, ngram_tokens, position, ontology, form=form) tokens |= set(ngram_tokens.values()) # 3-grams n = 3 ngram_tokens = dict() for position, ngram in get_ngrams_around_anchors(n, all_words, anchors): # TODO potential filtering of ngrams e.g. for linguistic purposes form = " ".join(ngram) for hit in ontology.fuzzy_match(form): uri = ontology.get_uri_from_label(hit) add_token(uri, ngram_tokens, position, ontology, form=form) tokens |= set(ngram_tokens.values()) # 4-grams # n = 4 # ngram_tokens = dict() # for position, ngram in get_ngrams_around_anchors(n, all_words, anchors): # # TODO potential filtering of ngrams e.g. for linguistic purposes # form = " ".join(ngram) # for hit in ontology.fuzzy_match(form): # uri = ontology.get_uri_from_label(hit) # add_token(uri, ngram_tokens, position, ontology, form=form) # tokens |= set(ngram_tokens.values()) tokens = remove_not_considered_keywords(tokens) return remove_nostandalone_candidates(tokens, ontology)
def main(): args = make_args() config = configparser.ConfigParser() utils.load_config(config, args.config) for cmd in args.modify: utils.modify_config(config, cmd) with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f: logging.config.dictConfig(yaml.load(f)) model_dir = utils.get_model_dir(config) category = utils.get_category(config) anchors = torch.from_numpy(utils.get_anchors(config)).contiguous() path, step, epoch = utils.train.load_model(model_dir) state_dict = torch.load(path, map_location=lambda storage, loc: storage) _model = utils.parse_attr(config.get('model', 'dnn')) dnn = _model(model.ConfigChannels(config, state_dict), anchors, len(category)) logging.info( humanize.naturalsize( sum(var.cpu().numpy().nbytes for var in dnn.state_dict().values()))) dnn.load_state_dict(state_dict) height, width = tuple(map(int, config.get('image', 'size').split())) image = torch.autograd.Variable( torch.randn(args.batch_size, 3, height, width)) output = dnn(image) state_dict = dnn.state_dict() d = utils.dense(state_dict[args.name]) keep = torch.LongTensor(np.argsort(d)[:int(len(d) * args.keep)]) modifier = utils.channel.Modifier( args.name, state_dict, dnn, lambda name, var: var[keep], lambda name, var, mapper: var[mapper(keep, len(d))], debug=args.debug, ) modifier(output.grad_fn) if args.debug: path = modifier.dot.view( '%s.%s.gv' % (os.path.basename(model_dir), os.path.basename(os.path.splitext(__file__)[0])), os.path.dirname(model_dir)) logging.info(path) assert len(keep) == len(state_dict[args.name]) dnn = _model(model.ConfigChannels(config, state_dict), anchors, len(category)) dnn.load_state_dict(state_dict) dnn(image) if not args.debug: torch.save(state_dict, path)
def _main(args): # Parse input arguments anchors_path = os.path.expanduser(args.anchors_path) classes_path = os.path.expanduser(args.classes_path) data_path = os.path.expanduser(args.data_path) output_path = os.path.expanduser(args.output_path) # Extract anchors, classes, images, and boxes from input files anchors = utils.get_anchors(anchors_path) classes = utils.get_classes(classes_path) images, boxes = utils.get_data(data_path) # Train YOLO model model_body, model = create_model(images.shape[1:-1], int(boxes.shape[-1]), anchors, classes) model.summary() train(model, classes, anchors, images, boxes, output_path=output_path)
def _main(args): # Parse input arguments anchors_path = os.path.expanduser(args.anchors_path) classes_path = os.path.expanduser(args.classes_path) data_path = os.path.expanduser(args.data_path) output_path = os.path.expanduser(args.output_path) # Extract anchors, classes, images, and boxes from input files anchors = utils.get_anchors(anchors_path) classes = utils.get_classes(classes_path) images, boxes = utils.get_data(data_path) # if you need to ensure the data being fed to the algorithm is correct, uncomment utils.check_data(images, boxes) # Train YOLO model model_body, model = create_model(images.shape[1:-1], int(boxes.shape[-1]), anchors, classes) model.summary() train(model, classes, anchors, images, boxes, output_path=output_path)
def get_yolov4(image): # inintial config ANCHORS = utils.get_anchors('./data/yolov4_anchors.txt', False) NUM_CLASS = len(utils.read_class_names('data/coco.names')) XYSCALE = [1.2, 1.1, 1.05] STRIDES = np.array([8, 16, 32]) input_size = 608 original_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) original_image_size = original_image.shape[:2] image_data = image_preporcess(np.copy(original_image), [input_size, input_size]) image_data = image_data[np.newaxis, ...].astype(np.float32) # send grpc request request.inputs['input_1'].CopyFrom( tf.make_tensor_proto(image_data, dtype=types_pb2.DT_FLOAT)) result_final = [] result_future = stub.Predict(request, 10) result_1 = result_future.outputs['tf_op_layer_concat_10'] result_final.append(np.reshape(np.array(result_1.ListFields()[2][1]), \ (1, 76, 76, 3, 6) )) result_2 = result_future.outputs['tf_op_layer_concat_11'] result_final.append(np.reshape(np.array(result_2.ListFields()[2][1]), \ (1, 38, 38, 3, 6) )) result_3 = result_future.outputs['tf_op_layer_concat_12'] result_final.append(np.reshape(np.array(result_3.ListFields()[2][1]), \ (1, 19, 19, 3, 6) )) pred_bbox = utils.postprocess_bbbox(result_final, ANCHORS, STRIDES, XYSCALE) bboxes = utils.postprocess_boxes(pred_bbox, original_image_size, input_size, 0.45) bboxes = utils.nms(bboxes, 0.213, method='nms') #image = utils.draw_bbox(original_image, bboxes) #image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2RGB) #cv2.imwrite('result.jpg', image) return bboxes
def __init__(self,dataset_type): self.annot_path = cfg['train_annot_path'] if dataset_type == 'train' else cfg['test_annot_path'] self.input_size = cfg['train_input_size'] if dataset_type == 'train' else cfg['test_input_size'] self.batch_size = cfg['train_batch_size'] if dataset_type == 'train' else cfg['test_batch_size'] self.data_aug = cfg['train_data_augement'] if dataset_type == 'train' else cfg['test_data_augement'] self.train_input_sizes = cfg['train_input_size'] self.train_input_size = random.choice(self.train_input_sizes) self.strides = np.array(cfg['yolo_strides']) self.classes = utils.read_class_names(cfg['yolo_classes_names']) self.num_classes = len(self.classes) self.anchors = np.array(utils.get_anchors(cfg['yolo_anchors'])) self.anchor_per_scale = cfg['yolo_anchor_per_scale'] self.max_bbox_per_scale = 150 self.annotations = self.load_annotation(dataset_type) self.num_samples = len(self.annotations) self.num_batchs = int(np.ceil(self.num_samples / self.batch_size)) self.batch_count = 0
def __init__(self, opt, datatype="train"): self.label_path = utils.read_label_path(opt.data, datatype) self.image_path = utils.read_image_path(opt.data, datatype) self.classes = utils.read_class_names(opt.data) self.input_size = opt.img_size self.strides = np.array([8, 16, 32]) self.output_sizes = self.input_size // self.strides self.batch_size = opt.batch_size self.num_classes = len(self.classes) self.max_bbox_per_scale = 150 # 读取anchors self.anchors = np.array(utils.get_anchors(opt.data)) self.anchor_per_scale = 3 self.num_samples = len(self.label_path) # np.ceil起到向上取整的作用 self.num_batchs = int(np.ceil(self.num_samples / self.batch_size)) self.batch_count = 0
def __init__(self, dataset_type): self.annot_path = cfg.TRAIN.ANNOT_PATH if dataset_type == 'train' else cfg.TRAIN.ANNOT_PATH self.input_sizes = cfg.TRAIN.INPUT_SIZE if dataset_type == 'train' else cfg.TEST.INPUT_SIZE self.batch_size = cfg.TRAIN.BATCH_SIZE if dataset_type == 'train' else cfg.TEST.BATCH_SIZE self.data_aug = cfg.TRAIN.DATA_AUG if dataset_type == 'train' else cfg.TEST.DATA_AUG self.train_input_sizes = cfg.TRAIN.INPUT_SIZE self.strides = np.array(cfg.YOLO.STRIDES) self.classes = utils.read_class_names(cfg.YOLO.CLASSES) self.num_classes = len(self.classes) self.anchors = np.array(utils.get_anchors()) self.anchor_per_scale = cfg.YOLO.ANCHOR_PER_SCALE self.max_bbox_per_scale = 150 self.img_id_list = self.load_car_person_list('train') if dataset_type == 'train' \ else self.load_car_person_list('test') # print("self.img_id_list: ", self.img_id_list) self.train_input_size = 416 self.annotations = self.load_annotations() self.num_samples = len(self.img_id_list) self.num_batchs = int(np.ceil(self.num_samples / self.batch_size)) self.batch_count = 0
def __init__(self, split='train'): self.config = load_config() self.data_path = '/home/aaron/tree_pcl_data/cropped' all_files = os.listdir(self.data_path) cutoff = int(len(all_files) * 0.8) if split == 'train': self.file_list = all_files[:cutoff] elif split == 'test': self.file_list = all_files[cutoff:] else: raise ValueError('split must be in [train, test]') # Calculate the size of the voxel grid in every dimensions self.voxel_W, self.voxel_H, self.voxel_D = get_num_voxels() self.anchors = get_anchors().reshape(-1, 7) # Because of the network architecure (deconvs), output feature map # shape is half that of the input self.feature_map_shape = (self.voxel_H // 2, self.voxel_W // 2)
def __init__(self, split='train'): self.config = load_config() self.data_path = os.path.join(kitti_data_dir, '%sing' % split) self.lidar_path = os.path.join(self.data_path, 'cropped/') self.image_path = os.path.join(self.data_path, 'image_2/') self.calib_path = os.path.join(self.data_path, 'calib/') self.label_path = os.path.join(self.data_path, 'label_2/') # Open the split file, containing numbers of the examples in this split # with open(os.path.join(self.data_path, '%s.txt' % split)) as f: with open(os.path.join(self.data_path, 'test_net.txt')) as f: self.file_list = f.read().splitlines() # Calculate the size of the voxel grid in every dimensions self.voxel_W, self.voxel_H, self.voxel_D = get_num_voxels() self.anchors = get_anchors().reshape(-1, 7) # Because of the network architecure (deconvs), output feature map # shape is half that of the input self.feature_map_shape = (self.voxel_H // 2, self.voxel_W // 2)
def main(): args = make_args() config = configparser.ConfigParser() utils.load_config(config, args.config) for cmd in args.modify: utils.modify_config(config, cmd) with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f: logging.config.dictConfig(yaml.load(f)) model_dir = utils.get_model_dir(config) category = utils.get_category(config) anchors = torch.from_numpy(utils.get_anchors(config)).contiguous() try: path, step, epoch = utils.train.load_model(model_dir) state_dict = torch.load(path, map_location=lambda storage, loc: storage) except (FileNotFoundError, ValueError): logging.warning('model cannot be loaded') state_dict = None dnn = utils.parse_attr(config.get('model', 'dnn'))(model.ConfigChannels( config, state_dict), anchors, len(category)) logging.info( humanize.naturalsize( sum(var.cpu().numpy().nbytes for var in dnn.state_dict().values()))) if state_dict is not None: dnn.load_state_dict(state_dict) height, width = tuple(map(int, config.get('image', 'size').split())) image = torch.autograd.Variable( torch.randn(args.batch_size, 3, height, width)) output = dnn(image) state_dict = dnn.state_dict() graph = utils.visualize.Graph(config, state_dict) graph(output.grad_fn) diff = [key for key in state_dict if key not in graph.drawn] if diff: logging.warning('variables not shown: ' + str(diff)) path = graph.dot.view( os.path.basename(model_dir) + '.gv', os.path.dirname(model_dir)) logging.info(path)
def _main(args): # Parse input arguments model_path = os.path.expanduser(args.model_path) data_path = os.path.expanduser(args.data_path) anchors_path = os.path.expanduser(args.anchors_path) classes_path = os.path.expanduser(args.classes_path) output_path = os.path.expanduser(args.output_path) batch = args.batch assert model_path.endswith('.h5'), 'model_path must have .h5 extension' assert output_path.endswith('.mat'), 'output_path must have .mat extension' # Extract anchors and classes from input files anchors = utils.get_anchors(anchors_path) classes = utils.get_classes(classes_path) images, boxes = utils.get_data(data_path) # Create model and load weights from file model_body, model = create_model(images.shape[1:-1], int(boxes.shape[-1]), anchors, classes) model_body.load_weights(model_path) model.summary()
def main(): args = make_args() config = configparser.ConfigParser() utils.load_config(config, args.config) for cmd in args.modify: utils.modify_config(config, cmd) with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f: logging.config.dictConfig(yaml.load(f)) model_dir = utils.get_model_dir(config) category = utils.get_category(config) anchors = torch.from_numpy(utils.get_anchors(config)).contiguous() path, step, epoch = utils.train.load_model(model_dir) state_dict = torch.load(path, map_location=lambda storage, loc: storage) dnn = utils.parse_attr(config.get('model', 'dnn'))(model.ConfigChannels( config, state_dict), anchors, len(category)) logging.info( humanize.naturalsize( sum(var.cpu().numpy().nbytes for var in dnn.state_dict().values()))) dnn.load_state_dict(state_dict) height, width = tuple(map(int, config.get('image', 'size').split())) image = torch.autograd.Variable( torch.randn(args.batch_size, 3, height, width)) output = dnn(image) state_dict = dnn.state_dict() closure = utils.walk.Closure(args.name, state_dict, type(dnn).scope, args.debug) closure(output.grad_fn) d = utils.dense(state_dict[args.name]) channels = torch.LongTensor(np.argsort(d)[int(len(d) * args.remove):]) utils.walk.prune(closure, channels) if args.debug: path = closure.dot.view( os.path.basename(model_dir) + '.gv', os.path.dirname(model_dir)) logging.info(path) else: torch.save(state_dict, path)
def main(argv): parser = argparse.ArgumentParser() parser.add_argument("--epochs", type=int, default=10000, help="number of epochs") parser.add_argument("--batch_size", type=int, default=20, help="size of each image batch") parser.add_argument("--data_config", type=str, default="config/adc.data", help="path to data config file") # parser.add_argument("--pretrained_weights", type=str, default="config/yolov3_ckpt_5.pth") # models/model1/yolov3_ckpt_73.pth parser.add_argument("--pretrained_weights", type=str) # models/model1/yolov3_ckpt_73.pth parser.add_argument( "--n_cpu", type=int, default=0, help="number of cpu threads to use during batch generation") parser.add_argument("--img_size", type=int, default=[768, 1024], help="size of each image dimension") parser.add_argument("--evaluation_interval", type=int, default=1, help="interval evaluations on validation set") parser.add_argument("--multiscale", default='False', choices=['True', 'False']) parser.add_argument("--augment", default='False', choices=['True', 'False']) parser.add_argument("--save_path", type=str, default='models/weights_1350_0102', help="save model path") parser.add_argument("--debug", type=str, default='False', choices=['True', 'False'], help="debug") parser.add_argument("--lr", type=float, default=0.01, help="learning rate") args = parser.parse_args(argv) args.debug = True if args.debug == 'True' else False args.multiscale = True if args.multiscale == 'True' else False args.augment = True if args.augment == 'True' else False print_args(args) print( datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')) if args.debug: print('debug...') import shutil # if os.path.exists(args.save_path): # shutil.rmtree(args.save_path) args.evaluation_interval = 1 # debug模式下先删除save_path,并每间隔一轮验证一次 # assert not os.path.exists(args.save_path) # os.makedirs(args.save_path) # adc.dat下有train和valid两个dat还有anchor.txt的路径 data_config = parse_data_config(args.data_config) train_path = data_config["train"] valid_path = data_config["valid"] if args.debug: valid_path = train_path anchors = get_anchors(data_config['anchors']).to('cuda') model = ResNet(anchors).to('cuda') if args.pretrained_weights: print('pretrained weights: ', args.pretrained_weights) model.load_pretrained_weights(args.pretrained_weights) dataset = ListDataset(train_path, img_size=args.img_size, augment=args.augment, multiscale=args.multiscale) eval = evaluate(path=valid_path, img_size=args.img_size, batch_size=args.batch_size, debug=args.debug) if args.debug: dataset.img_files = dataset.img_files[:10 * args.batch_size] dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.n_cpu, collate_fn=dataset.collate_fn, ) print('Number train sample: ', len(dataset)) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=5e-5) # 这里优化器和学习率是不是要调节? print('\n### train ...') for epoch in range(args.epochs): model.train() lr = max(1e-10, args.lr * (0.95**epoch)) for param_group in optimizer.param_groups: param_group['lr'] = lr for batch_i, (imgs, targets, _) in enumerate(dataloader): imgs = Variable(imgs.to('cuda')) # 训练集有经过augment_sequential,而验证集没有 # targets=([[0.0000, 0.7328, 0.2808, 0.0934, 0.0808], # [1.0000, 0.5255, 0.5466, 0.0596, 0.1587], # [1.0000, 0.5585, 0.8077, 0.0553, 0.2250], # [3.0000, 0.4519, 0.4351, 0.1365, 0.2048]], device='cuda:0') targets = Variable(targets.to('cuda'), requires_grad=False) yolo_map, _ = model(imgs) # yolo_map.shape : [4,] 其中每个yolo_map的格式如下: batch,featuremap_h,featuremap_w,anchor_num,(x,y,w,h,conf) loss, metrics = model.loss(yolo_map, targets) loss.backward() optimizer.step() optimizer.zero_grad() if (batch_i + 1) % 100 == 0 or (batch_i + 1) == len(dataloader): time_str = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S') lr = optimizer.param_groups[0]['lr'] loss = metrics["loss"] xy = metrics["xy"] wh = metrics["wh"] conf = metrics["conf"] loss_str = 'loss: {:<8.2f}'.format(loss) loss_str += 'xy: {:<8.2f}'.format(xy) loss_str += 'wh: {:<8.2f}'.format(wh) loss_str += 'conf: {:<8.2f}'.format(conf) epoch_str = 'Epoch: {:4}({:4}/{:4})'.format( epoch, batch_i + 1, len(dataloader)) print('[{}]{} {} lr:{}'.format(time_str, epoch_str, loss_str, lr)) print() if epoch % args.evaluation_interval == 0: print("\n---- Evaluating Model ----") save_model_epoch = 'yolov3_ckpt_{}.pth'.format(epoch) model.save_weights(os.path.join(args.save_path, save_model_epoch)) print(save_model_epoch) example_save_path = args.save_path for conf in [0.1, 0.3, 0.5, 0.7]: metrics = eval(model, iou_thres=0.5, conf_thres=conf, nms_thres=0.5, save_path=example_save_path) example_save_path = None print( 'image_acc: {}\t{}\tbbox_acc: {}\tbbox_recall: {}'.format( *metrics[1:])) names = ['image', 'ture', 'det', 'box_acc', 'image_acc'] print('{:<10}{:<10}{:<10}{:<10}{:<10}'.format(*names)) print('{:<10}{:<10}{:<10}{:<10}{:<10}'.format(*metrics[0][0])) print('{:<10}{:<10}{:<10}{:<10}{:<10}'.format(*metrics[0][1])) print()
def train_yolo_v3(): if hyper_parameters.FLAGS.load_model is not None: checkpoints_dir = "checkpoints/" + hyper_parameters.FLAGS.load_model.lstrip( "checkpoints/") else: current_time = datetime.now().strftime("%Y%m%d-%H%M") checkpoints_dir = "checkpoints/{}".format(current_time) try: os.makedirs(checkpoints_dir) except os.error: pass labels = json_convert.load_label(hyper_parameters.FLAGS.labels_file) anchors = utils.get_anchors(hyper_parameters.FLAGS.anchors_path) anchors = np.array(anchors, dtype=np.float32) tf.reset_default_graph() graph = tf.Graph() with graph.as_default(): yolo_v3 = DETECTERSUBNET( 'yolo_v3', image_size=hyper_parameters.FLAGS.image_size, anchors=anchors, batch_size=hyper_parameters.FLAGS.batch_size, num_anchors=hyper_parameters.FLAGS.num_anchors, learning_rate=hyper_parameters.FLAGS.learning_rate, num_classes=hyper_parameters.FLAGS.num_classes, num_id1=hyper_parameters.FLAGS.num_id1, num_id2=hyper_parameters.FLAGS.num_id2, num_id3=hyper_parameters.FLAGS.num_id3, num_id4=hyper_parameters.FLAGS.num_id4, num_id5=hyper_parameters.FLAGS.num_id5, norm=hyper_parameters.FLAGS.norm, threshold=hyper_parameters.FLAGS.threshold, max_num_boxes_per_image=hyper_parameters.FLAGS. max_num_boxes_per_image) reader = Reader(hyper_parameters.FLAGS.X, batch_size=hyper_parameters.FLAGS.batch_size, image_size=hyper_parameters.FLAGS.image_size) x, image_ids, image_heights, image_widths = reader.feed() loss = yolo_v3.model(x) last_layer_optimizer, yolo_optimizer = yolo_v3.yolo_v3_optimizer(loss) saver = tf.train.Saver() config = tf.ConfigProto(log_device_placement=True, allow_soft_placement=True) config.gpu_options.allow_growth = True if train_mode is True: with graph.as_default(): summary_op = tf.summary.merge_all() train_writer = tf.summary.FileWriter(checkpoints_dir, graph) with tf.Session(graph=graph, config=config) as sess: if hyper_parameters.FLAGS.load_model is not None: checkpoint = tf.train.get_checkpoint_state(checkpoints_dir) meta_graph_path = checkpoint.model_checkpoint_path + ".meta" restore = tf.train.import_meta_graph(meta_graph_path) restore.restore( sess, tf.train.latest_checkpoint(checkpoints_dir)) step = int(meta_graph_path.split("-")[2].split(".")[0]) else: sess.run(tf.global_variables_initializer()) step = 0 coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) try: while not coord.should_stop() and step < 400000: img_ids, img_heights, img_widths = sess.run( [image_ids, image_heights, image_widths]) heatmaps = labels_generator.get_detector_heatmap( img_ids, img_heights, img_widths, labels) optimizer = yolo_optimizer # if step < 100000 // 3: # optimizer = last_layer_optimizer _, loss_val, summary = sess.run( [optimizer, loss, summary_op], feed_dict={ yolo_v3.Y_true_data: heatmaps[0], yolo_v3.Y_true_boxes: heatmaps[1] }) train_writer.add_summary(summary, step) train_writer.flush() if (step + 1) % 100 == 0: logging.info('-----------Step %d:-------------' % (step + 1)) logging.info(' loss : {}'.format(loss_val)) if step % 10000 == 0: save_path = saver.save(sess, checkpoints_dir + "/model.ckpt", global_step=step) logging.info("Model saved in file: %s" % save_path) step += 1 except KeyboardInterrupt: logging.info('Interrupted') coord.request_stop() except Exception as e: coord.request_stop(e) finally: save_path = saver.save(sess, checkpoints_dir + "/model.ckpt", global_step=step) logging.info("Model saved in file: %s" % save_path) # When done, ask the threads to stop. coord.request_stop() coord.join(threads)
@author: Melon """ import tensorflow as tf import os import yolov3_tiny, utils if __name__ == '__main__': os.environ['CUDA_VISIBLE_DEVICES'] = '2' sess = tf.Session() image_h, image_w = 480, 640 CLASSES = ['rubbish'] anchors = utils.get_anchors('./anchors.txt', image_h, image_w) num_classes = len(CLASSES) ckpt_file = './checkpoint/yolov3_mix_v2_tiny_low_q/Rubbish.ckpt-20000' model = yolov3_tiny.yolov3_tiny(num_classes, anchors) with tf.Graph().as_default() as graph: sess = tf.Session(graph=graph) inputs = tf.placeholder( tf.float32, [1, image_h, image_w, 3]) # placeholder for detector inputs print("=>", inputs) with tf.variable_scope('yolov3-tiny'): feature_map = model.forward(inputs, is_training=False)
def _main(): # 显存分配 gpus = tf.config.experimental.list_physical_devices(device_type='GPU') for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) # 模型参数 class_names = get_classes(classes_path) num_classes = len(class_names) anchors = get_anchors(anchors_path) input_shape = (416, 416) # 创建模型 model = create_model(num_classes, weight_path, anchors, input_shape) # Callback logging = TensorBoard(log_dir=log_dir) checkpoint = ModelCheckpoint( log_dir + '/' + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5', monitor='val_loss', save_weights_only=True, save_best_only=True, period=3) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1) # 打乱/分割训练集 val_split = 0.1 with open(train_path) as f: lines = f.readlines() np.random.seed(10101) np.random.shuffle(lines) np.random.seed(None) num_val = int(len(lines) * val_split) num_train = len(lines) - num_val # Train with frozen layers first, to get a stable loss. # Adjust num epochs to your dataset. This step is enough to obtain a not bad model. if not True: model.compile( optimizer=Adam(lr=1e-3), loss={ # use custom yolo_loss Lambda layer. 'yolo_loss': lambda y_true, y_pred: y_pred }) batch_size = 64 print('Train on {} samples, val on {} samples, with batch size {}.'. format(num_train, num_val, batch_size)) model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes), steps_per_epoch=max(1, num_train // batch_size), validation_data=data_generator_wrapper( lines[num_train:], batch_size, input_shape, anchors, num_classes), validation_steps=max(1, num_val // batch_size), epochs=100, initial_epoch=0, callbacks=[logging, checkpoint]) model.save_weights(log_dir + '/trained_weights_stage_1.h5') print("Save path: ", log_dir, '/trained_weights_stage_1.h5') else: new_weight = log_dir + '/ep071-loss19.917-val_loss10.860.h5' assert new_weight.endswith( '.h5'), 'Keras model or weights must be a .h5 file.' model.load_weights(new_weight) # Unfreeze and continue training, to fine-tune. # Train longer if the result is not good. if True: for i in range(len(model.layers)): model.layers[i].trainable = True model.compile(optimizer=Adam(lr=1e-4), loss={ 'yolo_loss': lambda y_true, y_pred: y_pred }) # recompile to apply the change print('Unfreeze all of the layers.') batch_size = 4 # note that more GPU memory is required after unfreezing the body print('Train on {} samples, val on {} samples, with batch size {}.'. format(num_train, num_val, batch_size)) model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes), steps_per_epoch=max(1, num_train // batch_size), validation_data=data_generator_wrapper( lines[num_train:], batch_size, input_shape, anchors, num_classes), validation_steps=max(1, num_val // batch_size), epochs=200, initial_epoch=100, callbacks=[logging, checkpoint]) # callbacks=[logging, checkpoint, reduce_lr, early_stopping]) model.save_weights(log_dir + '/trained_weights_final.h5') print("Save path: ", log_dir, '/trained_weights_final.h5')
def __init__(self, inputs, training, data_format=None): """Creates the model. Args: n_classes: Number of class labels. model_size: The input size of the model. max_output_size: Max number of boxes to be selected for each class. iou_threshold: Threshold for the IOU. confidence_threshold: Threshold for the confidence score. data_format: The input format. Returns: None. """ self.iou_loss_thresh = 0.5 self.num_class = 2 self.anchor_per_scale = 3 self.classes = utils.read_class_names(cfg.YOLO.CLASSES) self.n_classes = len(self.classes) self.model_size = cfg.YOLO.MODEL_SIZE self.max_output_size = cfg.YOLO.MAX_OUTPUT_SIZE self.iou_threshold = cfg.YOLO.IOU_THRESHOLD self.data_format = data_format self.strides = np.array(cfg.YOLO.STRIDES) self._giou_loss_backup = None if self.data_format == 'channels_first': inputs = tf.transpose(inputs, [0, 3, 1, 2]) with tf.variable_scope('yolo_v3_model'): self.anchors = utils.get_anchors() route1, route2, inputs = darknet53(inputs=inputs, training=training, data_format=self.data_format) route, inputs = yolo_conv_block(inputs=inputs, filters=512, training=training, data_format=self.data_format, name='yolo_conv_block_1') self.conv_lbbox = yolo_detection_layer(inputs, n_classes=self.n_classes, anchors=self.anchors[2], img_size=self.model_size, data_format=self.data_format, name='con_lbbox_layer', strides=self.strides[2]) inputs = con2d_fixed_padding(route, filters=256, kernel_size=1, data_format=self.data_format, name='conv_lbbox') inputs = batch_norm(inputs, training=training, data_format=self.data_format) inputs = tf.nn.leaky_relu(inputs, alpha=cfg.YOLO.LEAKY_RELU) upsample_output_size = route2.get_shape().as_list() inputs = upsample(inputs, out_shape=upsample_output_size, data_format=self.data_format) # get the channel axis axis = 1 if self.data_format == 'channels_first' else 3 inputs = tf.concat((inputs, route2), axis=axis) route, inputs = yolo_conv_block(inputs, filters=256, training=training, data_format=self.data_format, name='yolo_conv_block_2') self.conv_mbbox = yolo_detection_layer(inputs, n_classes=self.n_classes, anchors=self.anchors[1], img_size=self.model_size, data_format=self.data_format, name='con_mbbox_layer', strides=self.strides[1]) inputs = con2d_fixed_padding(route, filters=128, kernel_size=1, data_format=self.data_format, name='conv_mbbox') inputs = batch_norm(inputs, training=training, data_format=self.data_format) inputs = tf.nn.leaky_relu(inputs, alpha=cfg.YOLO.LEAKY_RELU) upsample_output_size = route1.get_shape().as_list() inputs = upsample(inputs, out_shape=upsample_output_size, data_format=self.data_format) inputs = tf.concat((inputs, route1), axis=axis) route, inputs = yolo_conv_block(inputs, filters=128, training=training, data_format=self.data_format, name='yolo_conv_block_3') self.conv_sbbox = yolo_detection_layer(inputs, n_classes=self.n_classes, anchors=self.anchors[0], img_size=self.model_size, data_format=self.data_format, name='conv_sbbox', strides=self.strides[0]) with tf.variable_scope('pred_sbbox'): self.pred_sbbox = self.decode(self.conv_sbbox, self.anchors[0], self.strides[0]) print("self.pred_sbbox: ", self.pred_sbbox.shape) with tf.variable_scope('pred_mbbox'): self.pred_mbbox = self.decode(self.conv_mbbox, self.anchors[1], self.strides[1]) with tf.variable_scope('pred_lbbox'): self.pred_lbbox = self.decode(self.conv_lbbox, self.anchors[2], self.strides[2])
import cv2 import glob import numpy as np import os import os.path as osp from utils import get_anchors, get_classes, preprocess_image from model import yolo_body input_shape = (416, 416) anchors = get_anchors('voc_anchors_416.txt') classes = get_classes('voc_classes.txt') num_classes = len(classes) model, prediction_model = yolo_body(anchors=anchors, score_threshold=0.1) model.load_weights('checkpoints/pascal_21_9.4463_12.8289_0.8334_0.8535.h5', by_name=True) batch_size = 1 image_paths = glob.glob('datasets/VOC2007/JPEGImages/*.jpg') num_images = len(image_paths) colors = [np.random.randint(0, 256, 3).tolist() for i in range(num_classes)] def show_image(image, name, contours=None): image = image.astype(np.uint8) cv2.namedWindow(name, cv2.WINDOW_NORMAL) if contours is not None: if isinstance(contours, list): cv2.drawContours(image, contours, -1, (0, 0, 255), 2) else: cv2.drawContours(image, [contours], -1, (0, 0, 255), 2) cv2.imshow(name, image)
import dataLoader import os from keras.utils import plot_model from utils import get_anchors from kmeans import YOLO_Kmeans # Define main paths projectDir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) busDetectorDir = (os.path.dirname(os.path.abspath(__file__))) dataDir = os.path.join(projectDir, "Data") annotationsPath = os.path.join(dataDir, 'annotationsTrain.txt') imagesDir = os.path.join(dataDir, "busesTrain") logDir = os.path.join(busDetectorDir, 'logs/000/') # Anchors anchors = get_anchors('yolo_anchors.txt') anchors = [ 10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326 ] anchors = np.array(anchors).reshape(-1, 2) # Classes classes = ['green', 'orange', 'white', 'silver', 'blue', 'red'] num_classes = len(classes) input_shape = (3648, 2736) # Hyper parameters batch_size = 32
def get_detector_heatmap(image_ids, image_heights, image_widths, labels): def get_detector_heatmap_each_scale(boxes_data_, best_anchors_, anchors_mask, grid_size, num_classes): num_anchors = len(anchors_mask) boxes_data_shape = boxes_data_.shape best_anchors_mask = np.isin(best_anchors_, anchors_mask, invert=True) best_anchors_ = best_anchors_ * 1 best_anchors_ -= min(anchors_mask) best_anchors_[best_anchors_mask] = 0 boxes_data_mask = np.ones_like(best_anchors) boxes_data_mask[best_anchors_mask] = 0 boxes_data_mask = np.expand_dims(boxes_data_mask, -1) boxes_data_ = boxes_data_ * boxes_data_mask i__ = np.floor(boxes_data_[:, :, 1] * grid_size[0]).astype('int32') j = np.floor(boxes_data_[:, :, 0] * grid_size[1]).astype('int32') boxes_data_ = boxes_data_.reshape([-1, boxes_data_.shape[-1]]) best_anchors_ = best_anchors_.reshape([-1, 1]) i__ = i__.reshape([-1, 1]) j = j.reshape([-1, 1]) classes = boxes_data_[:, -1].reshape([-1]).astype(np.int) one_hot_array = np.zeros([boxes_data_.shape[0], num_classes]) one_hot_array[np.arange(boxes_data_.shape[0]), classes] = 1 boxes_data_mask = boxes_data_[:, 2] > 0 boxes_data_[boxes_data_mask, 4] = 1 boxes_data_ = np.concatenate([boxes_data_, one_hot_array], axis=-1) y_true = np.zeros([ boxes_data_shape[0] * int(grid_size[0]) * int(grid_size[1]) * num_anchors, 5 + num_classes ]) image_offset = np.repeat( np.linspace(0, y_true.shape[0], boxes_data_shape[0], endpoint=False, dtype=np.int), boxes_data_.shape[0] / boxes_data_shape[0]).reshape([-1, 1]) grid_offset = num_anchors * (grid_size[0] * i__ + j) indexing_array = np.array(image_offset + grid_offset + best_anchors_, dtype=np.int32) indexing_array = indexing_array[boxes_data_mask, :] indexing_array = indexing_array.reshape([-1]) y_true[indexing_array, :] = boxes_data_[boxes_data_mask] y_true = y_true.reshape([ boxes_data_shape[0], int(grid_size[0]) * int(grid_size[1]) * num_anchors, num_classes + 5 ]) boxes_data_ = boxes_data_.reshape( [boxes_data_shape[0], boxes_data_shape[1], -1]) return y_true, boxes_data_[..., 0:4] anchors = utils.get_anchors(hyper_parameters.FLAGS.anchors_path) anchors = np.array(anchors, dtype=np.float32) boxes_data = [] for i in range(len(image_ids)): label = labels[image_ids[i].decode('utf-8')] origin_height = image_heights[i] origin_width = image_widths[i] box = build_data( label, origin_height, origin_width, max_boxes=hyper_parameters.FLAGS.max_num_boxes_per_image) boxes_data.append(box) boxes_data = np.array(boxes_data) boxes_xy = (boxes_data[:, :, 0:2] + boxes_data[:, :, 2:4]) // 2 boxes_hw = boxes_data[:, :, 2:4] - boxes_data[:, :, 0:2] boxes_data[:, :, 0] = boxes_xy[..., 0] / hyper_parameters.FLAGS.image_size boxes_data[:, :, 1] = boxes_xy[..., 1] / hyper_parameters.FLAGS.image_size boxes_data[:, :, 2] = boxes_hw[..., 0] / hyper_parameters.FLAGS.image_size boxes_data[:, :, 3] = boxes_hw[..., 1] / hyper_parameters.FLAGS.image_size hw = np.expand_dims(boxes_hw, -2) anchors_broad = np.expand_dims(anchors, 0) anchor_maxes = anchors_broad / 2. anchor_mins = -anchor_maxes box_maxes = hw / 2. box_mins = -box_maxes intersect_mins = np.maximum(box_mins, anchor_mins) intersect_maxes = np.minimum(box_maxes, anchor_maxes) intersect_hw = np.maximum(intersect_maxes - intersect_mins, 0.) intersect_area = intersect_hw[..., 0] * intersect_hw[..., 1] box_area = hw[..., 0] * hw[..., 1] anchor_area = anchors[..., 0] * anchors[..., 1] iou = intersect_area / (box_area + anchor_area - intersect_area) best_anchors = np.argmax(iou, axis=-1) large_obj_image_size = hyper_parameters.FLAGS.image_size // 32 medium_obj_image_size = hyper_parameters.FLAGS.image_size // 16 small_obj_image_size = hyper_parameters.FLAGS.image_size // 8 large_obj_detectors, large_obj_boxes = get_detector_heatmap_each_scale( boxes_data, best_anchors_=best_anchors, anchors_mask=[6, 7, 8], grid_size=(large_obj_image_size, large_obj_image_size), num_classes=hyper_parameters.FLAGS.num_classes) medium_obj_detectors, medium_obj_boxes = get_detector_heatmap_each_scale( boxes_data, best_anchors_=best_anchors, anchors_mask=[3, 4, 5], grid_size=(medium_obj_image_size, medium_obj_image_size), num_classes=hyper_parameters.FLAGS.num_classes) small_obj_detectors, small_obj_boxes = get_detector_heatmap_each_scale( boxes_data, best_anchors_=best_anchors, anchors_mask=[0, 1, 2], grid_size=(small_obj_image_size, small_obj_image_size), num_classes=hyper_parameters.FLAGS.num_classes) yolo_true_data = np.concatenate( [large_obj_detectors, medium_obj_detectors, small_obj_detectors], axis=1) yolo_true_boxes = np.concatenate( [large_obj_boxes, medium_obj_boxes, small_obj_boxes], axis=1) heatmaps = [yolo_true_data, yolo_true_boxes] return heatmaps
# Description : Define yolo3 model,loss function,etc. # #===================================================== import numpy as np import tensorflow as tf import utils import common import backbone import getConfig cfg = {} cfg = getConfig.getConfig() NUM_CLASS = len(utils.read_class_names(cfg['yolo_classes_names'])) ANCHORS = utils.get_anchors(cfg['yolo_anchors']) STRIDES = np.array(cfg['yolo_strides']) IOU_LOSS_THRESHOLD = cfg['yolo_iou_loss_threshold'] def yolo3(input_layer): branch_1,branch_2,conv = backbone.backbone(input_layer) conv = common.conv(conv,(1,512)) conv = common.conv(conv,(3,1024)) conv = common.conv(conv,(1,512)) conv = common.conv(conv,(3,1024)) conv = common.conv(conv,(1,512)) conv_l_branch = common.conv(conv,(3,1024)) l_output = common.conv(conv_l_branch,(1,3 * (NUM_CLASS + 5)),activation = False,bn = False)
anchors_s = tp.Numpy.Placeholder((cfg.YOLO.ANCHOR_PER_SCALE, 2)) anchors_l = tp.Numpy.Placeholder((cfg.YOLO.ANCHOR_PER_SCALE, 2)) func_config = flow.FunctionConfig() model = Yolov3_tiny(cfg, trainable=False) @flow.global_function(type="predict", function_config=func_config) def test_job(images: test_images, anchors_s: anchors_s, anchors_l: anchors_l) \ -> tp.Numpy: pred = model.predict(images, anchors_s, anchors_l) return pred anchors = np.array(utils.get_anchors(cfg.YOLO.ANCHORS)) anchors[0, ...] /= cfg.YOLO.STRIDES[0] anchors[1, ...] /= cfg.YOLO.STRIDES[1] def predict(original_image): ''' :param original_image: [H, W, 3] :return: (xmin, ymin, xmax, ymax, score, class) ''' image = utils.image_preporcess(np.copy(original_image), [cfg.TEST.INPUT_SIZE, cfg.TEST.INPUT_SIZE]) image = image[np.newaxis, ...] image_ = np.transpose(image, [0, 3, 1, 2])
import tensorflow as tf import numpy as np from config import cfg from utils import read_class_names, get_anchors NUM_CLASS = len(read_class_names(cfg.YOLO.CLASSES)) ANCHORS = get_anchors(cfg.YOLO.ANCHORS) STRIDES = np.array(cfg.YOLO.STRIDES) def decode(conv_output, i=0): """ :return [batch_size, output_size, output_size, anchor_per_scale, 5 + num_classes] box format: (x, y, w, h, score, probability) """ conv_shape = tf.shape(conv_output) batch_size = conv_shape[0] output_size = conv_shape[1] conv_output = tf.reshape( conv_output, (batch_size, output_size, output_size, 3, 5 + NUM_CLASS)) conv_raw_dxdy = conv_output[:, :, :, :, 0:2] conv_raw_dwdh = conv_output[:, :, :, :, 2:4] conv_raw_conf = conv_output[:, :, :, :, 4:5] conv_raw_prob = conv_output[:, :, :, :, 5:] y = tf.tile( tf.range(output_size, dtype=tf.int32)[:, tf.newaxis], [1, output_size]) x = tf.tile(
model_dict = self.state_dict() if by_name: pretrianed_dict_update = {} for k, v in pretrianed_dict.items(): if k in model_dict: vv = model_dict[k] if v.size() == vv.size(): pretrianed_dict_update[k] = v model_dict.update(pretrianed_dict_update) else: model_dict.update(pretrianed_dict) self.load_state_dict(model_dict) if __name__ == '__main__': # import os # os.environ['CUDA_VISIBLE_DEVICES'] = '3' # anchors = get_anchors( '/data1/chenww/my_research/Two-Stage-Defect-Detection/detector/config/small_8cls/anchors.txt' ).to('cuda') model = ResNet(anchors).to('cuda') model_info(model, verbose=True) # print(model) # input = torch.randn(1, 3, 224, 224) # map, outputs = model(input) # print([o.size() for o in map]) # print() # torch.save(model.state_dict(), 'model.pth')
def output_to_boxes(prob_score_map, reg_map): ''' Convert VoxelNet output to bounding boxes for visualization Parameters: prob_score_map (arr): (BS, 2, H, W), probability score map reg_map (arr): (BS, 14, H, W), regression map (deltas) Returns: arr: boxes in center notation arr: boxes in corner notation arr: scores for the boxes ''' config = load_config() batch_size, _, _, _ = prob_score_map.shape device = prob_score_map.device # Convert regression map back to bounding boxes (center notation) batch_boxes3d = delta_to_boxes3d(reg_map, get_anchors()) batch_boxes2d = batch_boxes3d[:, :, [0, 1, 4, 5, 6]] batch_probs = prob_score_map.reshape((batch_size, -1)) batch_boxes3d = batch_boxes3d.cpu().numpy() batch_boxes2d = batch_boxes2d.cpu().numpy() batch_probs = batch_probs.cpu().numpy() return_box3d = [] return_score = [] for batch_id in range(batch_size): # Remove boxes under the threshold ind = np.where( batch_probs[batch_id, :] >= config['nms_score_threshold']) tmp_boxes3d = batch_boxes3d[batch_id, ind, ...].squeeze() tmp_boxes2d = batch_boxes2d[batch_id, ind, ...].squeeze() tmp_scores = batch_probs[batch_id, ind].squeeze() # Convert center notation 3d boxes to corner notation 2d boxes corner_box2d = center_to_corner_box2d(tmp_boxes2d) # Convert from xxyy to xyxy boxes2d = corner_to_standup_box2d(corner_box2d) # Apply NMS to get rid of duplicates ind, cnt = nms( torch.from_numpy(boxes2d).to(device), torch.from_numpy(tmp_scores).to(device), config['nms_threshold'], 20, ) try: ind = ind[:cnt].cpu().detach().numpy() except IndexError: print('Unable to select NMS-detected boxes, returning None') return None, None tmp_boxes3d = tmp_boxes3d[ind, ...] tmp_scores = tmp_scores[ind] return_box3d.append(tmp_boxes3d) return_score.append(tmp_scores) return_box3d = np.array(return_box3d) # Convert center notation 3d boxes to corner notation 3d boxes ret_box3d_corner = box3d_center_to_corner_batch(return_box3d) return ret_box3d_corner, return_box3d