def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
"""Make deconv layers."""
if num_layers != len(num_filters):
error_msg = f'num_layers({num_layers}) ' \
f'!= length of num_filters({len(num_filters)})'
raise ValueError(error_msg)
if num_layers != len(num_kernels):
error_msg = f'num_layers({num_layers}) ' \
f'!= length of num_kernels({len(num_kernels)})'
raise ValueError(error_msg)
layers = []
for i in range(num_layers):
kernel, padding, output_padding = \
self._get_deconv_cfg(num_kernels[i])
planes = num_filters[i]
layers.append(
build_upsample_layer(dict(type='deconv'),
in_channels=self.in_channels,
out_channels=planes,
kernel_size=kernel,
stride=2,
padding=padding,
output_padding=output_padding,
bias=False))
layers.append(nn.BatchNorm2d(planes))
layers.append(nn.ReLU(inplace=True))
self.in_channels = planes
return nn.Sequential(*layers)
def __init__(self,
in_filters,
out_filters,
conv_cfg,
norm_cfg,
upsample_cfg,
up_output_padding=0):
super(UpBlock, self).__init__()
# self.drop_out = drop_out
self.trans_conv = conv3x3(in_filters, out_filters, conv_cfg)
self.trans_bn = build_norm_layer(norm_cfg, out_filters)[1]
self.trans_act = nn.ReLU(inplace=True)
self.conv0 = conv1x3(out_filters, out_filters, conv_cfg)
self.bn0 = build_norm_layer(norm_cfg, out_filters)[1]
self.act0 = nn.ReLU(inplace=True)
self.conv1 = conv3x1(out_filters, out_filters, conv_cfg)
self.bn1 = build_norm_layer(norm_cfg, out_filters)[1]
self.act1 = nn.ReLU(inplace=True)
self.conv2 = conv3x3(out_filters, out_filters, conv_cfg)
self.bn2 = build_norm_layer(norm_cfg, out_filters)[1]
self.act2 = nn.ReLU(inplace=True)
self.up_conv = build_upsample_layer(upsample_cfg,
in_channels=out_filters,
out_channels=out_filters,
kernel_size=2,
stride=2,
padding=0,
output_padding=up_output_padding)
def _make_deconv_layers(self, in_channels, deconv_layer_output_channels,
num_deconv_layers, num_deconv_filters,
num_deconv_kernels, num_basic_blocks, cat_output):
deconv_layers = []
for i in range(num_deconv_layers):
if cat_output[i]:
in_channels += deconv_layer_output_channels[i]
planes = num_deconv_filters[i]
deconv_kernel, padding, output_padding = \
self._get_deconv_cfg(num_deconv_kernels[i])
layers = []
layers.append(
nn.Sequential(
build_upsample_layer(
dict(type='deconv'),
in_channels=in_channels,
out_channels=planes,
kernel_size=deconv_kernel,
stride=2,
padding=padding,
output_padding=output_padding,
bias=False), nn.BatchNorm2d(planes, momentum=0.1),
nn.ReLU(inplace=True)))
for _ in range(num_basic_blocks):
layers.append(nn.Sequential(BasicBlock(planes, planes), ))
deconv_layers.append(nn.Sequential(*layers))
in_channels = planes
return nn.ModuleList(deconv_layers)
def test_build_upsample_layer():
layer1 = nn.ConvTranspose2d(
in_channels=3,
out_channels=10,
kernel_size=3,
stride=2,
padding=1,
output_padding=1,
bias=False)
layer2 = build_upsample_layer(
dict(type='deconv'),
in_channels=3,
out_channels=10,
kernel_size=3,
stride=2,
padding=1,
output_padding=1,
bias=False)
layer2.load_state_dict(layer1.state_dict())
input_shape = (1, 3, 32, 32)
inputs = _demo_inputs(input_shape)
out1 = layer1(inputs)
out2 = layer2(inputs)
assert torch.equal(out1, out2)
def __init__(self,
in_channels=[128, 128, 256],
out_channels=[256, 256, 256],
upsample_strides=[1, 2, 4],
norm_cfg=dict(type='BN', eps=1e-3, momentum=0.01),
upsample_cfg=dict(type='deconv', bias=False)):
# if for GroupNorm,
# cfg is dict(type='GN', num_groups=num_groups, eps=1e-3, affine=True)
super(SECONDFPN, self).__init__()
assert len(out_channels) == len(upsample_strides) == len(in_channels)
self.in_channels = in_channels
self.out_channels = out_channels
deblocks = []
for i, out_channel in enumerate(out_channels):
upsample_layer = build_upsample_layer(
upsample_cfg,
in_channels=in_channels[i],
out_channels=out_channel,
kernel_size=upsample_strides[i],
stride=upsample_strides[i])
deblock = nn.Sequential(upsample_layer,
build_norm_layer(norm_cfg, out_channel)[1],
nn.ReLU(inplace=True))
deblocks.append(deblock)
self.deblocks = nn.ModuleList(deblocks)
def __init__(self,
in_channels=[128, 128, 256],
out_channels=[256, 256, 256],
upsample_strides=[1, 2, 4],
norm_cfg=dict(type='BN', eps=1e-3, momentum=0.01),
upsample_cfg=dict(type='deconv', bias=False),
conv_cfg=dict(type='Conv2d', bias=False),
use_conv_for_no_stride=False):
# if for GroupNorm,
# cfg is dict(type='GN', num_groups=num_groups, eps=1e-3, affine=True)
super(SECONDFPNMASK, self).__init__()
assert len(out_channels) == len(upsample_strides) == len(in_channels)
self.in_channels = in_channels
self.out_channels = out_channels
self.fp16_enabled = False
deblocks = []
channel_blocks = []
for i, out_channel in enumerate(out_channels):
stride = upsample_strides[i]
if stride > 1 or (stride == 1 and not use_conv_for_no_stride):
upsample_layer = build_upsample_layer(
upsample_cfg,
in_channels=in_channels[i],
out_channels=out_channel,
kernel_size=upsample_strides[i],
stride=upsample_strides[i])
else:
stride = np.round(1 / stride).astype(np.int64)
upsample_layer = build_conv_layer(
conv_cfg,
in_channels=in_channels[i],
out_channels=out_channel,
kernel_size=stride,
stride=stride)
deblock = nn.Sequential(upsample_layer,
build_norm_layer(norm_cfg, out_channel)[1],
nn.ReLU(inplace=True))
deblocks.append(deblock)
conv_1 = build_conv_layer(conv_cfg, in_channels=out_channel, out_channels=out_channel,
kernel_size=1, stride=1)
self.deblocks = nn.ModuleList(deblocks)
self.binary_cls = nn.Sequential(
build_conv_layer(conv_cfg, sum(out_channels), out_channels[0], 3, padding=1),
build_norm_layer(norm_cfg, out_channels[0])[1],
nn.ReLU(inplace=True),
build_conv_layer(conv_cfg, out_channels[0], out_channels[0], 1, 1),
build_norm_layer(norm_cfg, out_channels[0])[1],
nn.ReLU(inplace=True),
build_conv_layer(conv_cfg, out_channels[0], 1, 1),
nn.Sigmoid()
)
def __init__(self,
conv_block,
in_channels,
skip_channels,
out_channels,
num_convs=2,
stride=1,
dilation=1,
with_cp=False,
conv_cfg=None,
norm_cfg=dict(type='BN'),
act_cfg=dict(type='ReLU'),
upsample_cfg=dict(type='InterpConv'),
dcn=None,
plugins=None):
super(UpConvBlock, self).__init__()
assert dcn is None, 'Not implemented yet.'
assert plugins is None, 'Not implemented yet.'
self.conv_block = conv_block(in_channels=2 * skip_channels,
out_channels=out_channels,
num_convs=num_convs,
stride=stride,
dilation=dilation,
with_cp=with_cp,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=act_cfg,
dcn=None,
plugins=None)
if upsample_cfg is not None:
self.upsample = build_upsample_layer(cfg=upsample_cfg,
in_channels=in_channels,
out_channels=skip_channels,
with_cp=with_cp,
norm_cfg=norm_cfg,
act_cfg=act_cfg)
else:
self.upsample = ConvModule(in_channels,
skip_channels,
kernel_size=1,
stride=1,
padding=0,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg,
act_cfg=act_cfg)
def __init__(self,
semantic_in_channel=256,
semantic_out_channel=256,
instance_in_channel=256,
instance_out_channel=256,
dilations=[1, 3, 5],
out_size=14,
num_classes=80,
semantic_out_stride=4,
mask_use_sigmoid=False,
upsample_cfg=dict(type='bilinear', scale_factor=2)):
super(SFMStage, self).__init__()
self.semantic_out_stride = semantic_out_stride
self.mask_use_sigmoid = mask_use_sigmoid
self.num_classes = num_classes
# for extracting instance-wise semantic feats
self.semantic_transform_in = nn.Conv2d(semantic_in_channel,
semantic_out_channel, 1)
self.semantic_roi_extractor = build_roi_extractor(
dict(type='SingleRoIExtractor',
roi_layer=dict(type='RoIAlign',
output_size=out_size,
sampling_ratio=0),
out_channels=semantic_out_channel,
featmap_strides=[
semantic_out_stride,
]))
self.semantic_transform_out = nn.Conv2d(semantic_out_channel,
semantic_out_channel, 1)
self.instance_logits = nn.Conv2d(instance_in_channel, num_classes, 1)
fuse_in_channel = instance_in_channel + semantic_out_channel + 2
self.fuse_conv = nn.ModuleList([
nn.Conv2d(fuse_in_channel, instance_in_channel, 1),
MultiBranchFusion(instance_in_channel, dilations=dilations)
])
self.fuse_transform_out = nn.Conv2d(instance_in_channel,
instance_out_channel - 2, 1)
self.upsample = build_upsample_layer(upsample_cfg.copy())
self.relu = nn.ReLU(inplace=True)
self._init_weights()
def __init__(self,
in_channels=[128, 128, 256],
out_channels=[256, 256, 256],
upsample_strides=[1, 2, 4],
norm_cfg=dict(type='BN', eps=1e-3, momentum=0.01),
upsample_cfg=dict(type='deconv', bias=False),
conv_cfg=dict(type='Conv2d', bias=False),
use_conv_for_no_stride=False,
init_cfg=None):
# if for GroupNorm,
# cfg is dict(type='GN', num_groups=num_groups, eps=1e-3, affine=True)
super(SECONDFPN, self).__init__(init_cfg=init_cfg)
assert len(out_channels) == len(upsample_strides) == len(in_channels)
self.in_channels = in_channels
self.out_channels = out_channels
self.fp16_enabled = False
deblocks = []
for i, out_channel in enumerate(out_channels):
stride = upsample_strides[i]
if stride > 1 or (stride == 1 and not use_conv_for_no_stride):
upsample_layer = build_upsample_layer(
upsample_cfg,
in_channels=in_channels[i],
out_channels=out_channel,
kernel_size=upsample_strides[i],
stride=upsample_strides[i])
else:
stride = np.round(1 / stride).astype(np.int64)
upsample_layer = build_conv_layer(conv_cfg,
in_channels=in_channels[i],
out_channels=out_channel,
kernel_size=stride,
stride=stride)
deblock = nn.Sequential(upsample_layer,
build_norm_layer(norm_cfg, out_channel)[1],
nn.ReLU(inplace=True))
deblocks.append(deblock)
self.deblocks = nn.ModuleList(deblocks)
if init_cfg is None:
self.init_cfg = [
dict(type='Kaiming', layer='ConvTranspose2d'),
dict(type='Constant', layer='NaiveSyncBatchNorm2d', val=1.0)
]
def __init__(self,
hidden_dim,
input_dim,
simi_dim=None,
conv_cfg=dict(type='Conv2d'),
norm_cfg=dict(type='BN1d', eps=1e-3, momentum=0.01),
upsample_cfg=dict(type='deconv', bias=False),
upsample_stride=2,
need_offset=True):
super(UpdateBlock, self).__init__()
self.upsample_stride = upsample_stride
self.need_offset = need_offset
self.encoder = MotionEncoder(simi_dim,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg)
self.gru = ConvGRU(hidden_dim=hidden_dim,
input_dim=128 + hidden_dim,
conv_cfg=conv_cfg)
stride = upsample_stride
if stride > 1:
upsample_layer = build_upsample_layer(upsample_cfg,
in_channels=hidden_dim,
out_channels=hidden_dim,
kernel_size=upsample_stride,
stride=upsample_stride)
else:
stride = np.round(1 / stride).astype(np.int64)
upsample_layer = build_conv_layer(conv_cfg,
in_channels=hidden_dim,
out_channels=hidden_dim,
kernel_size=stride,
stride=stride)
self.upsample = nn.Sequential(upsample_layer, nn.ReLU(inplace=True))
if self.need_offset:
self.offset_head = OffsetHead(hidden_dim, conv_cfg=conv_cfg)
def __init__(self,
in_channels,
out_channels,
num_outs,
start_level=0,
end_level=-1,
norm_cfg=None,
act_cfg=None,
order=('conv', 'norm', 'act'),
upsample_cfg=dict(type='carafe',
up_kernel=5,
up_group=1,
encoder_kernel=3,
encoder_dilation=1)):
super(FPN_CARAFE, self).__init__()
assert isinstance(in_channels, list)
self.in_channels = in_channels
self.out_channels = out_channels
self.num_ins = len(in_channels)
self.num_outs = num_outs
self.norm_cfg = norm_cfg
self.act_cfg = act_cfg
self.with_bias = norm_cfg is None
self.upsample_cfg = upsample_cfg.copy()
self.upsample = self.upsample_cfg.get('type')
self.relu = nn.ReLU(inplace=False)
self.order = order
assert order in [('conv', 'norm', 'act'), ('act', 'conv', 'norm')]
assert self.upsample in [
'nearest', 'bilinear', 'deconv', 'pixel_shuffle', 'carafe', None
]
if self.upsample in ['deconv', 'pixel_shuffle']:
assert hasattr(
self.upsample_cfg,
'upsample_kernel') and self.upsample_cfg.upsample_kernel > 0
self.upsample_kernel = self.upsample_cfg.pop('upsample_kernel')
if end_level == -1:
self.backbone_end_level = self.num_ins
assert num_outs >= self.num_ins - start_level
else:
# if end_level < inputs, no extra level is allowed
self.backbone_end_level = end_level
assert end_level <= len(in_channels)
assert num_outs == end_level - start_level
self.start_level = start_level
self.end_level = end_level
self.lateral_convs = nn.ModuleList()
self.fpn_convs = nn.ModuleList()
self.upsample_modules = nn.ModuleList()
for i in range(self.start_level, self.backbone_end_level):
l_conv = ConvModule(in_channels[i],
out_channels,
1,
norm_cfg=norm_cfg,
bias=self.with_bias,
act_cfg=act_cfg,
inplace=False,
order=self.order)
fpn_conv = ConvModule(out_channels,
out_channels,
3,
padding=1,
norm_cfg=self.norm_cfg,
bias=self.with_bias,
act_cfg=act_cfg,
inplace=False,
order=self.order)
if i != self.backbone_end_level - 1:
upsample_cfg_ = self.upsample_cfg.copy()
if self.upsample == 'deconv':
upsample_cfg_.update(
in_channels=out_channels,
out_channels=out_channels,
kernel_size=self.upsample_kernel,
stride=2,
padding=(self.upsample_kernel - 1) // 2,
output_padding=(self.upsample_kernel - 1) // 2)
elif self.upsample == 'pixel_shuffle':
upsample_cfg_.update(in_channels=out_channels,
out_channels=out_channels,
scale_factor=2,
upsample_kernel=self.upsample_kernel)
elif self.upsample == 'carafe':
upsample_cfg_.update(channels=out_channels, scale_factor=2)
else:
# suppress warnings
align_corners = (None
if self.upsample == 'nearest' else False)
upsample_cfg_.update(scale_factor=2,
mode=self.upsample,
align_corners=align_corners)
upsample_module = build_upsample_layer(upsample_cfg_)
self.upsample_modules.append(upsample_module)
self.lateral_convs.append(l_conv)
self.fpn_convs.append(fpn_conv)
# add extra conv layers (e.g., RetinaNet)
extra_out_levels = (num_outs - self.backbone_end_level +
self.start_level)
if extra_out_levels >= 1:
for i in range(extra_out_levels):
in_channels = (self.in_channels[self.backbone_end_level -
1] if i == 0 else out_channels)
extra_l_conv = ConvModule(in_channels,
out_channels,
3,
stride=2,
padding=1,
norm_cfg=norm_cfg,
bias=self.with_bias,
act_cfg=act_cfg,
inplace=False,
order=self.order)
if self.upsample == 'deconv':
upsampler_cfg_ = dict(
in_channels=out_channels,
out_channels=out_channels,
kernel_size=self.upsample_kernel,
stride=2,
padding=(self.upsample_kernel - 1) // 2,
output_padding=(self.upsample_kernel - 1) // 2)
elif self.upsample == 'pixel_shuffle':
upsampler_cfg_ = dict(in_channels=out_channels,
out_channels=out_channels,
scale_factor=2,
upsample_kernel=self.upsample_kernel)
elif self.upsample == 'carafe':
upsampler_cfg_ = dict(channels=out_channels,
scale_factor=2,
**self.upsample_cfg)
else:
# suppress warnings
align_corners = (None
if self.upsample == 'nearest' else False)
upsampler_cfg_ = dict(scale_factor=2,
mode=self.upsample,
align_corners=align_corners)
upsampler_cfg_['type'] = self.upsample
upsample_module = build_upsample_layer(upsampler_cfg_)
extra_fpn_conv = ConvModule(out_channels,
out_channels,
3,
padding=1,
norm_cfg=self.norm_cfg,
bias=self.with_bias,
act_cfg=act_cfg,
inplace=False,
order=self.order)
self.upsample_modules.append(upsample_module)
self.fpn_convs.append(extra_fpn_conv)
self.lateral_convs.append(extra_l_conv)
def __init__(self,
num_convs=8,
roi_feat_size=28,
in_channels=256,
conv_kernel_size=3,
conv_out_channels=256,
num_keypoints=17,
heatmap_size=56,
upsample_cfg=dict(type='deconv', scale_factor=2),
up_scale=2,
conv_cfg=None,
norm_cfg=None,
loss_keypoint=dict(type='CrossEntropyLoss',
use_mask=True,
loss_weight=1.0)):
super(FCNKeypointHead, self).__init__()
self.upsample_cfg = upsample_cfg.copy()
if self.upsample_cfg['type'] not in [
None, 'deconv', 'nearest', 'bilinear', 'carafe'
]:
raise ValueError(
'Invalid upsample method {}, accepted methods '
'are "deconv", "nearest", "bilinear", "carafe"'.format(
self.upsample_cfg['type']))
self.num_convs = num_convs
# WARN: roi_feat_size is reserved and not used
self.roi_feat_size = _pair(roi_feat_size)
self.in_channels = in_channels
self.conv_kernel_size = conv_kernel_size
self.conv_out_channels = conv_out_channels
self.upsample_method = self.upsample_cfg.get('type')
self.scale_factor = self.upsample_cfg.pop('scale_factor')
self.num_keypoints = num_keypoints
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.fp16_enabled = False
#self.loss_keypoint = build_loss(loss_keypoint)
self.convs = nn.ModuleList()
for i in range(self.num_convs):
in_channels = (self.in_channels
if i == 0 else self.conv_out_channels)
padding = (self.conv_kernel_size - 1) // 2
self.convs.append(
ConvModule(in_channels,
self.conv_out_channels,
self.conv_kernel_size,
padding=padding,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg))
upsample_in_channels = (self.conv_out_channels
if self.num_convs > 0 else in_channels)
upsample_cfg_ = self.upsample_cfg.copy()
upsample_cfg_.update(in_channels=upsample_in_channels,
out_channels=num_keypoints,
kernel_size=self.scale_factor * 2,
stride=self.scale_factor,
padding=1)
#self.conv_logits = nn.Conv2d(self.conv_out_channels, num_keypoints, 1)
self.upsample = build_upsample_layer(upsample_cfg_)
#self.relu = nn.ReLU(inplace=True)
self.up_scale = up_scale
def __init__(self,
num_convs=4,
roi_feat_size=14,
in_channels=256,
conv_kernel_size=3,
conv_out_channels=256,
num_classes=80,
class_agnostic=False,
upsample_cfg=dict(type='deconv', scale_factor=2),
conv_cfg=None,
norm_cfg=None,
predictor_cfg=dict(type='Conv'),
loss_mask=dict(type='CrossEntropyLoss',
use_mask=True,
loss_weight=1.0),
init_cfg=None):
assert init_cfg is None, 'To prevent abnormal initialization ' \
'behavior, init_cfg is not allowed to be set'
super(FCNMaskHead, self).__init__(init_cfg)
self.upsample_cfg = upsample_cfg.copy()
if self.upsample_cfg['type'] not in [
None, 'deconv', 'nearest', 'bilinear', 'carafe'
]:
raise ValueError(
f'Invalid upsample method {self.upsample_cfg["type"]}, '
'accepted methods are "deconv", "nearest", "bilinear", '
'"carafe"')
self.num_convs = num_convs
# WARN: roi_feat_size is reserved and not used
self.roi_feat_size = _pair(roi_feat_size)
self.in_channels = in_channels
self.conv_kernel_size = conv_kernel_size
self.conv_out_channels = conv_out_channels
self.upsample_method = self.upsample_cfg.get('type')
self.scale_factor = self.upsample_cfg.pop('scale_factor', None)
self.num_classes = num_classes
self.class_agnostic = class_agnostic
self.conv_cfg = conv_cfg
self.norm_cfg = norm_cfg
self.predictor_cfg = predictor_cfg
self.fp16_enabled = False
self.loss_mask = build_loss(loss_mask)
self.convs = ModuleList()
for i in range(self.num_convs):
in_channels = (self.in_channels
if i == 0 else self.conv_out_channels)
padding = (self.conv_kernel_size - 1) // 2
self.convs.append(
ConvModule(in_channels,
self.conv_out_channels,
self.conv_kernel_size,
padding=padding,
conv_cfg=conv_cfg,
norm_cfg=norm_cfg))
upsample_in_channels = (self.conv_out_channels
if self.num_convs > 0 else in_channels)
upsample_cfg_ = self.upsample_cfg.copy()
if self.upsample_method is None:
self.upsample = None
elif self.upsample_method == 'deconv':
upsample_cfg_.update(in_channels=upsample_in_channels,
out_channels=self.conv_out_channels,
kernel_size=self.scale_factor,
stride=self.scale_factor)
self.upsample = build_upsample_layer(upsample_cfg_)
elif self.upsample_method == 'carafe':
upsample_cfg_.update(channels=upsample_in_channels,
scale_factor=self.scale_factor)
self.upsample = build_upsample_layer(upsample_cfg_)
else:
# suppress warnings
align_corners = (None
if self.upsample_method == 'nearest' else False)
upsample_cfg_.update(scale_factor=self.scale_factor,
mode=self.upsample_method,
align_corners=align_corners)
self.upsample = build_upsample_layer(upsample_cfg_)
out_channels = 1 if self.class_agnostic else self.num_classes
logits_in_channel = (self.conv_out_channels if self.upsample_method
== 'deconv' else upsample_in_channels)
self.conv_logits = build_conv_layer(self.predictor_cfg,
logits_in_channel, out_channels, 1)
self.relu = nn.ReLU(inplace=True)
self.debug_imgs = None
def __init__(self,
in_channels,
out_channels,
hidden_channels=None,
num_classes=0,
use_cbn=True,
use_norm_affine=False,
act_cfg=dict(type='ReLU'),
norm_cfg=dict(type='BN'),
upsample_cfg=dict(type='nearest', scale_factor=2),
upsample=True,
auto_sync_bn=True,
conv_cfg=None,
with_spectral_norm=False,
with_embedding_spectral_norm=None,
sn_style='torch',
norm_eps=1e-4,
sn_eps=1e-12,
init_cfg=dict(type='BigGAN')):
super().__init__()
self.learnable_sc = in_channels != out_channels or upsample
self.with_upsample = upsample
self.init_type = init_cfg.get('type', None)
self.activate = build_activation_layer(act_cfg)
hidden_channels = out_channels if hidden_channels is None \
else hidden_channels
if self.with_upsample:
self.upsample = build_upsample_layer(upsample_cfg)
self.conv_cfg = deepcopy(self._default_conv_cfg)
if conv_cfg is not None:
self.conv_cfg.update(conv_cfg)
# set `norm_spectral_norm` as `with_spectral_norm` if not defined
with_embedding_spectral_norm = with_embedding_spectral_norm \
if with_embedding_spectral_norm is not None else with_spectral_norm
sn_cfg = dict(eps=sn_eps, sn_style=sn_style)
self.conv_1 = SNConvModule(
in_channels,
hidden_channels,
with_spectral_norm=with_spectral_norm,
spectral_norm_cfg=sn_cfg,
**self.conv_cfg)
self.conv_2 = SNConvModule(
hidden_channels,
out_channels,
with_spectral_norm=with_spectral_norm,
spectral_norm_cfg=sn_cfg,
**self.conv_cfg)
self.norm_1 = SNConditionNorm(in_channels, num_classes, use_cbn,
norm_cfg, use_norm_affine, auto_sync_bn,
with_embedding_spectral_norm, sn_style,
norm_eps, sn_eps, init_cfg)
self.norm_2 = SNConditionNorm(hidden_channels, num_classes, use_cbn,
norm_cfg, use_norm_affine, auto_sync_bn,
with_embedding_spectral_norm, sn_style,
norm_eps, sn_eps, init_cfg)
if self.learnable_sc:
# use hyperparameters-fixed shortcut here
self.shortcut = SNConvModule(
in_channels,
out_channels,
kernel_size=1,
stride=1,
padding=0,
act_cfg=None,
with_spectral_norm=with_spectral_norm,
spectral_norm_cfg=sn_cfg)
self.init_weights()
