def __init__(self, block, depth, cardinality, base_width, num_classes):
super(CifarResNeXt, self).__init__()
# Model type specifies number of layers for CIFAR-10 and CIFAR-100 model
assert (depth - 2) % 9 == 0, 'depth should be one of 29, 38, 47, 56, 101'
self.layer_blocks = (depth - 2) // 9
self.cardinality,self.base_width,self.num_classes,self.block = cardinality,base_width,num_classes,block
self.conv_1_3x3 = nn.Conv2d(3, 64, 3, 1, 1, bias=False)
self.bn_1 = nn.BatchNorm2d(64)
self.inplanes = 64
self.stage_1 = self._make_layer(64 , 1)
self.stage_2 = self._make_layer(128, 2)
self.stage_3 = self._make_layer(256, 2)
self.avgpool = nn.AdaptiveAvgPool2d((1,1))
self.classifier = nn.Linear(256*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_()
elif isinstance(m, nn.Linear):
init.kaiming_normal(m.weight)
m.bias.data.zero_()
def __init__(self, cardinality, depth, num_classes, widen_factor=4, dropRate=0):
""" Constructor
Args:
cardinality: number of convolution groups.
depth: number of layers.
num_classes: number of classes
widen_factor: factor to adjust the channel dimensionality
"""
super(CifarResNeXt, self).__init__()
self.cardinality = cardinality
self.depth = depth
self.block_depth = (self.depth - 2) // 9
self.widen_factor = widen_factor
self.num_classes = num_classes
self.output_size = 64
self.stages = [64, 64 * self.widen_factor, 128 * self.widen_factor, 256 * self.widen_factor]
self.conv_1_3x3 = nn.Conv2d(3, 64, 3, 1, 1, bias=False)
self.bn_1 = nn.BatchNorm2d(64)
self.stage_1 = self.block('stage_1', self.stages[0], self.stages[1], 1)
self.stage_2 = self.block('stage_2', self.stages[1], self.stages[2], 2)
self.stage_3 = self.block('stage_3', self.stages[2], self.stages[3], 2)
self.classifier = nn.Linear(1024, num_classes)
init.kaiming_normal(self.classifier.weight)
for key in self.state_dict():
if key.split('.')[-1] == 'weight':
if 'conv' in key:
init.kaiming_normal(self.state_dict()[key], mode='fan_out')
if 'bn' in key:
self.state_dict()[key][...] = 1
elif key.split('.')[-1] == 'bias':
self.state_dict()[key][...] = 0
def weights_init(m):
for key in m.state_dict():
if key.split('.')[-1] == 'weight':
if 'conv' in key:
init.kaiming_normal(m.state_dict()[key], mode='fan_out')
if 'bn' in key:
m.state_dict()[key][...] = 1
elif key.split('.')[-1] == 'bias':
m.state_dict()[key][...] = 0
def weights_init_kaiming(m):
classname = m.__class__.__name__
# print(classname)
if classname.find('Conv') != -1:
init.kaiming_normal(m.weight.data, a=0, mode='fan_in')
elif classname.find('Linear') != -1:
init.kaiming_normal(m.weight.data, a=0, mode='fan_in')
elif classname.find('BatchNorm2d') != -1:
init.normal(m.weight.data, 1.0, 0.02)
init.constant(m.bias.data, 0.0)
def linear(channel_in, channel_out,
activation=nn.LeakyReLU,
normalizer=nn.BatchNorm1d):
layer = list()
bias = True if not normalizer else False
layer.append(nn.Linear(channel_in, channel_out, bias=bias))
_apply(layer, activation, normalizer, channel_out)
init.kaiming_normal(layer[0].weight)
return nn.Sequential(*layer)
def __init__(self, depth, pretrained=True, cut_at_pooling=False,
num_features=0, norm=False, dropout=0, num_classes=0,
num_diff_features=0, iden_pretrain = False,
model_path='/media/hh/disc_d/hh/open-reid-master/pretrained model/resnet50.pth'):
super(ResNet, self).__init__()
self.depth = depth
self.pretrained = pretrained
self.cut_at_pooling = cut_at_pooling
self.iden_pretrain = iden_pretrain
# Construct base (pretrained) resnet
if depth not in ResNet.__factory:
raise KeyError("Unsupported depth:", depth)
# self.base = ResNet.__factory[depth](pretrained=pretrained)
self.base = baseresnet.ResNet(baseresnet.Bottleneck, [3, 4, 6, 3])
if pretrained is True:
self.base.load_state_dict(torch.load(model_path))
self.relu = nn.ReLU(inplace=True)
if not self.cut_at_pooling:
self.num_features = num_features
self.num_diff_features = num_diff_features
self.norm = norm
self.dropout = dropout
self.has_embedding = num_features > 0
self.num_classes = num_classes
out_planes = self.base.fc.in_features
# Append new layers
if self.has_embedding:
self.feat = nn.Linear(out_planes, self.num_features)
self.feat_bn = nn.BatchNorm1d(self.num_features)
init.kaiming_normal(self.feat.weight, mode='fan_out')
init.constant(self.feat.bias, 0)
init.constant(self.feat_bn.weight, 1)
init.constant(self.feat_bn.bias, 0)
else:
# Change the num_features to CNN output channels
self.num_features = out_planes
if self.dropout > 0:
self.drop = nn.Dropout(self.dropout)
if self.num_diff_features > 0:
self.diff_feat = nn.Linear(self.num_features, self.num_diff_features)
init.orthogonal(self.diff_feat.weight)
init.constant(self.diff_feat.bias, 0)
if self.num_classes > 0:
self.classifier = nn.Linear(self.num_features, self.num_classes)
# init.orthogonal(self.classifier.weight)
init.normal(self.classifier.weight, std=0.001)
init.constant(self.classifier.bias, 0)
if not self.pretrained:
self.reset_params()
def reset_params(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
init.kaiming_normal(m.weight, mode='fan_out')
if m.bias is not None:
init.constant(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
init.constant(m.weight, 1)
init.constant(m.bias, 0)
elif isinstance(m, nn.Linear):
init.normal(m.weight, std=0.001)
if m.bias is not None:
init.constant(m.bias, 0)
def init_params(net):
'''Init layer parameters.'''
for m in net.modules():
if isinstance(m, nn.Conv2d):
init.kaiming_normal(m.weight, mode='fan_out')
if m.bias:
init.constant(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
init.constant(m.weight, 1)
init.constant(m.bias, 0)
elif isinstance(m, nn.Linear):
init.normal(m.weight, std=1e-3)
if m.bias:
init.constant(m.bias, 0)
def conv_transpose2d(channel_in, channel_out,
ksize=4, stride=2, padding=1,
activation=nn.LeakyReLU,
normalizer=nn.BatchNorm2d):
layer = list()
bias = True if not normalizer else False
layer.append(nn.ConvTranspose2d(channel_in, channel_out,
ksize, stride, padding,
bias=bias))
_apply(layer, activation, normalizer, channel_out)
init.kaiming_normal(layer[0].weight)
return nn.Sequential(*layer)
def nn_conv2d(channel_in, channel_out,
ksize=3, stride=1, padding=1,
scale_factor=2,
activation=nn.LeakyReLU,
normalizer=nn.BatchNorm2d):
layer = list()
bias = True if not normalizer else False
layer.append(nn.UpsamplingNearest2d(scale_factor=scale_factor))
layer.append(nn.Conv2d(channel_in, channel_out,
ksize, stride, padding,
bias=bias))
_apply(layer, activation, normalizer, channel_out)
init.kaiming_normal(layer[1].weight)
return nn.Sequential(*layer)
def init_fun(m):
classname = m.__class__.__name__
if (classname.find('Conv') == 0 or classname.find('Linear') == 0) and hasattr(m, 'weight'):
# print m.__class__.__name__
if init_type == 'gaussian':
init.normal(m.weight.data, 0.0, 0.02)
elif init_type == 'xavier':
init.xavier_normal(m.weight.data, gain=math.sqrt(2))
elif init_type == 'kaiming':
init.kaiming_normal(m.weight.data, a=0, mode='fan_in')
elif init_type == 'orthogonal':
init.orthogonal(m.weight.data, gain=math.sqrt(2))
elif init_type == 'default':
pass
else:
assert 0, "Unsupported initialization: {}".format(init_type)
if hasattr(m, 'bias') and m.bias is not None:
init.constant(m.bias.data, 0.0)
def init_func(m):
classname = m.__class__.__name__
if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1):
if init_type == 'normal':
init.normal(m.weight.data, 0.0, gain)
elif init_type == 'xavier':
init.xavier_normal(m.weight.data, gain=gain)
elif init_type == 'kaiming':
init.kaiming_normal(m.weight.data, a=0, mode='fan_in')
elif init_type == 'orthogonal':
init.orthogonal(m.weight.data, gain=gain)
else:
raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
if hasattr(m, 'bias') and m.bias is not None:
init.constant(m.bias.data, 0.0)
elif classname.find('BatchNorm2d') != -1:
init.normal(m.weight.data, 1.0, gain)
init.constant(m.bias.data, 0.0)
def __init__(self, num_features=0):
super(Reconstruct, self).__init__()
self.num_features = num_features
self.fc_re = nn.Linear(self.num_features, 2048)
self.fc_rebn = nn.BatchNorm1d(2048)
init.kaiming_normal(self.fc_re.weight, mode='fan_out')
init.constant(self.fc_re.bias, 0)
# init.constant(self.fc_rebn.weight, 1)
# init.constant(self.fc_rebn.bias, 0)
self.upconv5 = nn.ConvTranspose2d(2048, 1024, 3, 2, 1)
self.upconv5_bn = nn.BatchNorm2d(1024)
self.upconv4 = nn.ConvTranspose2d(1024, 512, 3, 2, 1)
self.upconv4_bn = nn.BatchNorm2d(512)
self.upconv3 = nn.ConvTranspose2d(512, 256, 3, 2, 1)
self.upconv3_bn = nn.BatchNorm2d(256)
self.upconv2 = nn.ConvTranspose2d(256, 64, 3, 1, 1)
self.upconv2_bn = nn.BatchNorm2d(64)
self.upconv1 = nn.ConvTranspose2d(64, 3, 7, 2, 3)
def __init__(self, depth, pretrained=True, cut_at_pooling=False,
num_features=0, norm=False, dropout=0, num_classes=0):
super(ResNet, self).__init__()
self.depth = depth
self.pretrained = pretrained
self.cut_at_pooling = cut_at_pooling
# Construct base (pretrained) resnet
if depth not in ResNet.__factory:
raise KeyError("Unsupported depth:", depth)
self.base = ResNet.__factory[depth](pretrained=pretrained)
if not self.cut_at_pooling:
self.num_features = num_features
self.norm = norm
self.dropout = dropout
self.has_embedding = num_features > 0
self.num_classes = num_classes
out_planes = self.base.fc.in_features
# Append new layers
if self.has_embedding:
self.feat = nn.Linear(out_planes, self.num_features)
self.feat_bn = nn.BatchNorm1d(self.num_features)
init.kaiming_normal(self.feat.weight, mode='fan_out')
init.constant(self.feat.bias, 0)
init.constant(self.feat_bn.weight, 1)
init.constant(self.feat_bn.bias, 0)
else:
# Change the num_features to CNN output channels
self.num_features = out_planes
if self.dropout > 0:
self.drop = nn.Dropout(self.dropout)
if self.num_classes > 0:
self.classifier = nn.Linear(self.num_features, self.num_classes)
init.normal(self.classifier.weight, std=0.001)
init.constant(self.classifier.bias, 0)
if not self.pretrained:
self.reset_params()
def __init__(self, margin=0, num_classes=128):
super(AdaptTripletLoss, self).__init__()
self.margin = margin
self.ranking_loss = nn.MarginRankingLoss(margin=margin)
self.softmargin_loss = nn.SoftMarginLoss()
self.num_classes = num_classes
self.adp_metric_embedding1 = nn.Linear(2*self.num_classes, self.num_classes,bias=False)
# self.adp_metric_embedding1_bn = nn.BatchNorm1d(self.num_classes)
self.adp_metric_embedding2 = nn.Linear(self.num_classes, self.num_classes,bias=False)
# self.adp_metric_embedding2_bn = nn.BatchNorm1d(self.num_classes)
# init.constant(self.adp_metric_embedding1.bias,0)
# init.constant(self.adp_metric_embedding2.bias,0)
init.kaiming_normal(self.adp_metric_embedding1.weight, mode='fan_out')
init.kaiming_normal(self.adp_metric_embedding2.weight, mode='fan_out')
self.transform_matrix = nn.Parameter(torch.Tensor(self.num_classes, self.num_classes))
init.kaiming_normal(self.transform_matrix, mode='fan_out')
def __init__(self, margin=0, num_feature=128):
super(AdaptTripletLoss, self).__init__()
self.margin = margin
self.ranking_loss = nn.MarginRankingLoss(margin=margin)
self.softmargin_loss = nn.SoftMarginLoss()
self.num_classes = num_feature
self.adp_metric_embedding1 = nn.Linear(3*self.num_classes, 3*self.num_classes, bias=False)
self.adp_metric_embedding1_bn = nn.BatchNorm1d(3*self.num_classes)
self.adp_metric_embedding2 = nn.Linear(3*self.num_classes, 2*self.num_classes, bias=False)
self.adp_metric_embedding2_bn = nn.BatchNorm1d(2 * self.num_classes)
self.adp_metric_embedding3 = nn.Linear(2*self.num_classes, 2*self.num_classes, bias=False)
self.adp_metric_embedding3_bn = nn.BatchNorm1d(2 * self.num_classes)
self.adp_metric_embedding4 = nn.Linear(2*self.num_classes, 2*self.num_classes, bias=False)
# self.adp_metric_embedding2_bn = nn.BatchNorm1d(self.num_classes)
# init.constant(self.adp_metric_embedding1.bias,0)
# init.constant(self.adp_metric_embedding2.bias,0)
init.kaiming_normal(self.adp_metric_embedding1.weight, mode='fan_out')
init.kaiming_normal(self.adp_metric_embedding2.weight, mode='fan_out')
init.kaiming_normal(self.adp_metric_embedding3.weight, mode='fan_out')
init.orthogonal(self.adp_metric_embedding4.weight)
def conv_params(ni, no, k=1):
return cast(kaiming_normal(torch.Tensor(no, ni, k, k)))
def __init__(self,
block,
depth,
num_classes,
input_grain_size=(1, 1),
input_num_bits=4,
input_M2D=0.0,
res_grain_size=(1, 1),
res_num_bits=4,
res_M2D=0.0,
output_grain_size=(1, 1),
output_num_bits=4,
output_M2D=0.0,
save_path='./'):
""" Constructor
Args:
depth: number of layers.
num_classes: number of classes
grain: grain size as tuple
M2D: Mean to Deviation ratio
base_width: base width
"""
super(CifarResNet, self).__init__()
#Model type specifies number of layers for CIFAR-10 and CIFAR-100 model
assert (depth -
2) % 6 == 0, 'depth should be one of 20, 32, 44, 56, 110'
layer_blocks = (depth - 2) // 6
print('CifarResNet : Depth : {} , Layers for each block : {}'.format(
depth, layer_blocks))
self.num_classes = num_classes
self.conv_1_3x3 = quan_Conv2d(3,
16,
kernel_size=3,
stride=1,
padding=1,
bias=False,
grain_size=input_grain_size,
num_bits=input_num_bits,
M2D=input_M2D,
save_path=save_path)
self.inplanes = 16
self.stage_1 = self._make_layer(block,
16,
layer_blocks,
1,
res_grain_size,
res_num_bits,
res_M2D,
save_path=save_path)
self.stage_2 = self._make_layer(block,
32,
layer_blocks,
2,
res_grain_size,
res_num_bits,
res_M2D,
save_path=save_path)
self.stage_3 = self._make_layer(block,
64,
layer_blocks,
2,
res_grain_size,
res_num_bits,
res_M2D,
save_path=save_path)
self.avgpool = nn.AvgPool2d(8)
self.classifier = quan_Linear(64 * block.expansion,
num_classes,
output_grain_size,
output_num_bits,
output_M2D,
save_path=save_path)
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))
#m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
init.kaiming_normal(m.weight)
m.bias.data.zero_()
def linear_init(ni, no):
return kaiming_normal(torch.Tensor(no, ni))
def _construct(self, layer_config):
"""
Method to construct the layer from the layer_config dictionary parameters.
"""
self.linear = nn.Linear(layer_config['n_in'], layer_config['n_out'])
self.bn = lambda x: x
if 'batch_norm' in layer_config:
if layer_config['batch_norm']:
self.bn = nn.BatchNorm1d(layer_config['n_out'], momentum=0.99)
if 'weight_norm' in layer_config:
if layer_config['weight_norm']:
self.linear = nn.utils.weight_norm(self.linear, name='weight')
init_gain = 1.
if 'non_linearity' in layer_config:
non_linearity = layer_config['non_linearity']
if non_linearity is None or non_linearity == 'linear':
self.non_linearity = lambda x: x
elif non_linearity == 'relu':
self.non_linearity = nn.ReLU()
init_gain = init.calculate_gain('relu')
elif non_linearity == 'leaky_relu':
self.non_linearity = nn.LeakyReLU()
elif non_linearity == 'clipped_leaky_relu':
self.non_linearity = ClippedLeakyReLU(negative_slope=1. / 3,
clip_min=-3,
clip_max=3)
elif non_linearity == 'elu':
self.non_linearity = nn.ELU()
elif non_linearity == 'selu':
self.non_linearity = nn.SELU()
elif non_linearity == 'tanh':
self.non_linearity = nn.Tanh()
init_gain = init.calculate_gain('tanh')
elif non_linearity == 'sigmoid':
self.non_linearity = nn.Sigmoid()
else:
raise Exception('Non-linearity ' + str(non_linearity) +
' not found.')
else:
self.non_linearity = lambda x: x
self.dropout = lambda x: x
if 'dropout' in layer_config:
if layer_config['dropout'] is not None:
self.dropout = nn.Dropout(layer_config['dropout'])
if 'initialize' in layer_config:
initialize = layer_config['initialize']
if initialize == 'normal':
init.normal(self.linear.weight)
elif initialize == 'glorot_uniform':
init.xavier_uniform(self.linear.weight, gain=init_gain)
elif initialize == 'glorot_normal':
init.xavier_normal(self.linear.weight, gain=init_gain)
elif initialize == 'kaiming_uniform':
init.kaiming_uniform(self.linear.weight)
elif initialize == 'kaiming_normal':
init.kaiming_normal(self.linear.weight)
elif initialize == 'orthogonal':
init.orthogonal(self.linear.weight, gain=init_gain)
elif initialize == '':
pass
else:
raise Exception('Parameter initialization ' + str(initialize) +
' not found.')
if 'batch_norm' in layer_config:
if layer_config['batch_norm']:
init.normal(self.bn.weight, 1, 0.02)
init.constant(self.bn.bias, 0.)
else:
init.xavier_normal(self.linear.weight, gain=init_gain)
init.constant(self.linear.bias, 0.)
def __init__(self,
depth,
pretrained=True,
cut_at_pooling=False,
num_features=0,
norm=False,
dropout=0,
num_classes=0,
FCN=False,
T=1,
dim=256):
super(ResNet, self).__init__()
self.depth = depth
self.pretrained = pretrained
self.cut_at_pooling = cut_at_pooling
self.FCN = FCN
self.T = T
self.reduce_dim = dim
# self.offset = ConvOffset2D(32)
# Construct base (pretrained) resnet
if depth not in ResNet.__factory:
raise KeyError("Unsupported depth:", depth)
self.base = ResNet.__factory[depth](pretrained=pretrained)
#==========================add dilation=============================#
if self.FCN:
self.base.layer4[0].conv2.stride = (1, 1)
# self.base.layer4[0].conv2.dilation=(2,2)
# self.base.layer4[0].conv2.padding=(2,2)
self.base.layer4[0].downsample[0].stride = (1, 1)
# self.base.layer4[1].conv2.dilation=(2,2)
# self.base.layer4[1].conv2.padding=(2,2)
# self.base.layer4[2].conv2.dilation=(2,2)
# self.base.layer4[2].conv2.padding=(2,2)
#================append conv for FCN==============================#
self.num_features = num_features
self.num_classes = num_classes - 1
self.dropout = dropout
self.local_conv = nn.Conv2d(2048,
self.num_features,
kernel_size=1,
padding=0,
bias=False)
init.kaiming_normal(self.local_conv.weight, mode='fan_out')
# init.constant(self.local_conv.bias,0)
self.feat_bn2d = nn.BatchNorm2d(
self.num_features) #may not be used, not working on caffe
init.constant(self.feat_bn2d.weight,
1) #initialize BN, may not be used
init.constant(self.feat_bn2d.bias,
0) # iniitialize BN, may not be used
##---------------------------stripe1----------------------------------------------#
self.instance0 = nn.Linear(self.num_features, self.num_classes)
init.normal(self.instance0.weight, std=0.001)
init.constant(self.instance0.bias, 0)
##---------------------------stripe1----------------------------------------------#
##---------------------------stripe1----------------------------------------------#
self.instance1 = nn.Linear(self.num_features, self.num_classes)
init.normal(self.instance1.weight, std=0.001)
init.constant(self.instance1.bias, 0)
##---------------------------stripe1----------------------------------------------#
##---------------------------stripe1----------------------------------------------#
self.instance2 = nn.Linear(self.num_features, self.num_classes)
init.normal(self.instance2.weight, std=0.001)
init.constant(self.instance2.bias, 0)
##---------------------------stripe1----------------------------------------------#
##---------------------------stripe1----------------------------------------------#
self.instance3 = nn.Linear(self.num_features, self.num_classes)
init.normal(self.instance3.weight, std=0.001)
init.constant(self.instance3.bias, 0)
##---------------------------stripe1----------------------------------------------#
##---------------------------stripe1----------------------------------------------#
self.instance4 = nn.Linear(self.num_features, self.num_classes)
init.normal(self.instance4.weight, std=0.001)
init.constant(self.instance4.bias, 0)
##---------------------------stripe1----------------------------------------------#
##---------------------------stripe1----------------------------------------------#
self.instance5 = nn.Linear(self.num_features, self.num_classes)
init.normal(self.instance5.weight, std=0.001)
init.constant(self.instance5.bias, 0)
##---------------------------stripe1----------------------------------------------#
##---------------------------stripe1----------------------------------------------#
self.drop = nn.Dropout(self.dropout)
self.local_mask = nn.Conv2d(self.reduce_dim,
6,
kernel_size=1,
padding=0,
bias=True)
init.kaiming_normal(self.local_mask.weight, mode='fan_out')
# init.xavier_normal(self.local_mask.weight)
init.constant(self.local_mask.bias, 0)
#===================================================================#
elif not self.cut_at_pooling:
self.num_features = num_features
self.norm = norm
self.dropout = dropout
self.has_embedding = num_features > 0
self.num_classes = num_classes
out_planes = self.base.fc.in_features
# Append new layers
if self.has_embedding:
# self.f_bn = nn.BatchNorm1d(2048)
# init.constant(self.f_bn.weight, 1)
# init.constant(self.f_bn.bias, 0)
self.feat = nn.Linear(out_planes,
self.num_features,
bias=False)
self.feat_bn = nn.BatchNorm1d(self.num_features)
init.kaiming_normal(self.feat.weight, mode='fan_out')
# init.constant(self.feat.bias, 0)
init.constant(self.feat_bn.weight, 1)
init.constant(self.feat_bn.bias, 0)
else:
# Change the num_features to CNN output channels
self.num_features = out_planes
if self.dropout > 0:
self.drop = nn.Dropout(self.dropout)
if self.num_classes > 0:
# self.classifier = nn.Linear(self.num_features, self.num_classes)
self.classifier = nn.Linear(self.num_features,
self.num_classes)
init.normal(self.classifier.weight, std=0.001)
init.constant(self.classifier.bias, 0)
if not self.pretrained:
self.reset_params()
def __init__(self, input_channel=7):
super(NormNetDF, self).__init__()
self.input_channel = input_channel
self.res_scale = 7 # number of residuals
# improved with shrink res-block layers
in_planes = input_channel
self.conv1 = conv(in_planes, 64, 7, 2)
self.conv2 = ResBlock(64, 128, 2)
self.conv3 = ResBlock(128, 256, 2)
self.conv3_1 = ResBlock(256, 256)
self.conv4 = ResBlock(256, 512, stride=2)
self.conv4_1 = ResBlock(512, 512)
self.conv5 = ResBlock(512, 512, stride=2)
self.conv5_1 = ResBlock(512, 512)
self.conv6 = ResBlock(512, 1024, stride=2)
self.conv6_1 = ResBlock(1024, 1024)
# original shrink conv layers
#self.conv2 = conv(self.batchNorm, 64, 128, 5, 2)
#self.conv3 = conv(self.batchNorm, 128, 256, 5, 2)
#self.conv3_1 = conv(self.batchNorm, 256, 256)
#self.conv4 = conv(self.batchNorm, 256, 512, stride=2)
#self.conv4_1 = conv(self.batchNorm, 512, 512)
#self.conv5 = conv(self.batchNorm, 512, 512, stride=2)
#self.conv5_1 = conv(self.batchNorm, 512, 512)
#self.conv6 = conv(self.batchNorm, 512, 1024, stride=2)
#self.conv6_1 = conv(self.batchNorm, 1024, 1024)
# iconv with deconv layers
'''
self.iconv5 = nn.ConvTranspose2d(1025, 512, 3, 1, 1)
self.iconv4 = nn.ConvTranspose2d(769, 256, 3, 1, 1)
self.iconv3 = nn.ConvTranspose2d(385, 128, 3, 1, 1)
self.iconv2 = nn.ConvTranspose2d(193, 64, 3, 1, 1)
self.iconv1 = nn.ConvTranspose2d(97, 32, 3, 1, 1)
self.iconv0 = nn.ConvTranspose2d(17+self.input_channel, 16, 3, 1, 1)
'''
self.iconv5 = nn.ConvTranspose2d(512 * 3, 512, 3, 1, 1)
self.iconv4 = nn.ConvTranspose2d(256 + 512 + 256, 256, 3, 1, 1)
self.iconv3 = nn.ConvTranspose2d(128 + 256 + 128, 128, 3, 1, 1)
self.iconv2 = nn.ConvTranspose2d(64 + 128 + 64, 64, 3, 1, 1)
self.iconv1 = nn.ConvTranspose2d(32 + 64 + 32, 32, 3, 1, 1)
self.iconv0 = nn.ConvTranspose2d(16 + 3 + 16, 16, 3, 1, 1)
# expand and produce disparity
self.upconv5 = deconv(1024, 512)
self.upconv4 = deconv(512, 256)
self.upconv3 = deconv(256, 128)
self.upconv2 = deconv(128, 64)
self.upconv1 = deconv(64, 32)
self.upconv0 = deconv(32, 16)
self.pred_res0 = predict_flow(16, 3)
# weight initialization
for m in self.modules():
if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
# n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
# m.weight.data.normal_(0, 0.02 / n)
# m.weight.data.normal_(0, 0.02)
kaiming_normal(m.weight.data)
if m.bias is not None:
m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def _weights_init(m):
classname = m.__class__.__name__
# print(classname)
if isinstance(m, MetaLinear) or isinstance(m, MetaConv2d):
init.kaiming_normal(m.weight)
def init_weights( self ):
'''
Initialize final classifier weights
'''
init.kaiming_normal( self.mlp.weight, mode='fan_in' )
self.mlp.bias.data.fill_( 0 )
googlenet.load_state_dict(torch.load(opt.googlenet))
#freeze the parameters
#for param in googlenet.parameters():
#param.requires_grad = False
#print(dir(googlenet.module))
#num_ftrs = googlenet.module.classifier.in_features
#googlenet.module.classifier = AngleLinear(num_ftrs,opt.out_class)
googlenet = googlenet.module
for param in googlenet.parameters():
param.requires_grad = False
#os.environ["CUDA_VISIBLE_DEVICES"] = "5"
num_ftrs = googlenet.classifier.in_features
#googlenet.classifier = AngleLinear(num_ftrs,opt.out_class,opt.m)
googlenet.classifier = nn.Linear(num_ftrs, opt.out_class)
init.kaiming_normal(googlenet.classifier.weight.data, a=0, mode='fan_in')
if ngpu > 1:
googlenet = nn.DataParallel(googlenet)
#print('m={}'.format(opt.m))
if opt.cuda:
googlenet.cuda()
criterion.cuda()
#if ngpu>1:
#googlenet.module.classifier = nn.DataParallel(googlenet.module.classifier)
#print(dir(googlenet.module))
#exit(0)
#googlenet.classifier = nn.Linear(num_ftrs,opt.out_class)
#init.kaiming_normal(googlenet.classifier.weight.data, a=0, mode='fan_in')
def reset_parameters(self):
kaiming_normal(self.weight)
ZeroInitializer(self.b1)
ZeroInitializer(self.b2)
def __init__(self,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
hidden_num=2048,
cut_at_pooling=False,
num_features=0,
norm=False,
dropout=0,
num_classes=0):
super(DenseNet, self).__init__()
self.cut_at_pooling = cut_at_pooling
# First convolution
self.features = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
if i < 2:
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
self.hidden = nn.Sequential(
OrderedDict([
('norm2', nn.BatchNorm2d(num_features)),
('relu2', nn.ReLU(inplace=True)),
('conv3',
nn.Conv2d(num_features,
num_features,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('norm3', nn.BatchNorm2d(num_features)),
('relu3', nn.ReLU(inplace=True)),
('pool3', nn.MaxPool2d(kernel_size=2, stride=2, padding=1)),
('conv4',
nn.Conv2d(num_features,
num_features,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('norm4', nn.BatchNorm2d(num_features)),
('relu4', nn.ReLU(inplace=True)),
('pool4', nn.MaxPool2d(kernel_size=2, stride=2, padding=1)),
]))
self.embedding = nn.Sequential(
OrderedDict([('feat', nn.Linear(3 * 6 * 512, hidden_num)),
('feat_bn', nn.BatchNorm2d(hidden_num)),
('feat_relu', nn.ReLU(inplace=True))]))
if not self.cut_at_pooling:
self.num_features = num_features
self.norm = norm
self.dropout = dropout
self.has_embedding = num_features > 0
self.num_classes = num_classes
out_planes = self.base.classifier.in_features
# Append new layers
if self.has_embedding:
self.feat = nn.Linear(out_planes, self.num_features)
self.feat_bn = nn.BatchNorm1d(self.num_features)
init.kaiming_normal(self.feat.weight, mode='fan_out')
init.constant(self.feat.bias, 0)
init.constant(self.feat_bn.weight, 1)
init.constant(self.feat_bn.bias, 0)
else:
# Change the num_features to CNN output channels
self.num_features = out_planes
if self.dropout > 0:
self.drop = nn.Dropout(self.dropout)
if self.num_classes > 0:
self.classifier_bn = nn.BatchNorm1d(self.num_features)
self.classifier = nn.Linear(self.num_features,
self.num_classes)
init.constant(self.classifier_bn.weight, 1)
init.constant(self.classifier_bn.bias, 0)
init.normal(self.classifier.weight, std=0.001)
init.constant(self.classifier.bias, 0)
def weights_init_kaiming(m):
classname = m.__class__.__name__
if classname.find('Conv2d') != -1:
init.kaiming_normal(m.weight.data)
if Deep4:
# final_conv_length determines the size of the receptive field of the ConvNet
model = Deep4Net(in_chans=in_chans,
n_classes=1,
input_time_length=input_time_length,
pool_time_stride=pool_time_stride,
final_conv_length=2,
stride_before_pool=True).create_network()
elif ResNet:
model_name = 'resnet-xavier-uniform'
init_name = model_name.lstrip('resnet-')
from torch.nn import init
init_fn = {
'he-uniform': lambda w: init.kaiming_uniform(w, a=0),
'he-normal': lambda w: init.kaiming_normal(w, a=0),
'xavier-uniform': lambda w: init.xavier_uniform(w, gain=1),
'xavier-normal': lambda w: init.xavier_normal(w, gain=1)
}[init_name]
model = EEGResNet(in_chans=in_chans,
n_classes=1,
input_time_length=input_time_length,
final_pool_length=2,
n_first_filters=48,
conv_weight_init_fn=init_fn).create_network()
elif EEGNet_v4:
model = EEGNetv4(
in_chans=in_chans,
n_classes=1,
final_conv_length=2,
def KaimingInit(weight, activation): assert not activation is None if hasattr(activation, "negative_slope"): kaiming_normal(weight, a = activation.negative_slope) else: kaiming_normal(weight, a = 0)
class MNISTResNet(ResNet):
def __init__(self):
super(MNISTResNet, self).__init__(BasicBlock, [2, 2, 2, 2],
num_classes=10)
self.conv1 = nn.Conv2d(1,
64,
kernel_size=3,
stride=1,
padding=3,
bias=False)
if __name__ == "__main__":
model = CNN()
new_model = nn.Sequential(*list(model.children()))
conv_model = nn.Sequential()
for layer in model.named_modules():
if isinstance(layer[1], nn.Conv2d):
conv_model.add_module(layer[0], layer[1])
for m in model.modules():
if isinstance(m, nn.Conv2d):
init.normal(m.weight.data)
init.xavier_normal(m.weight.data)
init.kaiming_normal(m.weight.data)
m.bias.data.fill_(0)
elif isinstance(m, nn.Linear):
m.weight.data.normal_()
def _weights_init(m):
if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):
init.kaiming_normal(m.weight)
def linear_params(ni, no):
return cast({'weight': kaiming_normal(torch.Tensor(no, ni)), 'bias': torch.zeros(no)})
def __init__(self, args):
self.use_cuda = args.cuda and torch.cuda.is_available()
self.args = args
self.encoder = args.encoder
self.decoder = args.decoder
self.z_dim_bern = args.z_dim_bern
self.z_dim_gauss = args.z_dim_gauss
self.AE = args.AE
self.n_filter = args.n_filter
self.n_rep = args.n_rep
self.kernel_size = args.kernel_size
self.padding = args.padding
self.sbd = args.sbd
self.freeze_decoder = args.freeze_decoder
self.n_digits = 2
if args.dataset.lower() == 'digits_gray':
self.nc = 1
elif args.dataset.lower() == 'digits_col':
self.nc = 3
else:
raise NotImplementedError
net = multi_VAE(self.encoder, self.decoder, self.z_dim_bern,
self.z_dim_gauss, self.n_filter, self.nc, self.n_rep,
self.sbd, self.kernel_size, self.padding, self.AE)
print("CUDA availability: " + str(torch.cuda.is_available()))
self.device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
net = nn.DataParallel(net)
self.net = net.to(self.device)
print("net on cuda: " + str(next(self.net.parameters()).is_cuda))
self.lr = args.lr
self.beta1 = args.beta1
self.beta2 = args.beta2
if not self.freeze_decoder:
if args.optim_type == 'Adam':
self.optim = optim.Adam(self.net.parameters(),
lr=self.lr,
betas=(self.beta1, self.beta2))
elif args.optim_type == 'SGD':
self.optim = optim.SGD(self.net.parameters(),
lr=self.lr,
momentum=0.9)
elif self.freeze_decoder:
if args.optim_type == 'Adam':
self.optim = optim.Adam(filter(lambda p: p.requires_grad,
self.net.parameters()),
lr=self.lr,
betas=(self.beta1, self.beta2))
elif args.optim_type == 'SGD':
self.optim = optim.SGD(filter(lambda p: p.requires_grad,
self.net.parameters()),
lr=self.lr,
momentum=0.9)
self.save_output = args.save_output
self.output_dir = args.output_dir #os.path.join(args.output_dir, args.viz_name)
print(self.output_dir)
if not os.path.exists(self.output_dir):
os.makedirs(self.output_dir, exist_ok=True)
self.ckpt_dir = os.path.join(args.output_dir, args.viz_name)
if not os.path.exists(self.ckpt_dir):
os.makedirs(self.ckpt_dir, exist_ok=True)
self.ckpt_name = args.ckpt_name
if self.ckpt_name is not None:
self.load_checkpoint(self.ckpt_name)
if self.freeze_decoder:
print("FREEZING DECODER")
child_counter = 0
for child in self.net.children():
if child_counter == 1:
print("In decoder: ")
not_freeze = [
'Lin_1.weight', 'Lin_1.bias', 'Lin_2.weight',
'Lin_2.bias', 'Lin_3.weight', 'Lin_3.bias'
]
for name, param in child.named_parameters():
if name not in not_freeze:
param.requires_grad = False
print(name, 'is FROZEN')
else:
print(name, 'is NOT frozen')
if name == 'Lin_1.weight' or name == 'Lin_2.weight' or name == 'Lin_3.weight':
init.kaiming_normal(param, nonlinearity='relu')
else:
param.data.fill_(0)
child_counter += 1
#print parameters in model
encoder_size = 0
decoder_size = 0
for name, param in net.named_parameters():
if param.requires_grad:
if 'encoder' in name:
encoder_size += param.numel()
elif 'decoder' in name:
decoder_size += param.numel()
tot_size = encoder_size + decoder_size
print(tot_size, "parameters in the network!", encoder_size,
" in the encoder", decoder_size, "in the decoder")
self.params = tot_size
self.train_dl, self.gnrl_dl, self.gnrl_data = return_data_unsupervised(
args)
self.max_epoch = args.max_epoch
self.global_iter = 0
self.gather_step = args.gather_step
self.display_step = args.display_step
self.save_step = args.save_step
self.beta = args.beta
self.gamma = args.gamma
self.l2_loss = args.l2_loss
self.encoder_target_type = args.encoder_target_type
self.image_size = args.image_size
self.flip = args.flip
if self.flip == True:
self.flip_idx = pickle.load(
open("{}train_idx_to_flip.p".format(args.dset_dir), "rb"))
self.flip_idx.sort()
print(self.flip_idx[0:20])
print(len(self.flip_idx), " flipped images!")
self.testing_method = args.testing_method
self.gather = DataGather(self.testing_method, self.encoder_target_type,
self.n_digits)
self.viz_name = args.viz_name
self.viz_port = args.viz_port
self.viz_on = args.viz_on
self.win_recon = None
self.win_kld = None
self.win_mu = None
self.win_var = None
def _weights_init(m):
classname = m.__class__.__name__
if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):
init.kaiming_normal(m.weight)
def __init__(self,
block,
layers,
network_type,
num_classes,
att_type=None):
self.inplanes = 64
super(ResNet, self).__init__()
self.network_type = network_type
# different model config between ImageNet and CIFAR
if network_type == "ImageNet":
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.avgpool = nn.AvgPool2d(7)
else:
self.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
if att_type == 'BAM':
self.bam1 = BAM(64 * block.expansion)
self.bam2 = BAM(128 * block.expansion)
self.bam3 = BAM(256 * block.expansion)
else:
self.bam1, self.bam2, self.bam3 = None, None, None
self.layer1 = self._make_layer(block, 64, layers[0], att_type=att_type)
self.layer2 = self._make_layer(block,
128,
layers[1],
stride=2,
att_type=att_type)
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=2,
att_type=att_type)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=2,
att_type=att_type)
self.fc = nn.Linear(512 * block.expansion, num_classes)
init.kaiming_normal(self.fc.weight)
for key in self.state_dict():
if key.split('.')[-1] == "weight":
if "conv" in key:
init.kaiming_normal(self.state_dict()[key], mode='fan_out')
if "bn" in key:
if "SpatialGate" in key:
self.state_dict()[key][...] = 0
else:
self.state_dict()[key][...] = 1
elif key.split(".")[-1] == 'bias':
self.state_dict()[key][...] = 0
def __init__(self, dim, output_padding, numpen, dropout=0.2, slope=0.0):
super(convSDAE, self).__init__()
self.in_dim = dim[0]
self.nlayers = len(dim) - 1
self.reluslope = slope
self.numpen = numpen
self.enc, self.dec = [], []
self.benc, self.bdec = [], []
for i in range(self.nlayers):
if i == self.nlayers - 1:
self.enc.append(nn.Linear(dim[i] * numpen * numpen,
dim[i + 1]))
self.benc.append(nn.BatchNorm2d(dim[i + 1]))
self.dec.append(
nn.ConvTranspose2d(dim[i + 1],
dim[i],
kernel_size=numpen,
stride=1))
self.bdec.append(nn.BatchNorm2d(dim[i]))
elif i == 0:
self.enc.append(
nn.Conv2d(dim[i],
dim[i + 1],
kernel_size=4,
stride=2,
padding=1))
self.benc.append(nn.BatchNorm2d(dim[i + 1]))
self.dec.append(
nn.ConvTranspose2d(dim[i + 1],
dim[i],
kernel_size=4,
stride=2,
padding=1,
output_padding=output_padding[i]))
self.bdec.append(nn.BatchNorm2d(dim[i]))
else:
self.enc.append(
nn.Conv2d(dim[i],
dim[i + 1],
kernel_size=5,
stride=2,
padding=2))
self.benc.append(nn.BatchNorm2d(dim[i + 1]))
self.dec.append(
nn.ConvTranspose2d(dim[i + 1],
dim[i],
kernel_size=5,
stride=2,
padding=2,
output_padding=output_padding[i]))
self.bdec.append(nn.BatchNorm2d(dim[i]))
setattr(self, 'enc_{}'.format(i), self.enc[-1])
setattr(self, 'benc_{}'.format(i), self.benc[-1])
setattr(self, 'dec_{}'.format(i), self.dec[-1])
setattr(self, 'bdec_{}'.format(i), self.bdec[-1])
self.base = []
self.bbase = []
for i in range(self.nlayers):
self.base.append(nn.Sequential(*self.enc[:i]))
self.bbase.append(nn.Sequential(*self.benc[:i]))
self.dropmodule1 = nn.Dropout(p=dropout)
self.dropmodule2 = nn.Dropout(p=dropout)
self.loss = nn.MSELoss(size_average=True)
# initialization
for m in self.modules():
if isinstance(m, nn.Linear):
init.normal(m.weight, std=1e-2)
if m.bias.data is not None:
init.constant(m.bias, 0)
elif isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
init.kaiming_normal(m.weight, mode='fan_out')
if m.bias.data is not None:
init.constant(m.bias, 0)
def conv_init(ni, no, k):
return kaiming_normal(torch.Tensor(no, ni, k, k))
def init_conv(conv, glu=True):
init.kaiming_normal(conv.weight)
if conv.bias is not None:
conv.bias.data.zero_()
def __init__(self,
depth,
pretrained=True,
cut_at_pooling=False,
num_features=0,
norm=False,
dropout=0,
num_classes=0):
super(ResNet, self).__init__()
self.depth = depth
self.pretrained = pretrained
self.cut_at_pooling = cut_at_pooling
# Construct base (pretrained) resnet
if depth not in ResNet.__factory:
raise KeyError("Unsupported depth:", depth)
self.base = ResNet.__factory[depth](pretrained=pretrained)
# fix layers [conv1 ~ layer2]
fixed_names = []
for name, module in self.base._modules.items():
if name == "layer3":
assert fixed_names == [
"conv1", "bn1", "relu", "maxpool", "layer1", "layer2"
]
break
fixed_names.append(name)
for param in module.parameters():
param.requires_grad = False
if not self.cut_at_pooling:
self.num_features = num_features
self.norm = norm
self.dropout = dropout
self.has_embedding = num_features > 0
self.num_classes = num_classes
out_planes = self.base.fc.in_features
# Append new layers
if self.has_embedding:
self.feat = nn.Linear(out_planes, self.num_features)
self.feat_bn = nn.BatchNorm1d(self.num_features)
init.kaiming_normal(self.feat.weight, mode='fan_out')
init.constant(self.feat.bias, 0)
init.constant(self.feat_bn.weight, 1)
init.constant(self.feat_bn.bias, 0)
else:
# Change the num_features to CNN output channels
self.num_features = out_planes
if self.dropout > 0:
self.drop = nn.Dropout(self.dropout)
if self.num_classes > 0:
self.classifier = nn.Linear(self.num_features,
self.num_classes)
init.normal(self.classifier.weight, std=0.001)
init.constant(self.classifier.bias, 0)
if not self.pretrained:
self.reset_params()
def __init_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv1d):
kaiming_normal(m.weight, mode='fan_in')
if m.bias is not None:
constant(m.bias, 0)
def init_weights_he(model):
if isinstance(model, nn.Conv2d):
init.kaiming_normal(model.weight)
init.constant(model.bias, 0)
def linear_init(ni, no):
return kaiming_normal(torch.Tensor(no, ni))
def weight_init(m):
if isinstance(m, nn.Conv2d):
torch.nn.init.xavier_normal(m.weight.data)
elif isinstance(m, nn.Linear):
kaiming_normal(m.weight)
m.bias.data.zero_()
def _weights_init(m):
classname = m.__class__.__name__
#print(classname)
if isinstance(m, nn.Linear) or isinstance(m, nn.Conv2d):
init.kaiming_normal(m.weight)
def reset_parameters(self):
init.kaiming_normal(self.attend[0].weight.data)
init.constant(self.attend[0].bias.data, val=0)
def init_params(net):
'''Init layer parameters.'''
for m in net.modules():
if isinstance(m, nn.Conv2d):
init.kaiming_normal(m.weight, mode='fan_out')
if m.bias:
init.constant(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
init.constant(m.weight, 1)
init.constant(m.bias, 0)
elif isinstance(m, nn.Linear):
init.normal(m.weight, std=1e-3)
if m.bias:
init.constant(m.bias, 0)
# _, term_width = os.popen('stty size', 'r').read().split()
# term_width = int(term_width)
#
# TOTAL_BAR_LENGTH = 65.
# last_time = time.time()
# begin_time = last_time
# def progress_bar(current, total, msg=None):
# global last_time, begin_time
# if current == 0:
# begin_time = time.time() # Reset for new bar.
#
# cur_len = int(TOTAL_BAR_LENGTH*current/total)
# rest_len = int(TOTAL_BAR_LENGTH - cur_len) - 1
#
# sys.stdout.write(' [')
# for i in range(cur_len):
# sys.stdout.write('=')
# sys.stdout.write('>')
# for i in range(rest_len):
# sys.stdout.write('.')
# sys.stdout.write(']')
#
# cur_time = time.time()
# step_time = cur_time - last_time
# last_time = cur_time
# tot_time = cur_time - begin_time
#
# L = []
# L.append(' Step: %s' % format_time(step_time))
# L.append(' | Tot: %s' % format_time(tot_time))
# if msg:
# L.append(' | ' + msg)
#
# msg = ''.join(L)
# sys.stdout.write(msg)
# for i in range(term_width-int(TOTAL_BAR_LENGTH)-len(msg)-3):
# sys.stdout.write(' ')
#
# # Go back to the center of the bar.
# for i in range(term_width-int(TOTAL_BAR_LENGTH/2)+2):
# sys.stdout.write('\b')
# sys.stdout.write(' %d/%d ' % (current+1, total))
#
# if current < total-1:
# sys.stdout.write('\r')
# else:
# sys.stdout.write('\n')
# sys.stdout.flush()
#
# def format_time(seconds):
# days = int(seconds / 3600/24)
# seconds = seconds - days*3600*24
# hours = int(seconds / 3600)
# seconds = seconds - hours*3600
# minutes = int(seconds / 60)
# seconds = seconds - minutes*60
# secondsf = int(seconds)
# seconds = seconds - secondsf
# millis = int(seconds*1000)
#
# f = ''
# i = 1
# if days > 0:
# f += str(days) + 'D'
# i += 1
# if hours > 0 and i <= 2:
# f += str(hours) + 'h'
# i += 1
# if minutes > 0 and i <= 2:
# f += str(minutes) + 'm'
# i += 1
# if secondsf > 0 and i <= 2:
# f += str(secondsf) + 's'
# i += 1
# if millis > 0 and i <= 2:
# f += str(millis) + 'ms'
# i += 1
# if f == '':
# f = '0ms'
# return f
def conv_init(ni, no, k):
return kaiming_normal(torch.Tensor(no, ni, k, k))
def _init_weights(self):
if cfg.MRCNN.CONV_INIT == 'GaussianFill':
init.normal(self.upconv5.weight, std=0.001)
elif cfg.MRCNN.CONV_INIT == 'MSRAFill':
init.kaiming_normal(self.upconv5.weight)
init.constant(self.upconv5.bias, 0)
def reset_parameters(self):
init.kaiming_normal(self.encoder1[0].weight.data)
init.kaiming_normal(self.encoder1[2].weight.data)
init.constant(self.encoder1[0].bias.data, val=0)
init.constant(self.encoder1[2].bias.data, val=0)
init.kaiming_normal(self.encoder2[0].weight.data)
init.kaiming_normal(self.encoder2[2].weight.data)
init.constant(self.encoder2[0].bias.data, val=0)
init.constant(self.encoder2[2].bias.data, val=0)
init.kaiming_normal(self.encoder3[0].weight.data)
init.kaiming_normal(self.encoder3[2].weight.data)
init.constant(self.encoder3[0].bias.data, val=0)
init.constant(self.encoder3[2].bias.data, val=0)
init.kaiming_normal(self.encoder4[0].weight.data)
init.constant(self.encoder4[0].bias.data, val=0)
init.kaiming_normal(self.decoder1[0].weight.data)
init.kaiming_normal(self.decoder1[2].weight.data)
init.constant(self.decoder1[0].bias.data, val=0)
init.constant(self.decoder1[2].bias.data, val=0)
init.kaiming_normal(self.decoder2[0].weight.data)
init.kaiming_normal(self.decoder2[2].weight.data)
init.constant(self.decoder2[0].bias.data, val=0)
init.constant(self.decoder2[2].bias.data, val=0)
init.kaiming_normal(self.decoder3[0].weight.data)
init.kaiming_normal(self.decoder3[2].weight.data)
init.constant(self.decoder3[0].bias.data, val=0)
init.constant(self.decoder3[2].bias.data, val=0)
init.kaiming_normal(self.decoder4[0].weight.data)
init.constant(self.decoder4[0].bias.data, val=0)
def weights_init(net):
for m in net.modules():
if isinstance(m, torch.nn.Conv3d) or isinstance(
m, torch.nn.ConvTranspose3d):
init.kaiming_normal(m.weight)
init.constant(m.bias, 0.01)
