def __init__(self, num_filters, channels_in, stride): super(AvgPoolPadding, self).__init__() self.identity = nn.AvgPool2d(stride, stride=stride) self.num_zeros = num_filters - channels_in
def __init__(self, in_channel, block, layers, num_classes=10, lam=2, eta_coeff=1., init_theta=0.5, all_filter=False): super(ResNet_Cifar, self).__init__() self.inchannel = in_channel self.lam = lam self.all_filter = all_filter self.preprocess = [ 'no_op', 'max_3x3', 'max_5x5', 'min_3x3', 'min_5x5', 'ave_3x3', 'ave_5x5', 'sobel_h', 'sobel_w', 'lap_3x3', 'lap_5x5', 'gaus_3x3', 'gaus_5x5', 'shap_4', 'shap_8', 'bin_0.5' ] self.d = len(self.preprocess) * self.inchannel self.inplanes = 16 self.conv1 = nn.Conv2d(self.d, 16, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(16) self.relu = nn.ReLU(inplace=True) self.layer1 = self._make_layer(block, 16, layers[0]) self.layer2 = self._make_layer(block, 32, layers[1], stride=2) self.layer3 = self._make_layer(block, 64, layers[2], stride=2) self.avgpool = nn.AvgPool2d(8, stride=1) self.fc = nn.Linear(64 * block.expansion, num_classes) func0 = FilterProcess(None) # no operation func1 = MaxOrMinFilterProcess(3, True) func2 = MaxOrMinFilterProcess(5, True) func3 = MaxOrMinFilterProcess(3, False) func4 = MaxOrMinFilterProcess(5, False) func5 = FilterProcess(f.ave_3x3) func6 = FilterProcess(f.ave_5x5) func7 = FilterProcess(f.sobel_h) func8 = FilterProcess(f.sobel_w) func9 = FilterProcess(f.lap_3x3) func10 = FilterProcess(f.lap_5x5) func11 = FilterProcess(f.gaus_3x3) func12 = FilterProcess(f.gaus_5x5) func13 = FilterProcess(f.shap_4) func14 = FilterProcess(f.shap_8) func15 = Binarization(0.5) self.preprocess_listR = [ func0, func1, func2, func3, func4, func5, func6, func7, func8, func9, func10, func11, func12, func13, func14, func15 ] self.preprocess_listG = [ func0, func1, func2, func3, func4, func5, func6, func7, func8, func9, func10, func11, func12, func13, func14, func15 ] self.preprocess_listB = [ func0, func1, func2, func3, func4, func5, func6, func7, func8, func9, func10, func11, func12, func13, func14, func15 ] init_theta = init_theta * np.ones(self.d) non_inc_f = W.SelectionNonIncFunc(threshold=0.25, negative_weight=True) w = W.QuantileBasedWeight(non_inc_f=non_inc_f, tie_case=True, normalization=False, min_problem=True) self.igo = BernoulliIGO(d=self.d, weight_func=w, theta=init_theta, eta=eta_coeff / self.d, theta_max=1. - 1. / self.d, theta_min=1. / self.d) self.arch = self.igo.sampling_model().sampling(self.lam) for m in self.modules(): if isinstance(nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) nn.init.constant_(m.bias, 0)
def __init__(self, in_channels: int = 3, num_classes=1000, version=1.0): super(SqueezeNet, self).__init__() if version not in [1.0, 1.1]: raise ValueError("Unsupported SqueezeNet version {version}:" "1.0 or 1.1 expected".format(version=version)) self.num_classes = num_classes if version == 1.0: self.features = nn.Sequential( nn.Conv2d(in_channels, 96, kernel_size=7, stride=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(96, 16, 64, 64), Fire(128, 16, 64, 64), Fire(128, 32, 128, 128), nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(256, 32, 128, 128), Fire(256, 48, 192, 192), Fire(384, 48, 192, 192), Fire(384, 64, 256, 256), nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(512, 64, 256, 256), ) else: self.features = nn.Sequential( nn.Conv2d(in_channels, 64, kernel_size=3, stride=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(64, 16, 64, 64), Fire(128, 16, 64, 64), nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(128, 32, 128, 128), Fire(256, 32, 128, 128), nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(256, 48, 192, 192), Fire(384, 48, 192, 192), Fire(384, 64, 256, 256), Fire(512, 64, 256, 256), ) # Final convolution is initialized differently form the rest final_conv = nn.Conv2d(512, 1024, kernel_size=1) self.classifier = nn.Sequential(nn.Dropout(p=0.5), final_conv, nn.ReLU(inplace=True), nn.AvgPool2d(13)) # TODO 在Squeezenet最后增加了linear评价器和分类器 self.critic_linear = nn.Linear(1024, 1) # value function 评价器 self.cls_linear = Categorical(1024, num_classes) # classification 分类器 self.train() # 设置成训练模式 self.apply(weights_init) # 初始化相关参数 for m in self.modules(): if isinstance(m, nn.Conv2d): gain = 2.0 if m is final_conv: m.weight.data.normal_(0, 0.01) else: fan_in = m.kernel_size[0] * m.kernel_size[1] * m.in_channels u = math.sqrt(3.0 * gain / fan_in) m.weight.data.uniform_(-u, u) if m.bias is not None: m.bias.data.zero_()
import torch import torch.nn as nn OPS = { 'none': lambda C, stride, affine: Zero(stride), 'avg_pool_3x3': lambda C, stride, affine: nn.AvgPool2d( 3, stride=stride, padding=1, count_include_pad=False), 'max_pool_3x3': lambda C, stride, affine: nn.MaxPool2d(3, stride=stride, padding=1), 'skip_connect': lambda C, stride, affine: Identity() if stride == 1 else FactorizedReduce(C, C, affine=affine), 'sep_conv_3x3': lambda C, stride, affine: SepConv(C, C, 3, stride, 1, affine=affine), 'sep_conv_5x5': lambda C, stride, affine: SepConv(C, C, 5, stride, 2, affine=affine), 'dil_conv_3x3': lambda C, stride, affine: DilConv(C, C, 3, stride, 2, 2, affine=affine), 'dil_conv_5x5': lambda C, stride, affine: DilConv(C, C, 5, stride, 4, 2, affine=affine), 'conv_7x1_1x7': lambda C, stride, affine: nn.Sequential( nn.ReLU(inplace=False), nn.Conv2d(C, C, (1, 7), stride=(1, stride), padding=(0, 3), bias=False), nn.Conv2d(C, C, (7, 1), stride=(stride, 1), padding=(3, 0), bias=False), nn.BatchNorm2d(C, affine=affine)), }
def __init__(self, in_channels, out_channels, d_spectral_norm, leaky_relu, synchronized_bn, downsample=True): super(DiscBlock, self).__init__() self.d_spectral_norm = d_spectral_norm self.downsample = downsample if leaky_relu: self.activation = nn.LeakyReLU(negative_slope=0.1, inplace=True) else: self.activation = nn.ReLU(inplace=True) self.ch_mismatch = False if in_channels != out_channels: self.ch_mismatch = True if d_spectral_norm: if self.ch_mismatch or downsample: self.conv2d0 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0) self.conv2d1 = snconv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1) self.conv2d2 = snconv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1) else: if self.ch_mismatch or downsample: self.conv2d0 = conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0) self.conv2d1 = conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1) self.conv2d2 = conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=3, stride=1, padding=1) if synchronized_bn: if self.ch_mismatch or downsample: self.bn0 = sync_batchnorm_2d(in_features=in_channels) self.bn1 = sync_batchnorm_2d(in_features=in_channels) self.bn2 = sync_batchnorm_2d(in_features=out_channels) else: if self.ch_mismatch or downsample: self.bn0 = batchnorm_2d(in_features=in_channels) self.bn1 = batchnorm_2d(in_features=in_channels) self.bn2 = batchnorm_2d(in_features=out_channels) self.average_pooling = nn.AvgPool2d(2)
def forward(self, x): dim = x.size() pool = nn.AvgPool2d(dim[-1]) x = pool(x) return x.view(dim[0], dim[1])
def __init__(self, nIn, nOut, stride): super(DownsampleB, self).__init__() self.avg = nn.AvgPool2d(stride) self.expand_ratio = nOut // nIn
def create_modules(blocks, print_net=True): net_info = blocks[ 0] #Captures the information about the input and pre-processing module_list = nn.ModuleList() index = 0 #indexing blocks helps with implementing route layers (skip connections) prev_filters = 3 output_filters = [] for x in blocks: if (x["type"] == "net"): continue if (print_net is True): print(str(index) + " " + str(x)) module = nn.Sequential() #fx YOLO input layer if (x["type"] == "input"): module_list.append(module) output_filters.append(0) index += 1 continue #If it's a convolutional layer if (x["type"] == "convolutional" or x["type"] == "dilated_convolutional" ): #dilated_convolutional for deeplab #Get the info about the layer try: activation = x["activation"] except: activation = "" try: batch_normalize = int(x["batch_normalize"]) except: batch_normalize = 0 if batch_normalize > 0: bias = False else: bias = True filters = int(x["filters"]) padding = int(x.get("pad", 0)) try: kernel_size = int(x["size"]) kernel_size_w = kernel_size kernel_size_h = kernel_size except: kernel_size_w = int(x["size_w"]) kernel_size_h = int(x["size_h"]) stride = int(x["stride"]) rate = int(x.get("rate", 1)) groups = int(x.get("groups", 1)) if padding: pad = (kernel_size - 1) // 2 else: pad = 0 #Add the convolutional layer #conv = nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias = bias, dilation=rate) conv = nn.Conv2d(prev_filters, filters, (kernel_size_h, kernel_size_w), stride, pad, bias=bias, dilation=rate, groups=groups) if rate > 1: module.add_module("dilated_conv_{0}".format(index), conv) else: module.add_module("conv_{0}".format(index), conv) #Add the Batch Norm Layer if batch_normalize: bn = nn.BatchNorm2d(filters) module.add_module("batch_norm_{0}".format(index), bn) #Check the activation. #It is either Linear or a Leaky ReLU for YOLO if activation == "leaky": activn = nn.LeakyReLU(0.1, inplace=True) module.add_module("leaky_{0}".format(index), activn) #If it's an upsampling layer #We use Bilinear2dUpsampling elif (x["type"] == "upsample"): stride = int(x["stride"]) # upsample = Upsample(stride) upsample = nn.Upsample(scale_factor=2, mode="nearest") module.add_module("upsample_{}".format(index), upsample) #If it is a route layer elif (x["type"] == "route"): route = EmptyLayer() module.add_module("route_{0}".format(index), route) x["layers"] = x["layers"].split(',') filters = 0 for layer in x["layers"]: i = int(layer) if i > 0: i -= index if i < 0: filters += output_filters[index + i] ##Start of a route #start = int(x["layers"][0]) # ##end, if there exists one. #try: # end = int(x["layers"][1]) #except: # end = 0 # ##Positive anotation #if start > 0: # start = start - index # #if end > 0: # end = end - index # #if end < 0: # filters = output_filters[index + start] + output_filters[index + end] #else: # filters= output_filters[index + start] #shortcut corresponds to skip connection elif x["type"] == "shortcut": from_ = int(x["from"]) shortcut = EmptyLayer() module.add_module("shortcut_{}".format(index), shortcut) elif x["type"] == "maxpool": stride = int(x["stride"]) size = int(x["size"]) if stride != 1: maxpool = nn.MaxPool2d(size, stride) else: maxpool = MaxPoolStride1(size) module.add_module("maxpool_{}".format(index), maxpool) #Yolo is the detection layer elif x["type"] == "yolo": mask = x["mask"].split(",") mask = [int(x) for x in mask] anchors = x["anchors"].split(",") anchors = [int(a) for a in anchors] anchors = [(anchors[i], anchors[i + 1]) for i in range(0, len(anchors), 2)] anchors = [anchors[i] for i in mask] detection = DetectionLayer(anchors) module.add_module("Detection_{}".format(index), detection) elif x["type"] == "softmax": #for deeplab spatial = int(x["spatial"]) softmax = EmptyLayer() module.add_module("softmax_{}".format(index), softmax) elif x["type"] == "bilinear": #for deeplab stride = int(x["stride"]) bilinear = nn.UpsamplingBilinear2d(scale_factor=stride) module.add_module("bilinear_{}".format(index), bilinear) elif x["type"] == "avgpool": #for deeplab avgpool = nn.AvgPool2d(1) module.add_module("avgpool_{}".format(index), avgpool) #### #elif x["type"] == "connected":#for vgg16 # output = int(x["output"]) # connected = nn.Linear( ,output) elif x["type"] == "dropout": #for vgg16 dropout = nn.Dropout(p=0.5) module.add_module("dropout_{}".format(index), dropout) else: print("Something I dunno: " + x["type"]) assert False module_list.append(module) prev_filters = filters output_filters.append(filters) index += 1 return (net_info, module_list)
def _make_layer(self, block, planes, blocks, stride=1, dilate=False, replace_stride_with_avgpool=False): norm_name = self.norm_name norm_name_base = self.norm_name_base norm_groups = self.norm_groups norm_k = self.norm_k norm_attention_mode = self.norm_attention_mode norm_all_mix = self.norm_all_mix downsample = None previous_dilation = self.dilation if dilate: self.dilation *= stride stride = 1 downsample_op = [] if stride != 1 or self.inplanes != planes * block.expansion: downsample_stride = stride if replace_stride_with_avgpool and stride > 1: downsample_op.append(nn.AvgPool2d((stride, stride), stride)) downsample_stride = 1 downsample_op.append( conv1x1(self.inplanes, planes * block.expansion, downsample_stride)) downsample_op.append( FeatureNorm(norm_name_base, planes * block.expansion, num_groups=norm_groups, num_k=norm_k, attention_mode=norm_attention_mode)) if len(downsample_op) > 0: downsample = nn.Sequential(*downsample_op) layers = [] layers.append( block(self.inplanes, planes, stride, downsample, self.groups, base_width=self.base_width, dilation=previous_dilation, norm_name=norm_name, norm_groups=norm_groups, norm_k=norm_k, norm_attention_mode=norm_attention_mode, norm_all_mix=norm_all_mix)) self.inplanes = planes * block.expansion for _ in range(1, blocks): layers.append( block(self.inplanes, planes, groups=self.groups, base_width=self.base_width, dilation=self.dilation, norm_name=norm_name, norm_groups=norm_groups, norm_k=norm_k, norm_attention_mode=norm_attention_mode, norm_all_mix=norm_all_mix)) if self.extra_norm_ac: layers.append(self._extra_norm_ac(self.inplanes, norm_k)) return nn.Sequential(*layers)
def lua_recursive_model(module, seq): for m in module.modules: name = type(m).__name__ real = m if name == 'TorchObject': name = m._typename.replace('cudnn.', '') m = m._obj if name == 'SpatialConvolution' or name == 'nn.SpatialConvolutionMM': if not hasattr(m, 'groups') or m.groups is None: m.groups = 1 n = nn.Conv2d( m.nInputPlane, m.nOutputPlane, (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH), 1, m.groups, bias=(m.bias is not None)) copy_param(m, n) add_submodule(seq, n) elif name == 'SpatialBatchNormalization': n = nn.BatchNorm2d( m.running_mean.size(0), m.eps, m.momentum, m.affine) copy_param(m, n) add_submodule(seq, n) elif name == 'VolumetricBatchNormalization': n = nn.BatchNorm3d( m.running_mean.size(0), m.eps, m.momentum, m.affine) copy_param(m, n) add_submodule(seq, n) elif name == 'ReLU': n = nn.ReLU() add_submodule(seq, n) elif name == 'Sigmoid': n = nn.Sigmoid() add_submodule(seq, n) elif name == 'SpatialMaxPooling': n = nn.MaxPool2d( (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH), ceil_mode=m.ceil_mode) add_submodule(seq, n) elif name == 'SpatialAveragePooling': n = nn.AvgPool2d( (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH), ceil_mode=m.ceil_mode) add_submodule(seq, n) elif name == 'SpatialUpSamplingNearest': n = nn.UpsamplingNearest2d(scale_factor=m.scale_factor) add_submodule(seq, n) elif name == 'View': n = Lambda(lambda x: x.view(x.size(0), -1)) add_submodule(seq, n) elif name == 'Reshape': n = Lambda(lambda x: x.view(x.size(0), -1)) add_submodule(seq, n) elif name == 'Linear': # Linear in pytorch only accept 2D input n1 = Lambda(lambda x: x.view(1, -1) if 1 == len(x.size()) else x) n2 = nn.Linear( m.weight.size(1), m.weight.size(0), bias=(m.bias is not None)) copy_param(m, n2) n = nn.Sequential(n1, n2) add_submodule(seq, n) elif name == 'Dropout': m.inplace = False n = nn.Dropout(m.p) add_submodule(seq, n) elif name == 'SoftMax': n = nn.Softmax() add_submodule(seq, n) elif name == 'Identity': n = Lambda(lambda x: x) # do nothing add_submodule(seq, n) elif name == 'SpatialFullConvolution': n = nn.ConvTranspose2d(m.nInputPlane, m.nOutputPlane, (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH), (m.adjW, m.adjH)) copy_param(m, n) add_submodule(seq, n) elif name == 'VolumetricFullConvolution': n = nn.ConvTranspose3d(m.nInputPlane, m.nOutputPlane, (m.kT, m.kW, m.kH), (m.dT, m.dW, m.dH), (m.padT, m.padW, m.padH), (m.adjT, m.adjW, m.adjH), m.groups) copy_param(m, n) add_submodule(seq, n) elif name == 'SpatialReplicationPadding': n = nn.ReplicationPad2d((m.pad_l, m.pad_r, m.pad_t, m.pad_b)) add_submodule(seq, n) elif name == 'SpatialReflectionPadding': n = nn.ReflectionPad2d((m.pad_l, m.pad_r, m.pad_t, m.pad_b)) add_submodule(seq, n) elif name == 'Copy': n = Lambda(lambda x: x) # do nothing add_submodule(seq, n) elif name == 'Narrow': n = Lambda( lambda x, a=(m.dimension, m.index, m.length): x.narrow(*a)) add_submodule(seq, n) elif name == 'SpatialCrossMapLRN': lrn = lnn.SpatialCrossMapLRN(m.size, m.alpha, m.beta, m.k) n = Lambda(lambda x: Variable(lrn.forward(x.data))) add_submodule(seq, n) elif name == 'Sequential': n = nn.Sequential() lua_recursive_model(m, n) add_submodule(seq, n) elif name == 'ConcatTable': # output is list n = LambdaMap(lambda x: x) lua_recursive_model(m, n) add_submodule(seq, n) elif name == 'CAddTable': # input is list n = LambdaReduce(lambda x, y: x + y) add_submodule(seq, n) elif name == 'Concat': dim = m.dimension n = LambdaReduce(lambda x, y: torch.cat((x, y), dim)) lua_recursive_model(m, n) add_submodule(seq, n) elif name == 'SpatialZeroPadding': n = nn.ZeroPad2d([m.pad_l, m.pad_r, m.pad_t, m.pad_b]) add_submodule(seq, n) elif (name == 'SpatialUpSamplingBilinear' or name == 'nn.SpatialUpSamplingBilinear'): size = [m.oheight, m.owidth] if m.oheight is None or m.owidth is None: size = None n = nn.UpSample(size, m.scale_factor, mode='bilinear') add_submodule(seq, n) elif name == 'TorchObject': print('Not Implement', name, real._typename) else: print('Not Implement', name)
def __init__(self, block, layers, num_classes=10, embed_dim=10, hidden_dim=10, gate_type='rnn', in_planes=64): self.inplanes = in_planes super(ResNetRecurrentGateSP, self).__init__() self.num_layers = layers # self.conv1 = conv3x3(3, 16, input_signed=True, predictive_forward=False, writer_prefix='conv1') self.conv1 = conv3x3(3, in_planes, input_signed=True, predictive_forward=False, writer_prefix='conv1') # self.bn1 = nn.BatchNorm2d(16) self.bn1 = nn.BatchNorm2d(in_planes) self.relu = nn.ReLU(inplace=True) self.embed_dim = embed_dim self.hidden_dim = hidden_dim # self._make_group(block, 16, layers[0], group_id=1, pool_size=32, writer_prefix='group_1') # self._make_group(block, 32, layers[1], group_id=2, pool_size=16, writer_prefix='group_2') # self._make_group(block, 64, layers[2], group_id=3, pool_size=8, writer_prefix='group_3') if in_planes == 16: self._make_group(block, 16, layers[0], group_id=1, pool_size=32, writer_prefix='group_1') self._make_group(block, 32, layers[1], group_id=2, pool_size=16, writer_prefix='group_2') self._make_group(block, 64, layers[2], group_id=3, pool_size=8, writer_prefix='group_3') final_pool_size = 8 final_channel_number = 64 elif in_planes == 64: self._make_group(block, 64, layers[0], group_id=1, pool_size=32, writer_prefix='group_1') self._make_group(block, 128, layers[1], group_id=2, pool_size=16, writer_prefix='group_2') self._make_group(block, 256, layers[2], group_id=3, pool_size=8, writer_prefix='group_3') self._make_group(block, 512, layers[3], group_id=4, pool_size=4, writer_prefix='group_4') final_pool_size = 4 final_channel_number = 512 # define recurrent gating module # self.avgpool = nn.AvgPool2d(8) self.avgpool = nn.AvgPool2d(final_pool_size) print(num_classes) # self.fc = nn.Linear(64 * block.expansion, num_classes) self.fc = nn.Linear(final_channel_number * block.expansion, num_classes) for m in self.modules(): if isinstance(m, (nn.Conv2d, PredictiveConv2d)): 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): n = m.weight.size(0) * m.weight.size(1) m.weight.data.normal_(0, math.sqrt(2. / n))
def __init__(self, depth, step_size=2.0, momentum=0.5, num_classes=1000, block_name='BasicBlock', feature_vec='x'): super(MomentumNet, self).__init__() # Model type specifies number of layers for CIFAR-10 model if block_name.lower() == 'basicblock': assert ( depth - 2 ) % 6 == 0, 'When use basicblock, depth should be 6n+2, e.g. 20, 32, 44, 56, 110, 1202' n = (depth - 2) // 6 block = BasicBlock elif block_name.lower() == 'bottleneck': assert ( depth - 2 ) % 9 == 0, 'When use bottleneck, depth should be 9n+2, e.g. 20, 29, 47, 56, 110, 1199' n = (depth - 2) // 9 block = Bottleneck else: raise ValueError('block_name shoule be Basicblock or Bottleneck') self.inplanes = 16 # for momentum net self.step_size = step_size self.momentum = momentum self.feature_vec = feature_vec self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1, bias=False) self.layer1 = self._make_layer(block, 16, n, step_size=self.step_size, momentum=self.momentum) self.layer2 = self._make_layer(block, 32, n, stride=2, step_size=self.step_size, momentum=self.momentum) self.layer3 = self._make_layer(block, 64, n, stride=2, step_size=self.step_size, momentum=self.momentum) self.bn = nn.BatchNorm2d(64 * block.expansion) self.relu = nn.ReLU(inplace=True) self.avgpool = nn.AvgPool2d(8) self.fc = nn.Linear(64 * block.expansion, num_classes) self.loss = nn.CrossEntropyLoss() 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_()
def __init__(self, n_classes=42): super().__init__() self.conv1 = nn.Sequential( nn.Conv2d(in_channels=3, out_channels=32, kernel_size=7, stride=2), nn.ReLU(), nn.AvgPool2d(kernel_size=3, stride=2) ) self.conv2 = nn.Sequential( nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=2), nn.BatchNorm2d(64), nn.ReLU(), nn.AvgPool2d(kernel_size=3, stride=2) ) self.conv3 = nn.Sequential( nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(128), nn.ReLU(), ) self.conv4 = nn.Sequential( nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(256), nn.ReLU(), ) self.conv5 = nn.Sequential( nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1), nn.BatchNorm2d(256), nn.ReLU() ) self.conv6 = nn.Sequential( nn.Conv2d(in_channels=256, out_channels=256, kernel_size=2), nn.BatchNorm2d(256), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2) ) self.fc1 = nn.Sequential( nn.Linear(4 * 4 * 256, 2048), nn.BatchNorm1d(2048), nn.ReLU(), ) self.fc2 = nn.Sequential( nn.Linear(2048, 2048), nn.BatchNorm1d(2048), nn.ReLU() ) self.fc3 = nn.Sequential( nn.Linear(2048, 2048), nn.BatchNorm1d(2048), nn.ReLU() ) self.fc4 = nn.Sequential( nn.Linear(2048, n_classes), )
def __init__(self): super(Generator, self).__init__() self.det_conv0 = nn.Sequential(nn.Conv2d(4, 32, 3, 1, 1), nn.ReLU()) self.det_conv1 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(), nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU()) self.det_conv2 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(), nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU()) self.det_conv3 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(), nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU()) self.det_conv4 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(), nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU()) self.det_conv5 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(), nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU()) self.conv_i = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1), nn.Sigmoid()) self.conv_f = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1), nn.Sigmoid()) self.conv_g = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1), nn.Tanh()) self.conv_o = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1), nn.Sigmoid()) self.det_conv_mask = nn.Sequential(nn.Conv2d(32, 1, 3, 1, 1), #nn.Conv2d(64, 1, 3, 1, 1), ) self.conv1 = nn.Sequential( nn.Conv2d(4, 64, 5, 1, 2), #nn.BatchNorm2d(64), nn.ReLU()) self.conv2 = nn.Sequential( nn.Conv2d(64, 128, 3, 2, 1), #nn.BatchNorm2d(128), nn.ReLU()) self.conv3 = nn.Sequential( nn.Conv2d(128, 128, 3, 1, 1), #nn.BatchNorm2d(128), nn.ReLU()) self.conv4 = nn.Sequential( nn.Conv2d(128, 256, 3, 2, 1), #nn.BatchNorm2d(256), nn.ReLU()) self.conv5 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 1), #nn.BatchNorm2d(256), nn.ReLU()) self.conv6 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 1), #nn.BatchNorm2d(256), nn.ReLU()) self.diconv1 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 2, dilation=2), #nn.BatchNorm2d(256), nn.ReLU()) self.diconv2 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 4, dilation=4), #nn.BatchNorm2d(256), nn.ReLU()) self.diconv3 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 8, dilation=8), #nn.BatchNorm2d(256), nn.ReLU()) self.diconv4 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 16, dilation=16), #nn.BatchNorm2d(256) nn.ReLU()) self.conv7 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 1), #nn.BatchNorm2d(256), nn.ReLU()) self.conv8 = nn.Sequential( nn.Conv2d(256, 256, 3, 1, 1), #nn.BatchNorm2d(256), nn.ReLU()) self.deconv1 = nn.Sequential( nn.ConvTranspose2d(256, 128, 4, 2, 1), nn.ReflectionPad2d((1, 0, 1, 0)), nn.AvgPool2d(2, stride=1), #nn.BatchNorm2d(128), nn.ReLU()) self.conv9 = nn.Sequential( nn.Conv2d(128, 128, 3, 1, 1), #nn.BatchNorm2d(128), nn.ReLU()) self.deconv2 = nn.Sequential( nn.ConvTranspose2d(128, 64, 4, 2, 1), nn.ReflectionPad2d((1, 0, 1, 0)), nn.AvgPool2d(2, stride=1), #nn.BatchNorm2d(64), nn.ReLU()) self.conv10 = nn.Sequential( nn.Conv2d(64, 32, 3, 1, 1), #nn.BatchNorm2d(32), nn.ReLU()) self.outframe1 = nn.Sequential(nn.Conv2d(256, 3, 3, 1, 1), nn.ReLU()) self.outframe2 = nn.Sequential(nn.Conv2d(128, 3, 3, 1, 1), nn.ReLU()) self.output = nn.Sequential(nn.Conv2d(32, 3, 3, 1, 1), #nn.Sigmoid() )
def __init__(self, nIn, nOut, stride=2): super(DownsampleB, self).__init__() self.avg = nn.AvgPool2d(stride)
def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 32, 3, 2) self.conv2 = nn.Conv2d(N, 64, 3, 2) self.conv3 = nn.Conv2d(64, 10, 3, 1) self.GAP = nn.AvgPool2d((4, 4), stride=1, padding=0)
def transition_block(in_channels, out_channels): blk = nn.Sequential(nn.BatchNorm2d(in_channels), nn.ReLU(), nn.Conv2d(in_channels, out_channels, kernel_size=1), nn.AvgPool2d(kernel_size=2, stride=2)) return blk
def __init__(self, num_classes=1001): super(InceptionResNetV2, self).__init__() # Special attributs self.input_space = None self.input_size = (299, 299, 3) self.mean = None self.std = None # Modules self.conv2d_1a = BasicConv2d(3, 32, kernel_size=3, stride=2) self.conv2d_2a = BasicConv2d(32, 32, kernel_size=3, stride=1) self.conv2d_2b = BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1) self.maxpool_3a = nn.MaxPool2d(3, stride=2) self.conv2d_3b = BasicConv2d(64, 80, kernel_size=1, stride=1) self.conv2d_4a = BasicConv2d(80, 192, kernel_size=3, stride=1) self.maxpool_5a = nn.MaxPool2d(3, stride=2) self.mixed_5b = Mixed_5b() self.repeat = nn.Sequential( Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17), Block35(scale=0.17) ) self.mixed_6a = Mixed_6a() self.repeat_1 = nn.Sequential( Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10), Block17(scale=0.10) ) self.mixed_7a = Mixed_7a() self.repeat_2 = nn.Sequential( Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20), Block8(scale=0.20) ) self.block8 = Block8(no_relu=True) self.conv2d_7b = BasicConv2d(2080, 1536, kernel_size=1, stride=1) self.avgpool_1a = nn.AvgPool2d(8, count_include_pad=False) self.last_linear = nn.Linear(1536, num_classes)
def __init__(self, classes, n_way=2, n_shot=5, g=True, l=True, p=True): super(_narpnRCNN, self).__init__() self.classes = classes self.n_classes = len(classes) # loss self.RCNN_loss_cls = 0 self.RCNN_loss_bbox = 0 # define rpn self.RCNN_rpn = _RPN(self.dout_base_model) # for proposal-target matching self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes) # pooling or align self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0 / 16.0) self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE), 1.0 / 16.0, 0) # few shot rcnn head self.global_relation = g self.local_correlation = l self.patch_relation = p self.pool_feat_dim = 1024 self.soft_gamma = 1e1 self.avgpool = nn.AvgPool2d(14, stride=1) self.avgpool_fc = nn.AvgPool2d(7) self.patch_avgpool = nn.AvgPool2d(kernel_size=3, stride=1) dim_in = self.pool_feat_dim if self.global_relation: self.global_fc_1 = nn.Linear(dim_in * 2, dim_in) self.global_fc_2 = nn.Linear(dim_in, dim_in) self.global_cls_score = nn.Linear(dim_in, 2) #nn.Linear(dim_in, 2) init.normal_(self.global_fc_1.weight, std=0.01) init.constant_(self.global_fc_1.bias, 0) init.normal_(self.global_fc_2.weight, std=0.01) init.constant_(self.global_fc_2.bias, 0) init.normal_(self.global_cls_score.weight, std=0.01) init.constant_(self.global_cls_score.bias, 0) if self.local_correlation: self.corr_conv = nn.Conv2d(dim_in, dim_in, 1, padding=0, bias=False) #self.bbox_pred_cor = nn.Linear(dim_in, 4 * 2) self.corr_cls_score = nn.Linear(dim_in, 2) #nn.Linear(dim_in, 2) init.normal_(self.corr_conv.weight, std=0.01) init.normal_(self.corr_cls_score.weight, std=0.01) init.constant_(self.corr_cls_score.bias, 0) if self.patch_relation: self.patch_conv_1 = nn.Conv2d(2 * dim_in, int(dim_in / 4), 1, padding=0, bias=False) self.patch_conv_2 = nn.Conv2d(int(dim_in / 4), int(dim_in / 4), 3, padding=0, bias=False) self.patch_conv_3 = nn.Conv2d(int(dim_in / 4), dim_in, 1, padding=0, bias=False) self.patch_cls_score = nn.Linear(dim_in, 2) init.normal_(self.patch_conv_1.weight, std=0.01) init.normal_(self.patch_conv_2.weight, std=0.01) init.normal_(self.patch_conv_3.weight, std=0.01) init.normal_(self.patch_cls_score.weight, std=0.01) init.constant_(self.patch_cls_score.bias, 0) # few shot settings self.n_way = n_way self.n_shot = n_shot
def convMeanpool(inplanes, outplanes): sequence = [] sequence += [conv3x3(inplanes, outplanes)] sequence += [nn.AvgPool2d(kernel_size=2, stride=2)] return nn.Sequential(*sequence)
def __init__(self, block, layers, num_classes=1000, train=True): self.inplanes = 64 super(ResNet, self).__init__() self.istrain = train self.frames = 16 self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.conv1_t = MultiConv(planes=64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=1) self.avgpool = nn.AvgPool2d((16, 8), stride=1) self.num_features = 128 self.feat = nn.Linear(512 * block.expansion, self.num_features) self.feat_bn = nn.BatchNorm1d(self.num_features) self.feat_bn1 = nn.BatchNorm1d(self.num_features) self.feat_bn2 = nn.BatchNorm1d(self.num_features) self.feat_bn3 = nn.BatchNorm1d(self.num_features) self.drop = nn.Dropout(0.5) self.drop1 = nn.Dropout(0.5) self.drop2 = nn.Dropout(0.5) self.drop3 = nn.Dropout(0.5) self.classifier = nn.Linear(4 * self.num_features, 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.BatchNorm1d): m.weight.data.fill_(1) m.bias.data.zero_() elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_() elif isinstance(m, nn.BatchNorm3d): m.weight.data.fill_(1) m.bias.data.zero_() elif isinstance(m, nn.Linear): init.normal_(m.weight, std=0.001) init.constant_(m.bias, 0) init.kaiming_normal_(self.feat.weight, mode='fan_out') init.constant_(self.feat.bias, 0) self.feat1 = nn.Conv2d(1, 128, kernel_size=(3, 128), stride=1, dilation=(1, 1), padding=(1, 0), bias=False) self.feat2 = nn.Conv2d(1, 128, kernel_size=(3, 128), stride=1, dilation=(2, 1), padding=(2, 0), bias=False) self.feat3 = nn.Conv2d(1, 128, kernel_size=(3, 128), stride=1, dilation=(3, 1), padding=(3, 0), bias=False) init.normal_(self.feat1.weight, std=0.001) init.normal_(self.feat2.weight, std=0.001) init.normal_(self.feat3.weight, std=0.001)
def __init__(self, block, layers, groups, reduction, dropout_p=0.2, inplanes=128, input_3x3=True, downsample_kernel_size=3, downsample_padding=1, num_classes=1000): """ Parameters ---------- block (nn.Module): Bottleneck class. - For SENet154: SEBottleneck - For SE-ResNet models: SEResNetBottleneck - For SE-ResNeXt models: SEResNeXtBottleneck layers (list of ints): Number of residual blocks for 4 layers of the network (layer1...layer4). groups (int): Number of groups for the 3x3 convolution in each bottleneck block. - For SENet154: 64 - For SE-ResNet models: 1 - For SE-ResNeXt models: 32 reduction (int): Reduction ratio for Squeeze-and-Excitation modules. - For all models: 16 dropout_p (float or None): Drop probability for the Dropout layer. If `None` the Dropout layer is not used. - For SENet154: 0.2 - For SE-ResNet models: None - For SE-ResNeXt models: None inplanes (int): Number of input channels for layer1. - For SENet154: 128 - For SE-ResNet models: 64 - For SE-ResNeXt models: 64 input_3x3 (bool): If `True`, use three 3x3 convolutions instead of a single 7x7 convolution in layer0. - For SENet154: True - For SE-ResNet models: False - For SE-ResNeXt models: False downsample_kernel_size (int): Kernel size for downsampling convolutions in layer2, layer3 and layer4. - For SENet154: 3 - For SE-ResNet models: 1 - For SE-ResNeXt models: 1 downsample_padding (int): Padding for downsampling convolutions in layer2, layer3 and layer4. - For SENet154: 1 - For SE-ResNet models: 0 - For SE-ResNeXt models: 0 num_classes (int): Number of outputs in `last_linear` layer. - For all models: 1000 """ super(SENet, self).__init__() self.inplanes = inplanes if input_3x3: layer0_modules = [ ('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1, bias=False)), ('bn1', nn.BatchNorm2d(64)), ('relu1', nn.ReLU(inplace=True)), ('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1, bias=False)), ('bn2', nn.BatchNorm2d(64)), ('relu2', nn.ReLU(inplace=True)), ('conv3', nn.Conv2d(64, inplanes, 3, stride=1, padding=1, bias=False)), ('bn3', nn.BatchNorm2d(inplanes)), ('relu3', nn.ReLU(inplace=True)), ] else: layer0_modules = [ ('conv1', nn.Conv2d(3, inplanes, kernel_size=7, stride=2, padding=3, bias=False)), ('bn1', nn.BatchNorm2d(inplanes)), ('relu1', nn.ReLU(inplace=True)), ] # To preserve compatibility with Caffe weights `ceil_mode=True` # is used instead of `padding=1`. layer0_modules.append(('pool', nn.MaxPool2d(3, stride=2, ceil_mode=True))) self.layer0 = nn.Sequential(OrderedDict(layer0_modules)) self.layer1 = self._make_layer(block, planes=64, blocks=layers[0], groups=groups, reduction=reduction, downsample_kernel_size=1, downsample_padding=0) self.layer2 = self._make_layer( block, planes=128, blocks=layers[1], stride=2, groups=groups, reduction=reduction, downsample_kernel_size=downsample_kernel_size, downsample_padding=downsample_padding) self.layer3 = self._make_layer( block, planes=256, blocks=layers[2], stride=2, groups=groups, reduction=reduction, downsample_kernel_size=downsample_kernel_size, downsample_padding=downsample_padding) self.layer4 = self._make_layer( block, planes=512, blocks=layers[3], stride=2, groups=groups, reduction=reduction, downsample_kernel_size=downsample_kernel_size, downsample_padding=downsample_padding) self.avg_pool = nn.AvgPool2d(7, stride=1) self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None self.last_linear = nn.Linear(512 * block.expansion, num_classes)
def __init__(self, block, layers, groups, reduction, dropout_p=0.2, inplanes=128, input_3x3=True, downsample_kernel_size=3, downsample_padding=1, num_classes=1000): super(AttentionResNet, self).__init__() self.inplanes = inplanes if input_3x3: layer0_modules = [ ('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1, bias=False)), ('bn1', nn.BatchNorm2d(64)), ('relu1', nn.ReLU(inplace=True)), ('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1, bias=False)), ('bn2', nn.BatchNorm2d(64)), ('relu2', nn.ReLU(inplace=True)), ('conv3', nn.Conv2d(64, inplanes, 3, stride=1, padding=1, bias=False)), ('bn3', nn.BatchNorm2d(inplanes)), ('relu3', nn.ReLU(inplace=True)), ] else: layer0_modules = [ ('conv1', nn.Conv2d(3, inplanes, kernel_size=7, stride=2, padding=3, bias=False)), ('bn1', nn.BatchNorm2d(inplanes)), ('relu1', nn.ReLU(inplace=True)), ] # To preserve compatibility with Caffe weights `ceil_mode=True` # is used instead of `padding=1`. layer0_modules.append(('pool', nn.MaxPool2d(3, stride=2, ceil_mode=True))) self.layer0 = nn.Sequential(OrderedDict(layer0_modules)) self.layer1 = self._make_layer(block, planes=64, blocks=layers[0], groups=groups, reduction=reduction, downsample_kernel_size=1, downsample_padding=0) self.layer2 = self._make_layer( block, planes=128, blocks=layers[1], stride=2, groups=groups, reduction=reduction, downsample_kernel_size=downsample_kernel_size, downsample_padding=downsample_padding) self.layer3 = self._make_layer( block, planes=256, blocks=layers[2], stride=2, groups=groups, reduction=reduction, downsample_kernel_size=downsample_kernel_size, downsample_padding=downsample_padding) self.layer4 = self._make_layer( block, planes=512, blocks=layers[3], stride=2, groups=groups, reduction=reduction, downsample_kernel_size=downsample_kernel_size, downsample_padding=downsample_padding) self.avg_pool = nn.AvgPool2d(7, stride=1) self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None self.last_linear = nn.Linear(512 * block.expansion, num_classes)
def __init__(self): super(Net, self).__init__() # Input Block self.convblock1 = nn.Sequential( nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(3, 3), padding=0, bias=False), nn.ReLU(), nn.BatchNorm2d(32)) #i/p=32, output_size = 30 Rf 3 Jout - 1 # CONVOLUTION BLOCK 1 self.convblock2 = nn.Sequential( nn.Conv2d(in_channels=32, out_channels=128, kernel_size=(3, 3), padding=2, bias=False), nn.ReLU(), nn.BatchNorm2d(128)) # i/p=30,output_size = 32 RF 5 Jout -1 self.depthwise = nn.Conv2d(128, 128, kernel_size=3, padding=1, groups=128) self.pointwise = nn.Conv2d(128, 64, kernel_size=1) #self.convblock3 = nn.Sequential( # nn.Conv2d(in_channels=64, out_channels=64, kernel_size=(1, 1), padding=0, bias=False), #) # i/p=30,output_size = 32 RF 5 Jout -1 # TRANSITION BLOCK 1 self.pool1 = nn.MaxPool2d(2, 2) # i./p=32,output_size = 16 RF 6 Jout - 2 # CONVOLUTION BLOCK 2 self.convblock4 = nn.Sequential( nn.Conv2d(in_channels=64, out_channels=128, kernel_size=(3, 3), padding=0, bias=False, dilation=2), ##dilation nn.ReLU(), nn.BatchNorm2d(128)) #i/p=16 output_size =12 RF 14 Jout - 2 # TRANSITION BLOCK 2 self.pool2 = nn.MaxPool2d(2, 2) #i/p=12 output_size = 6 RF 16 Jout - 4 #CONVOLUTION BLOCK 3 self.convblock5 = nn.Sequential( nn.Conv2d(in_channels=128, out_channels=128, kernel_size=(3, 3), padding=2, bias=False), nn.ReLU(), nn.BatchNorm2d(128)) # i/p=6,output_size =8 RF -24 ,Jout - 4 # TRANSITION BLOCK 3 self.pool3 = nn.MaxPool2d(2, 2) # i/p=8,output_size = 4 RF 32 Jout - 8 #CONVOLUTION BLOCK 4 self.convblock6 = nn.Sequential( nn.Conv2d(in_channels=128, out_channels=64, kernel_size=(3, 3), padding=1, bias=False), nn.ReLU(), nn.BatchNorm2d(64)) # i/p=4,output_size =4 RF 48 Jout - 8 # OUTPUT BLOCK self.gap = nn.Sequential( nn.AvgPool2d(kernel_size=4)) # output_size = 1 self.convblock9 = nn.Sequential( nn.Conv2d(in_channels=64, out_channels=10, kernel_size=(1, 1), padding=0, bias=False), )
def __init__(self, pretrained=True, average_pool=True, semantic=True, final_dim=1024): """ :param average_pool: whether or not to average pool the representations :param pretrained: Whether we need to load from scratch :param semantic: Whether or not we want to introduce the mask and the class label early on (default Yes) """ super(SimpleDetector, self).__init__() # huge thx to https://github.com/ruotianluo/pytorch-faster-rcnn/blob/master/lib/nets/resnet_v1.py backbone = _load_resnet_imagenet( pretrained=pretrained ) if USE_IMAGENET_PRETRAINED else _load_resnet(pretrained=pretrained) self.backbone = nn.Sequential( backbone.conv1, backbone.bn1, backbone.relu, backbone.maxpool, backbone.layer1, backbone.layer2, backbone.layer3, # backbone.layer4 ) self.newbackbone = nn.Sequential(backbone.conv1, backbone.bn1, backbone.relu, backbone.maxpool, backbone.layer1, backbone.layer2, backbone.layer3, backbone.layer4) self.roi_align = ROIAlign((7, 7) if USE_IMAGENET_PRETRAINED else (14, 14), spatial_scale=1 / 16, sampling_ratio=0) if semantic: self.mask_dims = 32 self.object_embed = torch.nn.Embedding(num_embeddings=81, embedding_dim=128) self.mask_upsample = torch.nn.Conv2d( 1, self.mask_dims, kernel_size=3, stride=2 if USE_IMAGENET_PRETRAINED else 1, padding=1, bias=True) else: self.object_embed = None self.mask_upsample = None after_roi_align = [backbone.layer4] self.final_dim = final_dim if average_pool: after_roi_align += [nn.AvgPool2d(7, stride=1), Flattener()] self.after_roi_align = torch.nn.Sequential(*after_roi_align) self.obj_downsample = torch.nn.Sequential( torch.nn.Dropout(p=0.1), torch.nn.Linear(2048 + (128 if semantic else 0), final_dim), torch.nn.ReLU(inplace=True), ) self.regularizing_predictor = torch.nn.Linear(2048, 81)
def _compute_grad_weights(self, grads): grads = self._normalize(grads) self.map_size = grads.size()[2:] return nn.AvgPool2d(self.map_size)(grads)
def __init__(self, in_channels: int = 3, num_classes=1000, expand_factor: int = 2): super(DeeperSimpleNet, self).__init__() mult = [32, 32, 64, 128] * expand_factor print('build deepersimplenet with in_channel {}, and out_channel {}'. format(in_channels, num_classes)) self.model = nn.Sequential( # x112x112 --> x56x56 nn.Conv2d(in_channels=in_channels, out_channels=mult[0], kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(num_features=mult[0]), nn.ReLU(inplace=True), nn.Conv2d(in_channels=mult[0], out_channels=mult[0], kernel_size=3, stride=1, padding=0), nn.BatchNorm2d(num_features=mult[0]), nn.ReLU(inplace=True), # x56x56 --> x28x28 nn.Conv2d(in_channels=mult[0], out_channels=mult[1], kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(num_features=mult[1]), nn.ReLU(inplace=True), nn.Conv2d(in_channels=mult[1], out_channels=mult[1], kernel_size=3, stride=1, padding=0), nn.BatchNorm2d(num_features=mult[1]), nn.ReLU(inplace=True), # x28x28 --> x14x14 nn.Conv2d(in_channels=mult[1], out_channels=mult[2], kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(num_features=mult[2]), nn.ReLU(inplace=True), nn.Conv2d(in_channels=mult[2], out_channels=mult[2], kernel_size=3, stride=1, padding=0), nn.BatchNorm2d(num_features=mult[2]), nn.ReLU(inplace=True), # x14x14 --> x7x7 nn.Conv2d(in_channels=mult[2], out_channels=mult[3], kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(num_features=mult[3]), nn.ReLU(inplace=True), nn.Conv2d(in_channels=mult[3], out_channels=mult[3], kernel_size=3, stride=1, padding=0), nn.BatchNorm2d(num_features=mult[3]), nn.ReLU(inplace=True), # pooling --> x1x1 nn.AvgPool2d(4)) self.num_nn = mult[3] self.fc = nn.Sequential( nn.Linear(in_features=self.num_nn, out_features=512, bias=True), nn.ReLU(inplace=True)) self.critic_linear = nn.Linear(512, 1) self.cls_linear = Categorical(512, num_classes) # classification 分类器 self.train() # 设置成训练模式 self.apply(weights_init) # 初始化相关参数
def __init__(self, block, layers, num_classes=1000): self.inplanes = 64 super(ResNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) # 64*64*64 # bottom-up self.layer1 = self._make_layer(block, 64, layers[0]) # 256*64*64 self.layer2 = self._make_layer(block, 128, layers[1], stride=2) # 512*32*32 self.layer3 = self._make_layer(block, 256, layers[2], stride=2) # 1024*16*16 self.layer4 = self._make_layer(block, 512, layers[3], stride=2) # 2048*8*8 self.avgpool = nn.AvgPool2d(7) # 2048*1*1 # top-down self.td_1 = self._make_top_down_layer(512 * block.expansion, 256 * block.expansion) # 1024*8*8 self.td_2 = self._make_top_down_layer(256 * block.expansion, 128 * block.expansion) # 512*16*16 self.td_3 = self._make_top_down_layer(128 * block.expansion, 64 * block.expansion) # 256*32*32 # extra conv layers self.p1_conv = self._make_conv_bn(256 * block.expansion, 256, 3, padding=0, stride=2, use_relu=True) # 256*4*4 self.p2_conv = self._make_conv_bn(256 * block.expansion, 256, 3, padding=0, stride=2, use_relu=True) # 256*8*8 self.p3_conv = self._make_conv_bn(128 * block.expansion, 256, 3, padding=0, stride=2, use_relu=True) # 256*16*16 self.p4_conv = self._make_conv_bn(64 * block.expansion, 256, 3, padding=0, stride=2, use_relu=True) # 256*32*32 # classification layer self.cls1 = nn.Linear(256, out_features=num_classes, bias=True) self.cls2 = nn.Linear(2304, out_features=num_classes, bias=True) self.cls3 = nn.Linear(12544, out_features=num_classes, bias=True) self.cls4 = nn.Linear(57600, out_features=num_classes, bias=True) 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_()
def __init__(self, n_head, n_mix, d_model, d_k, d_v, norm_layer=BatchNorm2d, kq_transform='conv', value_transform='conv', pooling=True, concat=False, dropout=0.1): super(SelfTrans, self).__init__() self.n_head = n_head self.n_mix = n_mix self.d_k = d_k self.d_v = d_v self.pooling = pooling self.concat = concat if self.pooling: self.pool = nn.AvgPool2d(3, 2, 1, count_include_pad=False) if kq_transform == 'conv': self.conv_qs = nn.Conv2d(d_model, n_head * d_k, 1) nn.init.normal_(self.conv_qs.weight, mean=0, std=np.sqrt(2.0 / (d_model + d_k))) elif kq_transform == 'ffn': self.conv_qs = nn.Sequential( nn.Conv2d(d_model, n_head * d_k, 3, padding=1, bias=False), norm_layer(n_head * d_k), nn.ReLU(True), nn.Conv2d(n_head * d_k, n_head * d_k, 1), ) nn.init.normal_(self.conv_qs[-1].weight, mean=0, std=np.sqrt(1.0 / d_k)) elif kq_transform == 'dffn': self.conv_qs = nn.Sequential( nn.Conv2d(d_model, n_head * d_k, 3, padding=4, dilation=4, bias=False), norm_layer(n_head * d_k), nn.ReLU(True), nn.Conv2d(n_head * d_k, n_head * d_k, 1), ) nn.init.normal_(self.conv_qs[-1].weight, mean=0, std=np.sqrt(1.0 / d_k)) else: raise NotImplemented self.conv_ks = self.conv_qs if value_transform == 'conv': self.conv_vs = nn.Conv2d(d_model, n_head * d_v, 1) else: raise NotImplemented nn.init.normal_(self.conv_vs.weight, mean=0, std=np.sqrt(2.0 / (d_model + d_v))) self.attention = MixtureOfSoftMax(n_mix=n_mix, d_k=d_k) self.conv = nn.Conv2d(n_head * d_v, d_model, 1, bias=False) self.norm_layer = norm_layer(d_model)
def train_net(images, net, lr=1e-3, n_epochs_auxiliary=1000, n_epochs_blockwise=500, batch_size=20, block_size=32, save_path='trained_model.pt'): """Trains a network on images, and save the network. :param images: list of torch.tensor on CUDA, each of shape (1, 4, Y, X) (Y and X can be different accross images) :param net: nn.Module, network to train or retrain. :param n_epochs_auxiliary: int, number of epochs on the auxiliary training net. Default: 1000 :param n_epochs_blockwise: int, number of epochs on the final blockwise net. Default: 500 :param batch_size: int. Default: 20 :param block_size: int. Default: 32 :param save_path: string, where to write the trained model. Default: 'trained_model.pt'. """ #writer = SummaryWriter('runs/Adaptive CFA Forensics') running_loss = 0.0 criterion = SelfPixelwiseNLLLoss().cuda() optim = torch.optim.Adam(net.auxiliary.parameters(), lr=lr) optim.zero_grad() for epoch in trange(n_epochs_auxiliary): random.shuffle(images) for i_img, img in enumerate(images): o = net.auxiliary(img) loss = criterion(o, global_best=True) loss.backward() running_loss += loss.item() if (i_img + 1) % batch_size == 0: optim.step() optim.zero_grad() writer.add_scalar('training loss auxiliary', running_loss / 1000, epoch) running_loss = 0.0 first_processor = nn.Sequential(net.spatial, net.pixelwise, net.grids, nn.AvgPool2d(block_size)) images = [ torch.tensor(first_processor(img).detach().cpu().numpy()).cuda() for img in images ] #Make sure no gradient stays criterion = SelfNLLLoss().cuda() optim = torch.optim.Adam(net.blockwise.parameters(), lr=lr) optim.zero_grad() running_loss = 0.0 for epoch in trange(n_epochs_blockwise): random.shuffle(images) for i_img, img in enumerate(images): o = net.blockwise(img) loss = criterion(o, global_best=True) loss.backward() running_loss += loss.item() if (i_img + 1) % batch_size == 0: optim.step() optim.zero_grad() writer.add_scalar('training loss blockwise', running_loss / 1000, epoch) running_loss = 0.0 torch.save(net.state_dict(), save_path)