def __init__(self): super(ModelConv, self).__init__() with supernet(kernel_size=(3, 5, 7), channel=((4, 8, 12), (8, 12, 16), (8, 12, 16), (8, 12, 16))) as ofa_super: models = [] models += [nn.Conv2D(3, 4, 3, padding=1)] models += [nn.InstanceNorm(4)] models += [ReLU()] models += [nn.Conv2D(4, 4, 3, groups=4)] models += [nn.InstanceNorm(4)] models += [ReLU()] models += [ nn.Conv2DTranspose(4, 4, 3, groups=4, padding=1, use_cudnn=True) ] models += [nn.BatchNorm(4)] models += [ReLU()] models += [nn.Conv2D(4, 3, 3)] models += [ReLU()] models = ofa_super.convert(models) models += [ Block(SuperSeparableConv2D(3, 6, 1, padding=1, candidate_config={'channel': (3, 6)}), fixed=True) ] with supernet(kernel_size=(3, 5, 7), expand_ratio=(1, 2, 4)) as ofa_super: models1 = [] models1 += [nn.Conv2D(6, 4, 3)] models1 += [nn.BatchNorm(4)] models1 += [ReLU()] models1 += [nn.Conv2D(4, 4, 3, groups=2)] models1 += [nn.InstanceNorm(4)] models1 += [ReLU()] models1 += [nn.Conv2DTranspose(4, 4, 3, groups=2)] models1 += [nn.BatchNorm(4)] models1 += [ReLU()] models1 += [nn.Conv2DTranspose(4, 4, 3)] models1 += [nn.BatchNorm(4)] models1 += [ReLU()] models1 = ofa_super.convert(models1) models += models1 self.models = paddle.nn.Sequential(*models)
def __init__( self, in_channels=[1024, 1024], mid_channels=[1024, 1024], out_channels=2048, ds_scales=[(1, 1, 1), (1, 1, 1)], ): super(LevelFusion, self).__init__() ops = [] num_ins = len(in_channels) for i in range(num_ins): op = Downampling(in_channels[i], mid_channels[i], kernel_size=(1, 1, 1), stride=(1, 1, 1), padding=(0, 0, 0), bias=False, groups=32, norm=True, activation=True, downsample_position='before', downsample_scale=ds_scales[i]) ops.append(op) self.ops = Sequential(*ops) in_dims = np.sum(mid_channels) self.fusion_conv = Sequential( nn.Conv3D(in_dims, out_channels, 1, 1, 0, bias_attr=False), nn.BatchNorm(out_channels), Relu())
def __init__( self, inplanes, planes, kernel_size=(3, 1, 1), stride=(1, 1, 1), padding=(1, 0, 0), bias=False, groups=1, norm=False, activation=False, downsample_position='after', downsample_scale=(1, 2, 2), ): super(Downampling, self).__init__() self.conv = nn.Conv3D(inplanes, planes, kernel_size, stride, padding, bias_attr=bias, groups=groups) self.norm = nn.BatchNorm(planes) if norm else None self.relu = Relu() if activation else None assert (downsample_position in ['before', 'after']) self.downsample_position = downsample_position self.pool = MaxPool3D(downsample_scale, downsample_scale, (0, 0, 0), ceil_mode=True)
def __init__(self, in_channels, out_channels, in_size, is_bias=True, is_bn=True, is_relu=True, is_test=False): super(FCBNReluLayer, self).__init__() self.is_bn = is_bn self.is_relu = is_relu if is_bias: bias_init = fluid.ParamAttr( initializer=fluid.initializer.ConstantInitializer(0.)) else: bias_init = False self.linear = nn.Linear(in_channels * in_size * in_size, out_channels, bias_attr=bias_init) self.bn = nn.BatchNorm(out_channels, param_attr=norm_weight_init(), bias_attr=norm_bias_init(), act=None, momentum=0.9, use_global_stats=is_test)
def __init__(self, in_channels, out_channels, filter_size, stride=1, padding=0, dilation=1, groups=1, bn_init_constant=1.0): super(ConvBNLayer, self).__init__() self.conv = nn.Conv2D(num_channels=in_channels, filter_size=filter_size, num_filters=out_channels, stride=stride, padding=padding, dilation=dilation, groups=groups, param_attr=weight_init(), bias_attr=False) self.bn = nn.BatchNorm(out_channels, param_attr=norm_weight_init(bn_init_constant), bias_attr=norm_bias_init(), act=None, momentum=0.1, use_global_stats=True)
def make_res_layer(block, inplanes, planes, blocks, spatial_stride=1, temporal_stride=1, dilation=1, style='pytorch', inflate_freq=1, inflate_style='3x1x1', nonlocal_freq=1, nonlocal_cfg=None, with_cp=False): inflate_freq = inflate_freq if not isinstance(inflate_freq, int) else (inflate_freq,) * blocks nonlocal_freq = nonlocal_freq if not isinstance(nonlocal_freq, int) else (nonlocal_freq,) * blocks assert len(inflate_freq) == blocks assert len(nonlocal_freq) == blocks downsample = None if spatial_stride != 1 or inplanes != planes * block.expansion: downsample = Sequential( nn.Conv3D( inplanes, planes * block.expansion, filter_size=1, stride=(temporal_stride, spatial_stride, spatial_stride), bias_attr=False), nn.BatchNorm(planes * block.expansion), ) layers = [] layers.append( block( inplanes, planes, spatial_stride, temporal_stride, dilation, downsample, style=style, if_inflate=(inflate_freq[0] == 1), inflate_style=inflate_style, if_nonlocal=(nonlocal_freq[0] == 1), nonlocal_cfg=nonlocal_cfg, with_cp=with_cp)) inplanes = planes * block.expansion for i in range(1, blocks): layers.append( block(inplanes, planes, 1, 1, dilation, style=style, if_inflate=(inflate_freq[i] == 1), inflate_style=inflate_style, if_nonlocal=(nonlocal_freq[i] == 1), nonlocal_cfg=nonlocal_cfg, with_cp=with_cp)) return Sequential(*layers)
def __init__(self, num_channels, num_filters, is_test=False): super(AdjustLayer, self).__init__() self.conv = nn.Conv2D(num_channels=num_channels, num_filters=num_filters, filter_size=1, param_attr=weight_init(), bias_attr=False) self.bn = nn.BatchNorm(num_channels=num_filters, param_attr=norm_weight_init(), bias_attr=norm_bias_init(), momentum=0.9, act=None, use_global_stats=is_test)
def __init__( self, inplanes, planes, kernel_size, stride, padding, bias=False, groups=1, ): super(ConvModule, self).__init__() self.conv = nn.Conv3D(inplanes, planes, kernel_size, stride, padding, bias_attr=bias, groups=groups) self.bn = nn.BatchNorm(planes) self.relu = Relu()
def __init__(self, in_channels, out_channels, filter_size, stride=1, groups=1, padding=1, is_test=False): super(ConvBNReluLayer, self).__init__() self.conv = nn.Conv2D(num_channels=in_channels, filter_size=filter_size, num_filters=out_channels, stride=stride, padding=padding, groups=groups, bias_attr=bias_init(), param_attr=weight_init()) self.bn = nn.BatchNorm(out_channels, param_attr=norm_weight_init(), bias_attr=norm_bias_init(), act=None, momentum=0.9, use_global_stats=is_test)
def __init__(self, in_channels=[256, 512, 1024, 2048], out_channels=256, spatial_modulation_config=None, temporal_modulation_config=None, upsampling_config=None, downsampling_config=None, level_fusion_config=None, aux_head_config=None, mode=None): super(TPN, self).__init__() assert isinstance(in_channels, list) assert isinstance(out_channels, int) self.in_channels = in_channels self.out_channels = out_channels self.num_ins = len(in_channels) self.mode = mode # spatial_modulation_config = Config(spatial_modulation_config) if isinstance(spatial_modulation_config, # dict) else spatial_modulation_config # temporal_modulation_config = Config(temporal_modulation_config) if isinstance(temporal_modulation_config, # dict) else temporal_modulation_config # upsampling_config = Config(upsampling_config) if isinstance(upsampling_config, dict) else upsampling_config # downsampling_config = Config(downsampling_config) if isinstance(downsampling_config, # dict) else downsampling_config # aux_head_config = Config(aux_head_config) if isinstance(aux_head_config, dict) else aux_head_config # level_fusion_config = Config(level_fusion_config) if isinstance(level_fusion_config, # dict) else level_fusion_config # self.temporal_modulation_ops = nn.ModuleList() # self.upsampling_ops = nn.ModuleList() # self.downsampling_ops = nn.ModuleList() temp_modulation_ops = [] temp_upsampling_ops = [] temp_downsampling_ops = [] for i in range(0, self.num_ins, 1): inplanes = in_channels[-1] planes = out_channels if temporal_modulation_config is not None: # overwrite the temporal_modulation_config # print(temporal_modulation_config) temporal_modulation_config['param'][ 'downsample_scale'] = temporal_modulation_config['scales'][ i] temporal_modulation_config['param']['inplanes'] = inplanes temporal_modulation_config['param']['planes'] = planes temporal_modulation = TemporalModulation( **temporal_modulation_config['param']) temp_modulation_ops.append(temporal_modulation) self.temporal_modulation_ops = Sequential(*temp_modulation_ops) if i < self.num_ins - 1: if upsampling_config is not None: # overwrite the upsampling_config upsampling = Upsampling(**upsampling_config) temp_upsampling_ops.append(upsampling) self.upsampling_ops = Sequential(*temp_upsampling_ops) if downsampling_config is not None: # overwrite the downsampling_config downsampling_config['param']['inplanes'] = planes downsampling_config['param']['planes'] = planes downsampling_config['param'][ 'downsample_scale'] = downsampling_config['scales'] downsampling = Downampling(**downsampling_config['param']) temp_downsampling_ops.append(downsampling) self.downsampling_ops = Sequential(*temp_downsampling_ops) self.level_fusion_op = LevelFusion() # **level_fusion_config self.spatial_modulation = SpatialModulation( ) # **spatial_modulation_config out_dims = level_fusion_config['out_channels'] # Two pyramids self.level_fusion_op2 = LevelFusion(**level_fusion_config) self.pyramid_fusion_op = Sequential( nn.Conv3D(out_dims * 2, 2048, 1, 1, 0, bias_attr=False), nn.BatchNorm(2048), Relu()) # overwrite aux_head_config if aux_head_config is not None: aux_head_config['inplanes'] = self.in_channels[-2] self.aux_head = AuxHead(**aux_head_config) else: self.aux_head = None
def layer_init(self): # for conv1 self.conv1 = nn.Conv2D(num_channels=3, num_filters=96, filter_size=11, stride=2, padding=0, groups=1, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn1 = nn.BatchNorm(num_channels=96, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) self.pool1 = nn.Pool2D(pool_size=3, pool_type="max", pool_stride=2, pool_padding=0) # for conv2 self.conv2 = nn.Conv2D(num_channels=96, num_filters=256, filter_size=5, stride=1, padding=0, groups=2, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn2 = nn.BatchNorm(num_channels=256, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) self.pool2 = nn.Pool2D(pool_size=3, pool_type="max", pool_stride=2, pool_padding=0) # for conv3 self.conv3 = nn.Conv2D(num_channels=256, num_filters=384, filter_size=3, stride=1, padding=0, groups=1, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn3 = nn.BatchNorm(num_channels=384, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) # for conv4 self.conv4 = nn.Conv2D(num_channels=384, num_filters=384, filter_size=3, stride=1, padding=0, groups=2, param_attr=self.weight_init(), bias_attr=self.bias_init()) self.bn4 = nn.BatchNorm(num_channels=384, is_test=self.is_test, param_attr=self.norm_weight_init(), bias_attr=self.bias_init(), use_global_stats=self.is_test) # for conv5 self.conv5 = nn.Conv2D(num_channels=384, num_filters=256, filter_size=3, stride=1, padding=0, groups=2, param_attr=self.weight_init(), bias_attr=self.bias_init())
def __init__(self, inplanes, planes, spatial_stride=1, temporal_stride=1, dilation=1, downsample=None, style='pytorch', if_inflate=True, inflate_style='3x1x1', if_nonlocal=True, nonlocal_cfg=None, with_cp=False): """Bottleneck block for ResNet. If style is "pytorch", the stride-two layer is the 3x3 conv layer, if it is "caffe", the stride-two layer is the first 1x1 conv layer. """ super(Bottleneck, self).__init__() assert style in ['pytorch', 'caffe'] assert inflate_style in ['3x1x1', '3x3x3'] self.inplanes = inplanes self.planes = planes if style == 'pytorch': self.conv1_stride = 1 self.conv2_stride = spatial_stride self.conv1_stride_t = 1 self.conv2_stride_t = temporal_stride else: self.conv1_stride = spatial_stride self.conv2_stride = 1 self.conv1_stride_t = temporal_stride self.conv2_stride_t = 1 if if_inflate: if inflate_style == '3x1x1': self.conv1 = nn.Conv3D( inplanes, planes, filter_size=(3, 1, 1), stride=(self.conv1_stride_t, self.conv1_stride, self.conv1_stride), padding=(1, 0, 0), bias_attr=False) self.conv2 = nn.Conv3D( planes, planes, filter_size=(1, 3, 3), stride=(self.conv2_stride_t, self.conv2_stride, self.conv2_stride), padding=(0, dilation, dilation), dilation=(1, dilation, dilation), bias_attr=False) else: self.conv1 = nn.Conv3D( inplanes, planes, filter_size=1, stride=(self.conv1_stride_t, self.conv1_stride, self.conv1_stride), bias_attr=False) self.conv2 = nn.Conv3D( planes, planes, filter_size=3, stride=(self.conv2_stride_t, self.conv2_stride, self.conv2_stride), padding=(1, dilation, dilation), dilation=(1, dilation, dilation), bias_attr=False) else: self.conv1 = nn.Conv3D( inplanes, planes, filter_size=1, stride=(1, self.conv1_stride, self.conv1_stride), bias_attr=False) self.conv2 = nn.Conv3D( planes, planes, filter_size=(1, 3, 3), stride=(1, self.conv2_stride, self.conv2_stride), padding=(0, dilation, dilation), dilation=(1, dilation, dilation), bias_attr=False) self.bn1 = nn.BatchNorm(planes) self.bn2 = nn.BatchNorm(planes) self.conv3 = nn.Conv3D( planes, planes * self.expansion, filter_size=1, bias_attr=False) self.bn3 = nn.BatchNorm(planes * self.expansion) self.relu = Relu() self.downsample = downsample self.spatial_tride = spatial_stride self.temporal_tride = temporal_stride self.dilation = dilation self.with_cp = with_cp