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)
