def __init__(self, **kwargs): super(PseDetectionModel, self).__init__(**kwargs) n = get('n', kwargs, 6) scale = get('scale', kwargs, 1) channels = get_valid('channels', kwargs) self.scale = scale conv_out = 256 # Top layer self.toplayer = nn.Conv2d(channels[0], conv_out, kernel_size=1, stride=1, padding=0) # Reduce channels # Lateral layers self.latlayer1 = nn.Conv2d(channels[1], conv_out, kernel_size=1, stride=1, padding=0) self.latlayer2 = nn.Conv2d(channels[2], conv_out, kernel_size=1, stride=1, padding=0) self.latlayer3 = nn.Conv2d(channels[3], conv_out, kernel_size=1, stride=1, padding=0) # Smooth layers self.smooth1 = nn.Conv2d(conv_out, conv_out, kernel_size=3, stride=1, padding=1) self.smooth2 = nn.Conv2d(conv_out, conv_out, kernel_size=3, stride=1, padding=1) self.smooth3 = nn.Conv2d(conv_out, conv_out, kernel_size=3, stride=1, padding=1) self.conv = nn.Sequential( nn.Conv2d(conv_out * 4, conv_out, kernel_size=3, padding=1, stride=1), nn.BatchNorm2d(conv_out), nn.ReLU(inplace=True) ) self.out_conv = nn.Conv2d(conv_out, n, kernel_size=1, stride=1)
def save_model(self, **kwargs): model = get_valid('model', kwargs) ckpt_folder = get_valid('ckpt_folder', kwargs) epoch = get_valid('epoch', kwargs) loss = get_valid('loss', kwargs) eval_type = get('eval_type', kwargs, 'acc') acc = get('acc', kwargs) acc = round(acc, 4) model_name = get('model_name', kwargs, '') state = { 'epoch': epoch, 'state_dict': model.state_dict(), 'eval_type': eval_type, 'acc': acc, 'loss': loss } loss = round(loss, 4) ckpt_name = '{}epoch{}_{}{}_loss{}.pth'.format(model_name, epoch, eval_type, acc, loss) ckpt_path = os.path.join(ckpt_folder, ckpt_name) torch.save(state, ckpt_path) print('Save checkpoint: {}'.format(ckpt_path)) return ckpt_path
def save_model(self, **kwargs): model = get_valid('model', kwargs) ckpt_folder = get_valid('ckpt_folder', kwargs) epoch = get_valid('epoch', kwargs) loss = get_valid('loss', kwargs) eval_type = get('eval_type', kwargs, 'score') eval_score = get('eval_score', kwargs, 0) model_name = get('model_name', kwargs, '') state = { 'epoch': epoch, 'state_dict': model.state_dict(), 'eval_type': eval_type, 'eval_score': eval_score, 'loss': loss } if eval_type is None: eval_type = '' if eval_score is None: eval_score = '' else: eval_score = round(eval_score, 4) eval_score = str(eval_score) loss = round(loss, 4) loss = str(loss) ckpt_name = '{}epoch{}{}{}loss{}.pth'.format(model_name, epoch, eval_type, eval_score, loss) ckpt_path = os.path.join(ckpt_folder, ckpt_name) torch.save(state, ckpt_path) print('Save checkpoint: {}'.format(ckpt_path)) return ckpt_path
def init_testloader(self, **kwargs): super(EastDetectionTemplate, self).init_testloader(**kwargs) test_transforms = get('test_transforms', kwargs, None) if test_transforms is None: test_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) kwargs['transforms'] = test_transforms test_folder = get_valid('test_folder', kwargs) assert os.path.exists(test_folder) test_dataset = EastDataset(folder=test_folder, **kwargs) test_data_num = len(test_dataset) test_batch = get('test_batch', kwargs, 4) test_worker = get('test_worker', kwargs, 8) if self.gpu is None: batch_size = test_batch else: batch_size = test_batch * len(self.gpu) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, num_workers=test_worker) print('Generate test data loader, test data folder: {}, train data num: {}'.format(test_folder, test_data_num)) return test_loader
def init_testloader(self, **kwargs): test_transforms = get('test_transforms', kwargs, None) if test_transforms is None: test_transforms = transforms.Compose([ # Denoise(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) kwargs['transforms'] = test_transforms test_folder = get_valid('test_folder', kwargs) test_batch = get('test_batch', kwargs, 64) test_worker = get('test_worker', kwargs, 8) class_dict = get_valid('class_dict', kwargs) test_loader_dict = dict() for cls in class_dict: cls_folder = os.path.join(test_folder, cls) cls_index_path = os.path.join(cls_folder, 'label.txt') test_dataset = SarDataset(index_path=cls_index_path, folder=cls_folder, **kwargs) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=self.get_batch_size(test_batch), num_workers=test_worker) cls_int = class_dict[cls] test_loader_dict[cls_int] = test_loader print('test {} data num: {}!'.format(cls, len(test_dataset))) return test_loader_dict
def init_testloader(self, **kwargs): super(SarRecognitionTemplate, self).init_testloader(**kwargs) test_transforms = get('test_transforms', kwargs, None) if test_transforms is None: test_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) kwargs['transforms'] = test_transforms test_index = get_valid('test_index', kwargs) test_folder = get_valid('test_folder', kwargs) test_dataset = SarDataset(index_path=test_index, folder=test_folder, **kwargs) test_batch = get('test_batch', kwargs, 64) test_worker = get('test_worker', kwargs, 8) test_loader = torch.utils.data.DataLoader( test_dataset, batch_size=self.get_batch_size(test_batch), num_workers=test_worker) test_data_num = len(test_dataset) print('Analyse test index: {}, test data num: {}!'.format( test_index, test_data_num)) return test_loader
def init_testloader(self, **kwargs): test_transforms = get('test_transforms', kwargs, None) if test_transforms is None: test_transforms = transforms.Compose([ Denoise(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) test_folder = get_valid('test_folder', kwargs) test_dataset = MultiDecoderClassifyDataset(folder=test_folder, is_training=False, transforms=test_transforms, **kwargs) test_batch = get('test_batch', kwargs, 16) test_worker = get('test_worker', kwargs, 8) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=test_batch, num_workers=test_worker) test_data_num = len(test_dataset) self.test_data_num = test_data_num print( 'generate test data loader, test data folder: {}, test data num:{}' .format(test_folder, test_data_num)) return test_loader
def predict(self, **kwargs): super(PredictEASTDetection, self).predict(**kwargs) score_map_thresh = get('score_map_thresh', kwargs, 0.7) box_thresh = get('box_thresh', kwargs, 0.1) nms_thresh = get('nms_thresh', kwargs, 0.2) img = self.pretreatment(**kwargs) with torch.no_grad(): if self.use_gpu: img = img.cuda() score, geometry = self.model(image=img) score = score.permute(0, 2, 3, 1) geometry = geometry.permute(0, 2, 3, 1) score = score.data.cpu().numpy() geometry = geometry.data.cpu().numpy() boxes = detect(score_map=score, geo_map=geometry, score_map_thresh=score_map_thresh, box_thresh=box_thresh, nms_thresh=nms_thresh) pred_list = list() if boxes is not None: boxes = boxes[:, :8].reshape(-1, 4, 2) for box in boxes: box = sort_poly(box.astype(np.int32)) pred_list.append(box) return pred_list
def init_optimizer(self, model, **kwargs): learning_rate = get('learning_rate', kwargs, 0.001) weight_decay = get('weight_decay', kwargs, 1e-4) raw_parameters = list(model.backbone.parameters()) part_parameters = list(model.proposal_net.parameters()) concat_parameters = list(model.concat_net.parameters()) partcls_parameters = list(model.partcls_net.parameters()) raw_optimizer = torch.optim.SGD(raw_parameters, lr=learning_rate, momentum=0.9, weight_decay=weight_decay) concat_optimizer = torch.optim.SGD(concat_parameters, lr=learning_rate, momentum=0.9, weight_decay=weight_decay) part_optimizer = torch.optim.SGD(part_parameters, lr=learning_rate, momentum=0.9, weight_decay=weight_decay) partcls_optimizer = torch.optim.SGD(partcls_parameters, lr=learning_rate, momentum=0.9, weight_decay=weight_decay) schedulers = [ MultiStepLR(raw_optimizer, milestones=[60, 100], gamma=0.1), MultiStepLR(concat_optimizer, milestones=[60, 100], gamma=0.1), MultiStepLR(part_optimizer, milestones=[60, 100], gamma=0.1), MultiStepLR(partcls_optimizer, milestones=[60, 100], gamma=0.1) ] return raw_optimizer, concat_optimizer, part_optimizer, partcls_optimizer, schedulers
def __init__(self, **kwargs): self.folder = get_valid('folder', kwargs) self.transforms = get('transforms', kwargs, None) self.input_size = get('input_size', kwargs, (768, 768)) self.detection_transforms = get('detection_transforms', kwargs, None) self.data_list = self.__get_data_list() self.n = get('n', kwargs, 6) self.m = get('m', kwargs, 0.5)
def __init__(self, **kwargs): self.folder = get_valid('folder', kwargs) self.is_training = get_valid('is_training', kwargs) self.class_dict = get_valid('class_dict', kwargs) self.transforms = get_valid('transforms', kwargs) self.size = get('size', kwargs, (32, 256, 3)) self.split = get('split', kwargs, ',') self.index_list = self.__generate_index()
def __init__(self, **kwargs): """Implement PSE Loss. """ super(PseDetectionLoss, self).__init__() reduction = get('reduction', kwargs, 'mean') assert reduction in ['mean', 'sum'], " reduction must in ['mean','sum']" self.Lambda = get('Lambda', kwargs, 0.7) self.ratio = get('ratio', kwargs, 3) self.reduction = reduction
def init_optimizer(self, **kwargs): super(ClassifyTemplate, self).init_optimizer(**kwargs) model = get_valid('model', kwargs) lr = get('lr', kwargs, 0.001) weight_decay = get('weight_decay', kwargs, 1e-4) raw_optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=weight_decay) return raw_optimizer
def __init__(self, **kwargs): self.use_gpu = get('use_gpu', kwargs, True) if self.use_gpu: if not torch.cuda.is_available(): raise RuntimeError('CUDA is not availabel!') else: if torch.cuda.is_available(): print('CUDA is availabel but not use it!') self.encoding = get('encoding', kwargs, 'utf-8')
def resnet50(**kwargs): pretrained = get('pretrained_backbone', kwargs, False) backbone_path = get('backbone_path', kwargs, None) model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs) if pretrained is True: if backbone_path is not None: ckpt = torch.load(backbone_path) else: url = resnet_urls['resnet50'] ckpt = model_zoo.load_url(url) model.load_state_dict(ckpt) return model
def eval_model(self, **kwargs): model = get_valid('model', kwargs) model.eval() eval_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) test_folder = get_valid('test_folder', kwargs) pred_folder = get_valid('pred_folder', kwargs) scale = get('scale', kwargs, 4) img_list = get_img_list(test_folder) for img in img_list: img_path = os.path.join(test_folder, img) image = cv2.imread(img_path) image = image.astype(np.float32) image = eval_transforms(image) image = image.unsqueeze(0) if self.gpu is not None: image = image.cuda() with torch.no_grad(): output = model(image=image) preds, boxes_list = pse_decode(output[0], scale) pred_list = list() if len(boxes_list)>0: for box in boxes_list: box = sort_poly(box.astype(np.int32)) pred = '{},{},{},{},{},{},{},{}'.format(box[0, 0], box[0, 1], box[1, 0], box[1, 1], box[2, 0], box[2, 1], box[3, 0], box[3, 1]) pred_list.append(pred) txt_name = img.split('.')[0] + '.txt' txt_path = os.path.join(pred_folder, txt_name) list2txt(boxes_list, txt_path) iou_threshold = get('iou_threshold', kwargs, 0.5) score, total_label_num, total_pred_num, total_correct_num = f1score(test_folder, pred_folder, iou_threshold) if total_label_num == 0 or total_correct_num == 0 or total_pred_num == 0: precision = 0 recall = 0 else: precision = total_correct_num / total_label_num recall = total_correct_num / total_pred_num print('f1score: {}, precision={}/{}={}, recall={}/{}={}, iou threshold: {};'.format(score, total_correct_num, total_label_num, precision, total_correct_num, total_pred_num, recall, iou_threshold)) return score
def pretreatment(self, **kwargs): eval_transforms = get('eval_transforms', kwargs) if eval_transforms is None: input_size = get('input_size', kwargs, 600) crop_size = get('crop_size', kwargs, 448) eval_transforms = transforms.Compose([ Padding(input_size), transforms.CenterCrop((crop_size, crop_size)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) img = get_valid('img', kwargs) return eval_transforms(img).float().unsqueeze(0)
def __init__(self, **kwargs): super(PredictSarRecognition, self).__init__(**kwargs) word_index_path = get_valid('word_index_path', kwargs) self.word2num, self.num2word = self.generate_dict(word_index_path) self.class_num = len(self.word2num) self.max_len = get('max_len', kwargs, 64) self.mask_ratio = get('mask_ratio', kwargs, (8, 4)) self.size = get('size', kwargs, (32, 256, 3)) model = self.init_model(**kwargs) model = self.load_model(model=model, **kwargs) if self.use_gpu: model = model.cuda() self.model = model.eval()
def retrieval(self, **kwargs): target_folder = get_valid('target_folder', kwargs) lsh = get_valid('lsh', kwargs) query_num = get('query_num', kwargs, 1) query_num = int(query_num) images = ImageProcess(target_folder).process() print('extract target feature') vecs, img_paths = extract_vectors(self.model, images, 1024, self.transform, ms=self.ms) target_feature = dict( zip(img_paths, list(vecs.detach().cpu().numpy().T))) for q_path, q_vec in target_feature.items(): try: response = lsh.query(q_vec.flatten(), num_results=query_num, distance_func="cosine") print('target img: {}'.format(q_path)) for idx in range(query_num): query_img_path = response[idx][0][1] print('{}th query img: {}'.format(idx, query_img_path)) print('*' * 20) except: print('error occur on: {}'.format(q_path)) continue
def __init__(self, **kwargs): super(SarRecognitionTemplate, self).__init__(**kwargs) word_index_path = get_valid('word_index_path', kwargs) self.word2num, self.num2word = self.generate_dict(word_index_path) assert len(self.word2num) == len(self.num2word) self.class_num = len(self.word2num) self.max_len = get('max_len', kwargs, 64)
def forward(self, **kwargs): super(SarRecognitionModel, self).forward(**kwargs) image = get_valid('image', kwargs) target_variable = get_valid('target', kwargs) mask = get_valid('mask', kwargs) teacher_forcing_ratio = get('teacher_forcing_ratio', kwargs, 1) hidden, feature = self.encoder(image=image) hidden = hidden.permute(2, 0, 1) decoder_input = target_variable[:, 0] output_list = list() for di in range(1, target_variable.shape[1]): output, hidden = self.decoder(input=decoder_input, hidden=hidden, feature=feature, mask=mask) output_list.append(output.unsqueeze(1)) teacher_forcing = random.random() < teacher_forcing_ratio if teacher_forcing: decoder_input = target_variable[:, di] else: _, topi = output.data.topk(1) decoder_input = topi.squeeze(1) output_list = torch.cat(output_list, 1) return output_list
def __init__(self, block, layers, num_classes=1000, **kwargs): self.get_layer1_feature = get('get_layer1_feature', kwargs, False) self.get_layer2_feature = get('get_layer2_feature', kwargs, False) self.get_layer3_feature = get('get_layer3_feature', kwargs, False) self.get_layer4_feature = get('get_layer4_feature', kwargs, False) self.get_avgpool_feature = get('get_avgpool_feature', kwargs, False) self.get_fc_feature = get('get_fc_feature', kwargs, False) self.get_fc_output = get('get_fc_output', kwargs, False) self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(512 * block.expansion, num_classes) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
def init_trainloader(self, **kwargs): super(SarRecognitionTemplate, self).init_trainloader(**kwargs) train_transforms = get('train_transforms', kwargs, None) if train_transforms is None: distort_num = get('distort_num', kwargs, 10) distort_ratio = get('distort_ratio', kwargs, 0.1) train_transforms = transforms.Compose([ RandomDistort(distort_num, distort_ratio), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) kwargs['transforms'] = train_transforms train_index = get_valid('train_index', kwargs) train_folder = get_valid('train_folder', kwargs) train_dataset = SarDataset(index_path=train_index, folder=train_folder, **kwargs) train_batch = get('train_batch', kwargs, 64) train_worker = get('train_worker', kwargs, 8) drop_last = get('drop_last', kwargs, True) shuffle = get('shuffle', kwargs, True) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=self.get_batch_size(train_batch), num_workers=train_worker, drop_last=drop_last, shuffle=shuffle) train_data_num = len(train_dataset) print('Analyse train index: {}, train data num: {}!'.format( train_index, train_data_num)) return train_loader
def init_trainloader(self, **kwargs): train_transforms = get('train_transforms', kwargs, None) if train_transforms is None: distort_num = get('distort_num', kwargs, 10) distort_ratio = get('distort_ratio', kwargs, 0.1) train_transforms = transforms.Compose([ RandomDistort(distort_num, distort_ratio), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) train_folder = get_valid('train_folder', kwargs) train_dataset = MultiDecoderClassifyDataset( folder=train_folder, is_training=True, transforms=train_transforms, **kwargs) train_batch = get('train_batch', kwargs, 16) train_worker = get('train_worker', kwargs, 8) drop_last = get('drop_last', kwargs, True) shuffle = get('shuffle', kwargs, True) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=train_batch, num_workers=train_worker, drop_last=drop_last, shuffle=shuffle) train_data_num = len(train_dataset) self.train_data_num = train_data_num print( 'Generate train data loader, train data folder: {}, train data num: {}' .format(train_folder, train_data_num)) return train_loader
def __init__(self, **kwargs): super(Decoder, self).__init__() self.hidden_size = get('hidden_size', kwargs, 512) self.class_num = get_valid('class_num', kwargs) self.embedding = nn.Embedding(self.class_num, self.hidden_size) self.dropout_p = get('dropout_p', kwargs, 0.1) self.f_channel = get('f_channel', kwargs, 512) # print('**** decoder dropout ratio: {} ****'.format(self.dropout_p)) self.dropout = nn.Dropout(self.dropout_p) self.rnn = nn.GRU(self.hidden_size, self.hidden_size, num_layers=2) self.out = nn.Linear(self.hidden_size + self.f_channel, self.class_num) self.conv1 = nn.Conv2d(512, 512, kernel_size=1, stride=1, bias=False) self.conv2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1, bias=False) self.conv3 = nn.Conv2d(512, 1, kernel_size=1, stride=1, bias=False)
def wrapper(*args, **kwargs): config_path = get('config_path', kwargs) if config_path is None: output_folder = get_valid('output_folder', kwargs) now = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S') output_folder = os.path.join(output_folder, now) if not os.path.exists(output_folder): os.makedirs(output_folder) kwargs['output_folder'] = output_folder config_path = os.path.join(output_folder, 'config.txt') avoid_key = get('avoid_key', kwargs, list()) config_list = list() for key in kwargs: if key not in avoid_key: config = '{}:{}'.format(key, kwargs[key]) print(config) config_list.append(config) list2txt(config_list, config_path) return func(*args, **kwargs)
def pretreatment(self, **kwargs): eval_transforms = get('eval_transforms', kwargs) if eval_transforms is None: eval_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) img = get_valid('img', kwargs) img = img.astype(np.float32) return eval_transforms(img).unsqueeze(0)
def init_testloader(self, **kwargs): super(ClassifyTemplate, self).init_testloader(**kwargs) test_transforms = get('test_transforms', kwargs) if test_transforms is None: input_size = get('input_size', kwargs, 600) crop_size = get('crop_size', kwargs, 448) test_transforms = transforms.Compose([ Padding(input_size), transforms.CenterCrop((crop_size, crop_size)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) test_folder = get('test_folder', kwargs) assert os.path.exists(test_folder) test_folder = test_folder test_datset = ClassifyDataset(folder=test_folder, is_training=False, transforms=test_transforms, **kwargs) test_batch = get('test_batch', kwargs, 16) test_worker = get('test_worker', kwargs, 8) test_loader = torch.utils.data.DataLoader(test_datset, batch_size=test_batch, num_workers=test_worker) test_data_num = len(test_datset) self.test_data_num = test_data_num print( 'generate test data loader, test data folder: {}, test data num:{}' .format(test_folder, test_data_num)) return test_loader
def __init__(self, **kwargs): self.checkpoint = get_valid('checkpoint', kwargs) self.state = torch.load(self.checkpoint) net_params = self.init_params() self.model = init_network(net_params) self.model.load_state_dict(self.state['state_dict']) if torch.cuda.is_available(): self.model.cuda() self.model.eval() multiscale = '[1]' self.ms = list(eval(multiscale)) self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=self.model.meta['mean'], std=self.model.meta['std']) ]) self.hash_size = get('hash_size', kwargs, 0) self.num_hashtables = get('num_hashtables', kwargs, 1) self.input_dim = get('input_dim', kwargs, 2048) self.image_size = get('image_size', kwargs, 1024)
def __init__(self, **kwargs): kwargs['get_layer4_feature'] = True kwargs['get_fc_feature'] = True kwargs['get_fc_output'] = True self.nts_fc_ratio = get_valid("nts_fc_ratio", kwargs) self.use_gpu = get('use_gpu', kwargs, True) self.class_num = get_valid('class_num', kwargs) super(NTSClassifyModel, self).__init__(**kwargs) self.top_n = get('top_n', kwargs, 6) self.crop_size = get('crop_size', kwargs, (448, 448)) self.cat_num = get('cat_num', kwargs, 4) self._default_anchors_setting = ( dict(layer='p3', stride=32, size=48, scale=[2**(1. / 3.), 2**(2. / 3.)], aspect_ratio=[0.667, 1, 1.5]), dict(layer='p4', stride=64, size=96, scale=[2**(1. / 3.), 2**(2. / 3.)], aspect_ratio=[0.667, 1, 1.5]), dict(layer='p5', stride=128, size=192, scale=[1, 2**(1. / 3.), 2**(2. / 3.)], aspect_ratio=[0.667, 1, 1.5]), ) self.backbone.avgpool = nn.AdaptiveAvgPool2d(1) self.backbone.fc = nn.Linear(512 * self.nts_fc_ratio, self.class_num) self.proposal_net = ProposalNet(**kwargs) self.concat_net = nn.Linear( 512 * self.nts_fc_ratio * (self.cat_num + 1), self.class_num) self.partcls_net = nn.Linear(512 * self.nts_fc_ratio, self.class_num) _, edge_anchors, _ = self.generate_default_anchor_maps() self.pad_side = 224 self.edge_anchors = (edge_anchors + 224).astype(np.int)