def __init__(self, num_classes, cfg):
super(Backbone, self).__init__()
last_stride = 1
model_path = 'out/pretrained/resnet50-19c8e357.pth'
model_name = cfg.model_name
pretrain_choice = 'imagenet'
self.cos_layer = False
self.neck = 'bnneck'
self.neck_feat = 'after'
if model_name == 'resnet50':
self.in_planes = 2048
self.base = ResNet(last_stride=last_stride,
block=Bottleneck, frozen_stages= -1,
layers=[3, 4, 6, 3])
print('using resnet50 as a backbone')
elif model_name == 'resnet50_ibn_a':
self.in_planes = 2048
self.base = resnet50_ibn_a(last_stride)
print('using resnet50_ibn_a as a backbone')
elif model_name == 'resnet101_ibn_a':
self.in_planes = 2048
self.base = resnet101_ibn_a(last_stride, frozen_stages= -1)
print('using resnet101_ibn_a as a backbone')
elif model_name == 'se_resnet101_ibn_a':
self.in_planes = 2048
self.base = se_resnet101_ibn_a(last_stride,frozen_stages= -1)
print('using se_resnet101_ibn_a as a backbone')
else:
print('unsupported backbone! but got {}'.format(model_name))
if pretrain_choice == 'imagenet':
self.base.load_param(model_path)
print('Loading pretrained ImageNet model......from {}'.format(model_path))
self.gap = nn.AdaptiveAvgPool2d(1)
self.num_classes = num_classes
# if self.cos_layer:
# print('using cosine layer')
# self.arcface = ArcFace(self.in_planes, self.num_classes, s=30.0, m=0.50)
# else:
# self.classifier = nn.Linear(self.in_planes, self.num_classes, bias=False)
# self.classifier.apply(weights_init_classifier)
self.bottleneck = nn.BatchNorm1d(self.in_planes)
self.bottleneck.bias.requires_grad_(False)
self.bottleneck.apply(weights_init_kaiming)
class MVFace(torch.nn.Module):
def __init__(self, backbone, feat_dim, num_class, is_am):
super(MVFace, self).__init__()
if backbone == 'resnet18':
self.feat_net = ResNet(last_stride=2,
block=BasicBlock,
frozen_stages=-1,
layers=[2, 2, 2, 2])
elif backbone == 'resnet50':
self.feat_net = ResNet(last_stride=2,
block=Bottleneck,
frozen_stages=-1,
layers=[3, 4, 6, 3])
elif backbone == 'resnet50_ibn':
self.feat_net = resnet50_ibn_a(last_stride=2)
else:
raise Exception(
'backbone must be resnet18, resnet50 and resnet50_ibn.')
self.gap = nn.AdaptiveAvgPool2d(1)
self.loss_layer = MV_Softmax(feat_dim=feat_dim,
num_class=num_class,
is_am=is_am)
def forward(self, data, label):
feat = self.feat_net.forward(data)
feat = self.gap(feat).squeeze()
pred = self.loss_layer.forward(feat, label)
return pred
def __init__(self, num_classes, pretrained=None):
"""
Args:
num_classes(int): number of classes, background should be counted in.
e.g: there are 100 foreground objects, num_classes should be 101.
pretrained(str): 'imagenet' or 'coco', set 'imagenet' indicate just
backbone use imagenet pretrained weights, 'coco' indicate whole
Mask R-CNN model use pretrained weights on COCO dataset.
"""
super(MaskRCNN, self).__init__()
if pretrained is not None:
assert pretrained in ['imagenet', 'coco']
assert pretrained not in [
'coco'
], "COCO pretrained weights is not available yet."
self.config = ConfigParser()
self.config.read(
os.path.abspath(os.path.join(__file__, "../", "config.ini")))
self.num_classes = num_classes
self.pooling_size_clsbbox = (7, 7)
self.pooling_size_mask = (14, 14)
self.validating = False # when True output loss and predict results.
self.fpn_on = bool(int(self.config['BACKBONE']['FPN_ON']))
self.mask_head_on = bool(int(self.config['HEAD']['MASK_HEAD_ON']))
self.train_rpn_only = bool(int(self.config['TRAIN']['TRAIN_RPN_ONLY']))
resnet_layer = int(self.config['BACKBONE']['RESNET_LAYER'])
if self.fpn_on:
self.backbone_fpn = ResNetFPN(resnet_layer, pretrained=pretrained)
self.depth = 256
else:
self.backbone = ResNet(resnet_layer, pretrained=pretrained)
self.depth = 1024
self.rpn = RPN(self.depth, self.fpn_on)
if not self.train_rpn_only:
# RoiAlign for cls and bbox head, pooling size 7x7
self.roi_align_clsbbox = RoiAlign(
grid_size=self.pooling_size_clsbbox)
# RoiAlign for mask head, pooling size 14x14
self.roi_align_mask = RoiAlign(grid_size=self.pooling_size_mask)
self.clsbbox_head = ClsBBoxHead(
depth=self.depth,
pool_size=self.pooling_size_clsbbox,
num_classes=num_classes)
if self.mask_head_on:
self.mask_head = MaskHead(depth=self.depth,
pool_size=self.pooling_size_mask,
num_classes=num_classes)
self.img_height = None
self.img_width = None
self.batch_size = None
def __init__(self, backbone, feat_dim, num_class, is_am):
super(MVFace, self).__init__()
if backbone == 'resnet18':
self.feat_net = ResNet(last_stride=2,
block=BasicBlock,
frozen_stages=-1,
layers=[2, 2, 2, 2])
elif backbone == 'resnet50':
self.feat_net = ResNet(last_stride=2,
block=Bottleneck,
frozen_stages=-1,
layers=[3, 4, 6, 3])
elif backbone == 'resnet50_ibn':
self.feat_net = resnet50_ibn_a(last_stride=2)
else:
raise Exception(
'backbone must be resnet18, resnet50 and resnet50_ibn.')
self.gap = nn.AdaptiveAvgPool2d(1)
self.loss_layer = MV_Softmax(feat_dim=feat_dim,
num_class=num_class,
is_am=is_am)
def __init__(self, num_classes, pretrained=None):
super(MaskRCNN, self).__init__()
if pretrained is not None:
assert pretrained in ['imagenet', 'voc2007', 'coco']
assert pretrained not in ['voc2007', 'coco'], ("VOC2007 and COCO pretrained weights "
"will be added soon.")
self.config = ConfigParser()
self.config.read(os.path.abspath(os.path.join(__file__, "../", "config.ini")))
self.num_classes = num_classes
self.pooling_size_clsbbox = (7, 7)
self.pooling_size_mask = (14, 14)
use_fpn = bool(int(self.config['BACKBONE']['USE_FPN']))
self.use_fpn = use_fpn
self.train_rpn_only = bool(int(self.config['TRAIN']['TRAIN_RPN_ONLY']))
resnet_layer = int(self.config['BACKBONE']['RESNET_LAYER'])
if self.use_fpn:
self.backbone_fpn = ResNetFPN(resnet_layer, pretrained=pretrained)
self.depth = 256
else:
self.backbone = ResNet(resnet_layer, pretrained=pretrained)
self.depth = 1024
self.rpn = RPN(self.depth, self.use_fpn)
if not self.train_rpn_only:
# RoiAlign for cls and bbox head, pooling size 7x7
self.roi_align_clsbbox = RoiAlign(grid_size=self.pooling_size_clsbbox)
# RoiAlign for mask head, pooling size 14x14
self.roi_align_mask = RoiAlign(grid_size=self.pooling_size_mask)
self.clsbbox_head = ClsBBoxHead(depth=self.depth, pool_size=self.pooling_size_clsbbox,
num_classes=num_classes)
self.mask_head = MaskHead(depth=self.depth, pool_size=self.pooling_size_mask,
num_classes=num_classes)
self.img_height = None
self.img_width = None
self.batch_size = None
class Backbone(nn.Module):
def __init__(self, num_classes, cfg):
super(Backbone, self).__init__()
last_stride = 1
model_path = 'out/pretrained/resnet50-19c8e357.pth'
model_name = cfg.model_name
pretrain_choice = 'imagenet'
self.cos_layer = False
self.neck = 'bnneck'
self.neck_feat = 'after'
if model_name == 'resnet50':
self.in_planes = 2048
self.base = ResNet(last_stride=last_stride,
block=Bottleneck, frozen_stages= -1,
layers=[3, 4, 6, 3])
print('using resnet50 as a backbone')
elif model_name == 'resnet50_ibn_a':
self.in_planes = 2048
self.base = resnet50_ibn_a(last_stride)
print('using resnet50_ibn_a as a backbone')
elif model_name == 'resnet101_ibn_a':
self.in_planes = 2048
self.base = resnet101_ibn_a(last_stride, frozen_stages= -1)
print('using resnet101_ibn_a as a backbone')
elif model_name == 'se_resnet101_ibn_a':
self.in_planes = 2048
self.base = se_resnet101_ibn_a(last_stride,frozen_stages= -1)
print('using se_resnet101_ibn_a as a backbone')
else:
print('unsupported backbone! but got {}'.format(model_name))
if pretrain_choice == 'imagenet':
self.base.load_param(model_path)
print('Loading pretrained ImageNet model......from {}'.format(model_path))
self.gap = nn.AdaptiveAvgPool2d(1)
self.num_classes = num_classes
# if self.cos_layer:
# print('using cosine layer')
# self.arcface = ArcFace(self.in_planes, self.num_classes, s=30.0, m=0.50)
# else:
# self.classifier = nn.Linear(self.in_planes, self.num_classes, bias=False)
# self.classifier.apply(weights_init_classifier)
self.bottleneck = nn.BatchNorm1d(self.in_planes)
self.bottleneck.bias.requires_grad_(False)
self.bottleneck.apply(weights_init_kaiming)
def forward(self, x, label=None): # label is unused if self.cos_layer == 'no'
x = self.base(x)
global_feat = nn.functional.avg_pool2d(x, x.shape[2:4])
global_feat = global_feat.view(global_feat.shape[0], -1) # flatten to (bs, 2048)
feat = self.bottleneck(global_feat)
if self.neck == 'no':
feat = global_feat
elif self.neck == 'bnneck':
feat = self.bottleneck(global_feat)
if self.training:
# if self.cos_layer:
# cls_score = self.arcface(feat, label)
# else:
# cls_score = self.classifier(feat)
return global_feat # global feature for triplet loss
else:
if self.neck_feat == 'after':
# print("Test with feature after BN")
return feat
else:
# print("Test with feature before BN")
return global_feat
def load_param(self, trained_path):
param_dict = torch.load(trained_path)
for i in param_dict:
if 'classifier' in i or 'arcface' in i:
continue
self.state_dict()[i].copy_(param_dict[i])
print('Loading pretrained model from {}'.format(trained_path))
def load_param_finetune(self, model_path):
param_dict = torch.load(model_path)
for i in param_dict:
self.state_dict()[i].copy_(param_dict[i])
print('Loading pretrained model for finetuning from {}'.format(model_path))
def __init__(self, num_classes, pretrained=None):
"""
Args:
num_classes(int): number of classes, background should be counted in.
e.g: there are 100 foreground objects, num_classes should be 101.
pretrained(str): 'imagenet' or 'coco', set 'imagenet' indicate just
backbone use imagenet pretrained weights, 'coco' indicate whole
Mask R-CNN model use pretrained weights on COCO dataset.
"""
super(MaskRCNN, self).__init__()
if pretrained is not None:
assert pretrained in ['imagenet', 'coco']
assert pretrained not in [
'coco'
], "COCO pretrained weights is not available yet."
self.config = ConfigParser()
config_path = os.path.abspath(
os.path.join(__file__, "../", "config.ini"))
assert os.path.exists(config_path), "config.ini not exists!"
self.config.read(config_path)
self.num_classes = num_classes
self.validating = False # when validating output loss and predict results.
self.fpn_on = bool(int(self.config['BACKBONE']['FPN_ON']))
self.mask_head_on = bool(int(self.config['HEAD']['MASK_HEAD_ON']))
self.train_rpn_only = bool(int(self.config['TRAIN']['TRAIN_RPN_ONLY']))
resnet_layer = int(self.config['BACKBONE']['RESNET_LAYER'])
self.pooling_size_clsbbox = int(
self.config['POOLING']['POOLING_SIZE_CLSBBOX'])
self.pooling_size_mask = int(
self.config['POOLING']['POOLING_SIZE_MASK'])
if self.fpn_on:
self.backbone_fpn = ResNetFPN(resnet_layer, pretrained=pretrained)
self.depth_for_rpn = 256
self.depth_for_head = 2048
else:
backbone_type = self.config['BACKBONE']['BACKBONE_TYPE']
assert backbone_type in ['resnet', 'vgg16']
if backbone_type == 'resnet':
self.backbone = ResNet(resnet_layer, pretrained=pretrained)
self.depth_rpn = 1024
self.depth_head = 2048
elif backbone_type == 'vgg16':
self.backbone = VGG16(pretrained=pretrained)
self.depth_rpn = 512
self.depth_head = 4096
self.rpn = RPN(self.depth_rpn, self.fpn_on)
self.head_common = HeadCommon(pretrained=pretrained)
if not self.train_rpn_only:
# RoiAlign for cls and bbox head
self.roi_align_clsbbox = RoiAlign(
grid_size=(self.pooling_size_clsbbox,
self.pooling_size_clsbbox))
self.clsbbox_head = ClsBBoxHead(depth=self.depth_head,
num_classes=num_classes)
if self.mask_head_on:
# RoiAlign for mask head
self.roi_align_mask = RoiAlign(
grid_size=(self.pooling_size_mask, self.pooling_size_mask))
self.mask_head = MaskHead(depth=self.depth_head,
pool_size=(self.pooling_size_mask,
self.pooling_size_mask),
num_classes=num_classes)
self.img_height = None
self.img_width = None
self.batch_size = None