def init_func(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (-1)):
init.gauss_(0.0, mean=gain)
elif (classname.find('BatchNorm') != (-1)):
init.gauss_(1.0, mean=0.02)
m.bias.data.fill_(0)
def weights_init_normal(m):
classname = m.__class__.__name__
if (classname.find('Linear') != (- 1)):
init.gauss_(m.weight, mean=0.0, std=0.02)
elif (classname.find('BatchNorm') != (- 1)):
init.gauss_(m.weight, mean=1.0, std=0.02)
init.constant_(m.bias, value=0.0)
def make_conv3x3(
in_channels,
out_channels,
dilation=1,
stride=1,
use_gn=False,
use_relu=False,
kaiming_init=True
):
conv = Conv2d(
in_channels,
out_channels,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
bias=False if use_gn else True
)
if kaiming_init:
init.kaiming_normal_(
conv.weight, mode="fan_out", nonlinearity="relu"
)
else:
init.gauss_(conv.weight, std=0.01)
if not use_gn:
init.constant_(conv.bias, 0)
module = [conv,]
if use_gn:
module.append(group_norm(out_channels))
if use_relu:
module.append(nn.ReLU())
if len(module) > 1:
return nn.Sequential(*module)
return conv
def __init__(self, cfg, in_channels, num_anchors):
"""
Arguments:
cfg : config
in_channels (int): number of channels of the input feature
num_anchors (int): number of anchors to be predicted
"""
super(RPNHead, self).__init__()
self.conv = nn.Conv(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1)
self.cls_logits = nn.Conv(in_channels,
num_anchors,
kernel_size=1,
stride=1)
self.bbox_pred = nn.Conv(in_channels,
num_anchors * 4,
kernel_size=1,
stride=1)
for l in [self.conv, self.cls_logits, self.bbox_pred]:
init.gauss_(l.weight, std=0.01)
init.constant_(l.bias, 0)
def __init__(self, cfg, in_channels):
"""
Arguments:
in_channels (int): number of channels of the input feature
num_anchors (int): number of anchors to be predicted
"""
super(RetinaNetHead, self).__init__()
# TODO: Implement the sigmoid version first.
num_classes = cfg.MODEL.RETINANET.NUM_CLASSES - 1
num_anchors = len(cfg.MODEL.RETINANET.ASPECT_RATIOS) \
* cfg.MODEL.RETINANET.SCALES_PER_OCTAVE
cls_tower = []
bbox_tower = []
for i in range(cfg.MODEL.RETINANET.NUM_CONVS):
cls_tower.append(
nn.Conv(
in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1
)
)
cls_tower.append(nn.ReLU())
bbox_tower.append(
nn.Conv(
in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1
)
)
bbox_tower.append(nn.ReLU())
self.cls_tower = nn.Sequential(*cls_tower)
self.bbox_tower = nn.Sequential(*bbox_tower)
self.cls_logits = nn.Conv(
in_channels, num_anchors * num_classes, kernel_size=3, stride=1,
padding=1
)
self.bbox_pred = nn.Conv(
in_channels, num_anchors * 4, kernel_size=3, stride=1,
padding=1
)
# Initialization
for modules in [self.cls_tower, self.bbox_tower, self.cls_logits,
self.bbox_pred]:
for l in modules.modules():
if isinstance(l, nn.Conv):
init.gauss_(l.weight, std=0.01)
init.constant_(l.bias, 0)
# retinanet_bias_init
prior_prob = cfg.MODEL.RETINANET.PRIOR_PROB
bias_value = -math.log((1 - prior_prob) / prior_prob)
init.constant_(self.cls_logits.bias, bias_value)
def __init__(self, cfg):
super(MaskIoUPredictor, self).__init__()
num_classes = cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES
self.maskiou = nn.Linear(1024, num_classes)
init.gauss_(self.maskiou.weight, mean=0, std=0.01)
init.constant_(self.maskiou.bias, 0)
def weights_init_normal(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (-1)):
init.gauss_(m.weight, mean=0.0, std=0.02)
if (hasattr(m, 'bias') and (m.bias is not None)):
init.constant_(m.bias, value=0.0)
elif (classname.find('BatchNorm') != (-1)):
init.gauss_(m.weight, mean=1.0, std=0.02)
init.constant_(m.bias, value=0.0)
def __init__(self, cfg):
super(MaskIoUGAPPredictor, self).__init__()
num_classes = cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES
in_channel = cfg.MODEL.ROI_MASK_HEAD.CONV_LAYERS[0]
self.maskiou = nn.Linear(in_channel, num_classes)
init.gauss_(self.maskiou.weight, mean=0, std=0.01)
init.constant_(self.maskiou.bias, 0)
def init_weights(m, mode='MSRAFill'):
if isinstance(m, (nn.Conv, nn.ConvTranspose)):
if mode == 'GaussianFill':
init.gauss_(m.weight, std=0.001)
elif mode == 'MSRAFill':
MSRAFill(m.weight)
else:
raise ValueError
if m.bias is not None:
init.constant_(m.bias, 0)
if isinstance(m, nn.Linear):
XavierFill(m.weight)
init.constant_(m.bias, 0)
def _initialize_weights(self):
for m in self.modules():
if isinstance(m, Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
init.gauss_(m.weight, 0, (2. / n)**0.5)
if m.bias is not None:
init.constant_(m.bias, 0.0)
# elif isinstance(m, BatchNorm2d):
# m.weight.data.fill_(1)
# m.bias.data.zero_()
elif isinstance(m, nn.Linear):
n = m.weight.shape[1]
init.gauss_(m.weight, 0, 0.01)
init.constant_(m.bias, 0.0)
def __init__(self, cfg, in_channels):
super(FPNPredictor, self).__init__()
num_classes = cfg.MODEL.ROI_BOX_HEAD.NUM_CLASSES
representation_size = in_channels
self.cls_score = nn.Linear(representation_size, num_classes)
num_bbox_reg_classes = 2 if cfg.MODEL.CLS_AGNOSTIC_BBOX_REG else num_classes
self.bbox_pred = nn.Linear(representation_size,
num_bbox_reg_classes * 4)
init.gauss_(self.cls_score.weight, std=0.01)
init.gauss_(self.bbox_pred.weight, std=0.001)
for l in [self.cls_score, self.bbox_pred]:
init.constant_(l.bias, 0)
def __init__(self, cfg, in_channels):
"""
Arguments:
cfg : config
in_channels (int): number of channels of the input feature
"""
super(RPNHeadFeatureSingleConv, self).__init__()
self.conv = nn.Conv(
in_channels, in_channels, kernel_size=3, stride=1, padding=1
)
for l in [self.conv]:
init.gauss_(l.weight, std=0.01)
init.constant_(l.bias, 0)
self.out_channels = in_channels
def __init__(self, cfg, in_channels):
super(FPNXconv1fcFeatureExtractor, self).__init__()
resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION
scales = cfg.MODEL.ROI_BOX_HEAD.POOLER_SCALES
sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO
pooler = Pooler(
output_size=(resolution, resolution),
scales=scales,
sampling_ratio=sampling_ratio,
)
self.pooler = pooler
use_gn = cfg.MODEL.ROI_BOX_HEAD.USE_GN
conv_head_dim = cfg.MODEL.ROI_BOX_HEAD.CONV_HEAD_DIM
num_stacked_convs = cfg.MODEL.ROI_BOX_HEAD.NUM_STACKED_CONVS
dilation = cfg.MODEL.ROI_BOX_HEAD.DILATION
xconvs = []
for ix in range(num_stacked_convs):
xconvs.append(
nn.Conv(in_channels,
conv_head_dim,
kernel_size=3,
stride=1,
padding=dilation,
dilation=dilation,
bias=False if use_gn else True))
in_channels = conv_head_dim
if use_gn:
xconvs.append(group_norm(in_channels))
xconvs.append(nn.ReLU())
self.xconvs = nn.Sequential(*xconvs)
for modules in [
self.xconvs,
]:
for l in modules.modules():
if isinstance(l, nn.Conv):
init.gauss_(l.weight, std=0.01)
if not use_gn:
init.constant_(l.bias, 0)
input_size = conv_head_dim * resolution**2
representation_size = cfg.MODEL.ROI_BOX_HEAD.MLP_HEAD_DIM
self.fc6 = make_fc(input_size, representation_size, use_gn=False)
self.out_channels = representation_size
def __init__(self, config, in_channels):
super(FastRCNNPredictor, self).__init__()
assert in_channels is not None
num_inputs = in_channels
num_classes = config.MODEL.ROI_BOX_HEAD.NUM_CLASSES
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.cls_score = nn.Linear(num_inputs, num_classes)
num_bbox_reg_classes = 2 if config.MODEL.CLS_AGNOSTIC_BBOX_REG else num_classes
self.bbox_pred = nn.Linear(num_inputs, num_bbox_reg_classes * 4)
init.gauss_(self.cls_score.weight, mean=0, std=0.01)
init.constant_(self.cls_score.bias, 0)
init.gauss_(self.bbox_pred.weight, mean=0, std=0.001)
init.constant_(self.bbox_pred.bias, 0)
def __init__(self, in_channels, n_class, roi_size, spatial_scale,
sampling_ratio):
# n_class includes the background
super(RoIHead, self).__init__()
self.classifier = nn.Sequential(
nn.Linear(in_channels * roi_size * roi_size, 4096), nn.ReLU(),
nn.Linear(4096, 4096), nn.ReLU())
self.cls_loc = nn.Linear(4096, n_class * 4)
self.score = nn.Linear(4096, n_class)
self.n_class = n_class
self.roi_size = roi_size
self.spatial_scale = spatial_scale
self.roi = ROIAlign((self.roi_size, self.roi_size),
self.spatial_scale,
sampling_ratio=sampling_ratio)
init.gauss_(self.cls_loc.weight, 0, 0.001)
init.constant_(self.cls_loc.bias, 0)
init.gauss_(self.score.weight, 0, 0.01)
init.constant_(self.score.bias, 0)
def weights_init_normal(m):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
init.gauss_(m.weight, 0.0, 0.02)
init.gauss_(m.bias, 0.0, 0.02)
elif classname.find("BatchNorm") != -1:
init.gauss_(m.weight, 1.0, 0.02)
init.constant_(m.bias, 0.0)
def initialize_weights(net):
for m in net.modules():
if isinstance(m, nn.Conv):
init.gauss_(m.weight, 0, 0.02)
init.constant_(m.bias, 0)
elif isinstance(m, nn.ConvTranspose):
init.gauss_(m.weight, 0, 0.02)
init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
init.gauss_(m.weight, 0, 0.02)
init.constant_(m.bias, 0)
def _normal_init(self):
for var in [self.conv1, self.score, self.loc]:
init.gauss_(var.weight, 0, 0.01)
init.constant_(var.bias, 0.0)
def init_conv2d(self):
""" Initialize convolution parameters. """
for c in self.children():
if isinstance(c, nn.Conv):
init.gauss_(c.weight)
def weights_init_normal(m):
classname = m.__class__.__name__
if (classname.find('Conv') != (-1)):
init.gauss_(m.weight, mean=0.0, std=0.02)
def MSRAFill(tensor):
"""Caffe2 MSRAFill Implementation"""
size = reduce(operator.mul, tensor.shape, 1)
fan_out = size / tensor.shape[1]
scale = math.sqrt(2 / fan_out)
return init.gauss_(tensor, 0, scale)
def __init__(self,
layers,
cardinality=1,
base_width=64,
usefpn=False,
num_classes=None):
super(ResnetXtFPN, self).__init__()
self.cardinality = cardinality
self.base_width = base_width
self.usefpn = usefpn
self.num_classes = num_classes
self.conv1 = nn.Conv(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = _BN(64)
self.relu = nn.ReLU()
self.maxpool = nn.Pool(kernel_size=3,
stride=2,
padding=1,
op='maximum')
self.layer1 = self._make_layer(inplanes=64,
outplanes=256,
stride=1,
widen_factor=1,
blocks=layers[0])
self.layer2 = self._make_layer(inplanes=256,
outplanes=512,
stride=2,
widen_factor=2,
blocks=layers[1])
self.layer3 = self._make_layer(inplanes=512,
outplanes=1024,
stride=2,
widen_factor=3,
blocks=layers[2])
if len(layers) == 4:
self.layer4 = self._make_layer(inplanes=1024,
outplanes=2048,
stride=2,
widen_factor=4,
blocks=layers[3])
else:
self.layer4 = None
if usefpn:
# c1, c2, c3, c4 all conv to same channel
self.fpn_c4p4 = nn.Conv(2048,
256,
kernel_size=1,
stride=1,
padding=0)
self.fpn_c3p3 = nn.Conv(1024,
256,
kernel_size=1,
stride=1,
padding=0)
self.fpn_c2p2 = nn.Conv(512,
256,
kernel_size=1,
stride=1,
padding=0)
self.fpn_c1p1 = nn.Conv(256,
256,
kernel_size=1,
stride=1,
padding=0)
self.fpn_p4 = nn.Conv(256, 256, kernel_size=3, stride=1, padding=1)
self.fpn_p3 = nn.Conv(256, 256, kernel_size=3, stride=1, padding=1)
self.fpn_p2 = nn.Conv(256, 256, kernel_size=3, stride=1, padding=1)
self.fpn_p1 = nn.Conv(256, 256, kernel_size=3, stride=1, padding=1)
if (num_classes is not None) and (not usefpn):
self.avgpool = nn.Pool(7, stride=1, op='mean')
self.fc = nn.Linear(2048, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
init.gauss_(m.weight, 0, math.sqrt(2. / n))
elif isinstance(m, _BN):
init.constant_(m.weight, 1.0)
init.constant_(m.bias, 0.0)
