def init_weights(self, pretrained=None):
if isinstance(pretrained, str):
logger = logging.getLogger()
load_checkpoint(self, pretrained, strict=False, logger=logger)
elif pretrained is None:
for m in self.features.modules():
if isinstance(m, nn.Conv2d):
kaiming_init(m)
elif isinstance(m, nn.BatchNorm2d):
constant_init(m, 1)
else:
raise TypeError('pretrained must be a str or None')
for f in [
self.Norm1, self.Norm2, self.Norm3, self.Norm4, self.icn1,
self.icn2, self.icn3, self.dsc1, self.dsc2, self.dsc3,
self.agent1, self.agent2, self.agent3, self.proj1, self.proj2,
self.proj3, self.convert1, self.convert2, self.convert3,
self.merge1, self.merge2, self.merge3, self.ibn1, self.ibn2,
self.extra
]:
for m in f.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
elif isinstance(m, nn.BatchNorm2d):
constant_init(m, 1)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
if hasattr(self, 'attention') and self.attention is not None:
self.attention.init_weights()
def init_weights(self, pretrained=None):
"""Initialize the weights in backbone.
Args:
pretrained (str, optional): Path to pre-trained weights.
Defaults to None.
"""
if isinstance(pretrained, str):
logger = get_root_logger()
load_checkpoint(self, pretrained, strict=False, logger=logger)
elif pretrained is None:
for m in self.features.modules():
if isinstance(m, nn.Conv2d):
kaiming_init(m)
elif isinstance(m, nn.BatchNorm2d):
constant_init(m, 1)
elif isinstance(m, nn.Linear):
normal_init(m, std=0.01)
else:
raise TypeError('pretrained must be a str or None')
for m in self.extra.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
constant_init(self.l2_norm, self.l2_norm.scale)
def init_weights(self):
# initialize weight and bias
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m)
elif isinstance(m, nn.BatchNorm2d):
uniform_init(m)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
nn.init.constant_(self.conv_final[-1].bias, 0.0)
nn.init.constant_(self.atten_conv_final[-1].bias, 0.0)
self.atten.init_weights()
def init_weights(self):
for g in self.grabs:
g.init_weights()
self.grab_extra.init_weights()
for m in self.conv_extra.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
def init_weights(self):
for m in self.modules():
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
xavier_init(m, distribution='uniform')
for m in self.modules():
if isinstance(m, CARAFEPack):
m.init_weights()
def init_weights(self):
if self.num_lstms > 0:
for lstm_cell in self.lstm_cells:
lstm_cell.init_weights()
if self.num_extra_convs > 0:
for conv in self.extra_convs:
xavier_init(conv)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
normal_init(self.r_conv, std=0.01)
# normal_init(self.scale_conv_k_2, std=0.01)
# # normal_init(self.scale_conv_q_2, std=0.01)
# normal_init(self.scale_conv_v_2, std=0.01)
#
# normal_init(self.scale_conv_k_3, std=0.01)
# # normal_init(self.scale_conv_q_3, std=0.01)
# normal_init(self.scale_conv_v_3, std=0.01)
#
# normal_init(self.scale_conv_k_4, std=0.01)
# # normal_init(self.scale_conv_q_4, std=0.01)
# normal_init(self.scale_conv_v_4, std=0.01)
#
# normal_init(self.scale_conv_k_5, std=0.01)
# # normal_init(self.scale_conv_q_5, std=0.01)
# normal_init(self.scale_conv_v_5, std=0.01)
#
# normal_init(self.scale_conv_k_6, std=0.01)
# # normal_init(self.scale_conv_q_6, std=0.01)
# normal_init(self.scale_conv_v_6, std=0.01)
normal_init(self.batch_, std=0.01)
normal_init(self.batch_11, std=0.01)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
# normal_init(self.content_encoder, std=0.001)
kaiming_init(self.channel_compressor)
kaiming_init(self.content_encoder)
def init_method(m):
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform', bias=0)
elif isinstance(m, nn.ConvTranspose2d):
xavier_init(m, distribution='uniform', bias=0)
elif isinstance(m, nn.BatchNorm2d):
constant_init(m, 1)
def init_weights(self):
normal_init(self.fc_cls, std=0.01)
normal_init(self.fc_reg, std=0.001)
for m in self.fc_branch.modules():
if isinstance(m, nn.Linear):
xavier_init(m, distribution='uniform')
def init_weights(self):
if self.num_rnns > 0:
for rnn_cell in self.rnn_cells:
rnn_cell.init_weights()
if self.num_extra_convs > 0:
for conv in self.extra_convs:
xavier_init(conv)
def init_weights(self):
#if isinstance(pretrained, str):
# logger = logging.getLogger()
# load_checkpoint(self, pretrained, strict=False, logger=logger)
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform', bias=0)
def init_weights(self):
"""Initialize weights of the bbox head."""
for m in self.modules():
if isinstance(m, (nn.Conv2d, nn.Conv1d)):
xavier_init(m, distribution='uniform')
normal_init(self.conv_reg[-1].conv, mean=0, std=0.001)
def init_func(m):
"""Initialization function.
Args:
m (nn.Module): Module to be initialized.
"""
classname = m.__class__.__name__
if hasattr(m, 'weight') and (classname.find('Conv') != -1
or classname.find('Linear') != -1):
if init_type == 'normal':
normal_init(m, 0.0, init_gain)
elif init_type == 'xavier':
xavier_init(m, gain=init_gain, distribution='normal')
elif init_type == 'kaiming':
kaiming_init(m,
a=0,
mode='fan_in',
nonlinearity='leaky_relu',
distribution='normal')
elif init_type == 'orthogonal':
init.orthogonal_(m.weight, gain=init_gain)
init.constant_(m.bias.data, 0.0)
else:
raise NotImplementedError(
f"Initialization method '{init_type}' is not implemented")
elif classname.find('BatchNorm2d') != -1:
# BatchNorm Layer's weight is not a matrix;
# only normal distribution applies.
normal_init(m, 1.0, init_gain)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
for m in self.high_lateral_conv_attention.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
def init_weights(self, pretrained=None):
if isinstance(pretrained, str):
#self.encoder.conv1.weight.data[:, 3:, :, :] = 0
logger = get_root_logger()
load_checkpoint(self, pretrained, strict=False, logger=logger)
if (self.in_channels) > 3:
print(
f'modifying input layer to accept {self.in_channels} channels'
)
net_encoder_sd = self.encoder.state_dict()
conv1_weights = net_encoder_sd['conv1.weight']
c_out, c_in, h, w = conv1_weights.size()
conv1_mod = torch.zeros(c_out, self.in_channels, h, w)
conv1_mod[:, :3, :, :] = conv1_weights
conv1 = self.encoder.conv1
conv1.in_channels = self.in_channels
conv1.weight = torch.nn.Parameter(conv1_mod)
self.encoder.conv1 = conv1
net_encoder_sd['conv1.weight'] = conv1_mod
self.encoder.load_state_dict(net_encoder_sd)
elif pretrained is None:
if (self.in_channels) > 3:
print(
f'modifying input layer to accept {self.in_channels} channels'
)
net_encoder_sd = self.encoder.state_dict()
conv1_weights = net_encoder_sd['conv1.weight']
c_out, c_in, h, w = conv1_weights.size()
conv1_mod = torch.zeros(c_out, self.in_channels, h, w)
conv1_mod[:, :3, :, :] = conv1_weights
conv1 = self.encoder.conv1
conv1.in_channels = self.in_channels
conv1.weight = torch.nn.Parameter(conv1_mod)
self.encoder.conv1 = conv1
net_encoder_sd['conv1.weight'] = conv1_mod
self.encoder.load_state_dict(net_encoder_sd)
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m)
elif isinstance(m, nn.BatchNorm2d):
constant_init(m, 1)
else:
raise TypeError(f'"pretrained" must be a str or None.'
f'But received {type(pretrained)}')
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m)
elif isinstance(m, nn.BatchNorm2d):
constant_init(m, 1)
elif isinstance(m, nn.Linear):
normal_init(m, std=0.01)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
for m in self.modules():
if isinstance(m, ModulatedDeformConvPack):
constant_init(m.conv_offset, 0)
def init_weights(self):
"""Initialize model weights."""
for m in self.conv_blocks:
if isinstance(m, nn.Conv2d):
normal_init(m, std=0.001, bias=0)
for m in self.fc_layer.named_modules():
if isinstance(m, nn.Linear):
xavier_init(m, gain=0.01)
def init_weights(self):
"""Initialize the weights of FPN module."""
for m in self.modules():
if isinstance(m, nn.Conv2d):
if self.init_type == 'uniform':
xavier_init(m, distribution='uniform')
elif self.init_type == 'normal':
xavier_init(m, distribution='normal')
def init_weights(self):
# conv layers are already initialized by ConvModule
normal_init(self.fc_cls, std=0.01)
normal_init(self.fc_reg, std=0.001)
for m in self.fc_branch.modules():
if isinstance(m, nn.Linear):
xavier_init(m, distribution='uniform')
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
for m in [self.proto_logits, self.segm_logits]:
nn.init.kaiming_normal_(
m.weight, mode='fan_out', nonlinearity='relu')
nn.init.constant_(m.bias, 0)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Linear):
normal_init(m, std=0.01)
if isinstance(m, nn.Conv3d):
xavier_init(m, distribution='uniform')
if isinstance(m, nn.BatchNorm3d):
constant_init(m, 1)
def init_weights(self):
"""Initialize the weights of module."""
for m in self.modules():
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
xavier_init(m, distribution='uniform')
for m in self.modules():
if isinstance(m, CARAFE_se_3):
m.init_weights()
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
for _, m in self.deconv_layers.named_modules():
if isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
xavier_init(m, distribution='uniform')
if self.use_skip:
nn.init.constant_(self.conv_final[-1].bias, 0.0)
else:
nn.init.constant_(self.conv_final[-1].bias[0], 1.0)
nn.init.constant_(self.conv_final[-1].bias[1], 0.0)
def init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv3d):
xavier_init(m, distribution='uniform')
if isinstance(m, nn.BatchNorm3d):
constant_init(m, 1)
if self.aux_head is not None:
self.aux_head.init_weights()