def __init__(self, ch_in, ch_out): super(ConvBlock, self).__init__() self.conv = nn.Sequential( nn.Conv2D(ch_in, ch_out, kernel_size=3, stride=1, padding=1), nn.BatchNorm2D(ch_out), nn.ReLU(), nn.Conv2D(ch_out, ch_out, kernel_size=3, stride=1, padding=1), nn.BatchNorm2D(ch_out), nn.ReLU())
def __init__(self, num_classes=16, max_points=1024): super(VFE_Clas, self).__init__() self.vfe = VFE(max_points=max_points) self.fc = self.fc = nn.Sequential(nn.Linear(max_points, 512), nn.ReLU(), nn.Linear(512, 256), nn.ReLU(), nn.Dropout(p=0.7), nn.Linear(256, num_classes))
def __init__(self, block, depth, class_dim=1000, with_pool=True): super(RedNet, self).__init__(block=block, depth=50, num_classes=class_dim, with_pool=with_pool) layer_cfg = { 26: [1, 2, 4, 1], 38: [2, 3, 5, 2], 50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3], } layers = layer_cfg[depth] self.conv1 = None self.bn1 = None self.relu = None self.inplanes = 64 self.class_dim = class_dim self.stem = nn.Sequential( nn.Sequential( ( "conv", nn.Conv2D( in_channels=3, out_channels=self.inplanes // 2, kernel_size=3, stride=2, padding=1, bias_attr=False, ), ), ("bn", nn.BatchNorm2D(self.inplanes // 2)), ("activate", nn.ReLU()), ), Involution(self.inplanes // 2, 3, 1), nn.BatchNorm2D(self.inplanes // 2), nn.ReLU(), nn.Sequential( ( "conv", nn.Conv2D( in_channels=self.inplanes // 2, out_channels=self.inplanes, kernel_size=3, stride=1, padding=1, bias_attr=False, ), ), ("bn", nn.BatchNorm2D(self.inplanes)), ("activate", nn.ReLU()), ), ) 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=2)
def batch_relu_conv3d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bn3d=True, conv_param_attr=nn.initializer.KaimingNormal(), conv_bias_attr=False, bn_param_attr=None, bn_bias_attr=None): if bn3d: # 3D batchnorm + relu + convolutional layer return nn.Sequential( nn.BatchNorm3D(num_features=in_channels), nn.ReLU(), nn.Conv3D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, padding=padding, stride=stride, weight_attr=conv_param_attr, bias_attr=conv_bias_attr)) else: # 3D relu + convolutional layer return nn.Sequential( nn.ReLU(), nn.Conv3D(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, padding=padding, stride=stride, weight_attr=conv_param_attr, bias_attr=conv_bias_attr))
def __init__(self, conv, scale, n_feats, bn=False, act=False, bias=True): m = [] if (scale & (scale - 1)) == 0: # Is scale = 2^n? for _ in range(int(math.log(scale, 2))): m.append(conv(n_feats, 4 * n_feats, 3, bias)) m.append(nn.PixelShuffle(2)) if bn: m.append(nn.BatchNorm2D(n_feats)) if act == 'relu': m.append(nn.ReLU()) elif act == 'prelu': m.append(nn.PReLU(n_feats)) elif scale == 3: m.append(conv(n_feats, 9 * n_feats, 3, bias)) m.append(nn.PixelShuffle(3)) if bn: m.append(nn.BatchNorm2D(n_feats)) if act == 'relu': m.append(nn.ReLU()) elif act == 'prelu': m.append(nn.PReLU(n_feats)) else: raise NotImplementedError super(Upsampler, self).__init__(*m)
def __init__(self, in_planes, out_planes, stride, dropRate=0.0): super(BasicBlock, self).__init__() self.bn1 = nn.BatchNorm2D(in_planes) self.relu1 = nn.ReLU() self.conv1 = nn.Conv2D(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, weight_attr=nn.initializer.KaimingNormal()) self.bn2 = nn.BatchNorm2D(out_planes) self.relu2 = nn.ReLU() self.conv2 = nn.Conv2D(out_planes, out_planes, kernel_size=3, stride=1, padding=1, weight_attr=nn.initializer.KaimingNormal()) self.droprate = dropRate self.equalInOut = (in_planes == out_planes) self.convShortcut = (not self.equalInOut) and nn.Conv2D( in_planes, out_planes, kernel_size=1, stride=stride, padding=0, weight_attr=nn.initializer.KaimingNormal()) or None
def __init__(self, num_layers, emb_dim, drop_ratio=0.5, JK="last", residual=False, gnn_type='gin'): ''' emb_dim (int): node embedding dimensionality ''' super(GNN_node_Virtualnode, self).__init__() self.num_layers = num_layers self.drop_ratio = drop_ratio self.JK = JK ### add residual connection or not self.residual = residual if self.num_layers < 2: raise ValueError("Number of GNN layers must be greater than 1.") self.atom_encoder = AtomEncoder(emb_dim) ### set the initial virtual node embedding to 0. # self.virtualnode_embedding = paddle.nn.Embedding(1, emb_dim) self.virtualnode_embedding = self.create_parameter( shape=[1, emb_dim], dtype='float32', default_initializer=nn.initializer.Constant(value=0.0)) ### List of GNNs self.convs = [] ### batch norms applied to node embeddings self.batch_norms = [] ### List of MLPs to transform virtual node at every layer self.mlp_virtualnode_list = [] for layer in range(num_layers): if gnn_type == 'gin': self.convs.append(GINConv(emb_dim)) elif gnn_type == 'gcn': self.convs.append(GCNConv(emb_dim)) else: ValueError('Undefined GNN type called {}'.format(gnn_type)) self.batch_norms.append(paddle.nn.BatchNorm1D(emb_dim)) for layer in range(num_layers - 1): self.mlp_virtualnode_list.append( nn.Sequential(nn.Linear(emb_dim, emb_dim), nn.BatchNorm1D(emb_dim), nn.ReLU(), nn.Linear(emb_dim, emb_dim), nn.BatchNorm1D(emb_dim), nn.ReLU())) self.pool = gnn.GraphPool(pool_type="sum") self.convs = nn.LayerList(self.convs) self.batch_norms = nn.LayerList(self.batch_norms) self.mlp_virtualnode_list = nn.LayerList(self.mlp_virtualnode_list)
def __init__(self, input_channels, output_channels, stride=1): super(ResidualBlock, self).__init__() self.input_channels = input_channels self.output_channels = output_channels self.stride = stride self.bn1 = nn.BatchNorm2D(input_channels) self.relu = nn.ReLU() self.conv1 = nn.Conv2D(input_channels, output_channels // 4, 1, 1, bias_attr=False) self.bn2 = nn.BatchNorm2D(output_channels // 4) self.relu = nn.ReLU() self.conv2 = nn.Conv2D(output_channels // 4, output_channels // 4, 3, stride, padding=1, bias_attr=False) self.bn3 = nn.BatchNorm2D(output_channels // 4) self.relu = nn.ReLU() self.conv3 = nn.Conv2D(output_channels // 4, output_channels, 1, 1, bias_attr=False) self.conv4 = nn.Conv2D(input_channels, output_channels, 1, stride, bias_attr=False)
def __init__(self, in_channels, nclass): super().__init__() self.nclass = nclass inter_channels = in_channels // 4 self.inp = paddle.zeros(shape=(nclass, 300), dtype='float32') self.inp = paddle.create_parameter( shape=self.inp.shape, dtype=str(self.inp.numpy().dtype), default_initializer=paddle.nn.initializer.Assign(self.inp)) self.inp.stop_gradient = True self.fc1 = nn.Sequential(nn.Linear(300, 128), nn.BatchNorm1D(128), nn.ReLU()) self.fc2 = nn.Sequential(nn.Linear(128, 256), nn.BatchNorm1D(256), nn.ReLU()) self.conv5 = layers.ConvBNReLU(in_channels, inter_channels, 3, padding=1, bias_attr=False, stride=1) self.gloru = GlobalReasonUnit(in_channels=inter_channels, num_state=256, num_node=84, nclass=nclass) self.conv6 = nn.Sequential(nn.Dropout(0.1), nn.Conv2D(inter_channels, nclass, 1))
def make_layers(self, cfg, data_dict, batch_norm=False) -> nn.Sequential: layers = [] in_channels = 3 block = 1 number = 1 for v in cfg: if v == 'M': layers += [nn.MaxPool2D(kernel_size=2, stride=2)] block += 1 number = 1 else: conv2d = nn.Conv2D(in_channels, v, kernel_size=3, padding=1) """ set value """ weight = paddle.to_tensor( self.get_conv_filter(data_dict, f'conv{block}_{number}')) weight = weight.transpose((3, 2, 0, 1)) bias = paddle.to_tensor( self.get_bias(data_dict, f'conv{block}_{number}')) conv2d.weight.set_value(weight) conv2d.bias.set_value(bias) number += 1 if batch_norm: layers += [conv2d, nn.BatchNorm2D(v), nn.ReLU()] else: layers += [conv2d, nn.ReLU()] in_channels = v return nn.Sequential(*layers)
def __init__(self, input_size, output_size): super(SimpleNet, self).__init__() self.linear1 = nn.Linear(input_size, output_size) self.relu1 = nn.ReLU() self.linear2 = nn.Linear(input_size, output_size) self.relu2 = nn.ReLU() self.linear3 = nn.Linear(input_size, output_size)
def __init__(self, model_config): """ Initialization """ super(MolTransModel, self).__init__() # Basic config self.model_config = model_config self.drug_max_seq = model_config['drug_max_seq'] self.target_max_seq = model_config['target_max_seq'] self.emb_size = model_config['emb_size'] self.dropout_ratio = model_config['dropout_ratio'] self.input_drug_dim = model_config['input_drug_dim'] self.input_target_dim = model_config['input_target_dim'] self.layer_size = model_config['layer_size'] self.gpus = 1 # Model config self.interm_size = model_config['interm_size'] self.num_attention_heads = model_config['num_attention_heads'] self.attention_dropout_ratio = model_config['attention_dropout_ratio'] self.hidden_dropout_ratio = model_config['hidden_dropout_ratio'] self.flatten_dim = model_config['flatten_dim'] self.hidden_size = model_config['emb_size'] # Enhanced embeddings self.drug_emb = EnhancedEmbedding(self.input_drug_dim, self.emb_size, self.drug_max_seq, self.dropout_ratio) self.target_emb = EnhancedEmbedding(self.input_target_dim, self.emb_size, self.target_max_seq, self.dropout_ratio) # Encoder module self.encoder = EncoderModule(self.layer_size, self.hidden_size, self.interm_size, self.num_attention_heads, self.attention_dropout_ratio, self.hidden_dropout_ratio) # Cross information self.interaction_cnn = nn.Conv2D(1, 3, 3, padding=1) # Conv2D #self.involution = Involution2D(in_channel=1, out_channel=3) # Involution2D # Decoder module self.decoder = nn.Sequential( nn.Linear(self.flatten_dim, 512), nn.ReLU(), # nn.LayerNorm(512), LayerNorm(512), # nn.BatchNorm(512), nn.Linear(512, 64), nn.ReLU(), # nn.LeakyReLU(), # nn.LayerNorm(64), LayerNorm(64), # nn.BatchNorm(64), nn.Linear(64, 32), nn.ReLU(), # nn.LeakyReLU(), nn.Linear(32, 1))
def __init__(self, in_ch, out_ch, kernel_size, stride, expansion_factor, bn_momentum=0.1): super(_InvertedResidual, self).__init__() assert stride in [1, 2] assert kernel_size in [3, 5] mid_ch = in_ch * expansion_factor self.apply_residual = (in_ch == out_ch and stride == 1) self.layers = nn.Sequential( # Pointwise nn.Conv2D(in_ch, mid_ch, 1, bias_attr=False), nn.BatchNorm2D(mid_ch, momentum=bn_momentum), nn.ReLU(), # Depthwise nn.Conv2D(mid_ch, mid_ch, kernel_size, padding=kernel_size // 2, stride=stride, groups=mid_ch, bias_attr=False), nn.BatchNorm2D(mid_ch, momentum=bn_momentum), nn.ReLU(), # Linear pointwise. Note that there's no activation. nn.Conv2D(mid_ch, out_ch, 1, bias_attr=False), nn.BatchNorm2D(out_ch, momentum=bn_momentum))
def _make_transition_layer( self, num_channels_pre_layer, num_channels_cur_layer): num_branches_cur = len(num_channels_cur_layer) num_branches_pre = len(num_channels_pre_layer) transition_layers = [] for i in range(num_branches_cur): if i < num_branches_pre: if num_channels_cur_layer[i] != num_channels_pre_layer[i]: transition_layers.append(nn.Sequential( nn.Conv2D(num_channels_pre_layer[i], num_channels_cur_layer[i], kernel_size=3, stride=1, padding=1, bias_attr=False), self.norm_layer(num_channels_cur_layer[i]), nn.ReLU())) else: transition_layers.append(None) else: conv3x3s = [] for j in range(i + 1 - num_branches_pre): inchannels = num_channels_pre_layer[-1] outchannels = num_channels_cur_layer[i] \ if j == i - num_branches_pre else inchannels conv3x3s.append(nn.Sequential( nn.Conv2D(inchannels, outchannels, kernel_size=3, stride=2, padding=1, bias_attr=False), self.norm_layer(outchannels), nn.ReLU())) transition_layers.append(nn.Sequential(*conv3x3s)) return nn.LayerList(transition_layers)
def __init__(self, in_channels, out_channels, size=(8, 8)): super(AttentionModule_stage3_cifar, self).__init__() self.first_residual_blocks = ResidualBlock(in_channels, out_channels) self.trunk_branches = nn.Sequential( ResidualBlock(in_channels, out_channels), ResidualBlock(in_channels, out_channels)) self.middle_2r_blocks = nn.Sequential( ResidualBlock(in_channels, out_channels), ResidualBlock(in_channels, out_channels)) self.conv1_1_blocks = nn.Sequential( nn.BatchNorm2D(out_channels), nn.ReLU(), nn.Conv2D(out_channels, out_channels, kernel_size=1, stride=1, bias_attr=False), nn.BatchNorm2D(out_channels), nn.ReLU(), nn.Conv2D(out_channels, out_channels, kernel_size=1, stride=1, bias_attr=False), nn.Sigmoid()) self.last_blocks = ResidualBlock(in_channels, out_channels)
def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu=True, bn=True): super(BasicConv, self).__init__() self.out_channels = out_planes if bn: self.conv = nn.Conv2D(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias_attr=None) self.bn = nn.BatchNorm2D(out_planes, epsilon=1e-5, momentum=0.01) self.relu = nn.ReLU() if relu else None else: self.conv = nn.Conv2D(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias_attr=None) self.bn = None self.relu = nn.ReLU() if relu else None
def __init__(self, num_classes): super(ResidualAttentionModel_92_32input_update, self).__init__() self.conv1 = nn.Sequential( nn.Conv2D(3, 32, kernel_size=3, stride=1, padding=1, bias_attr=False), nn.BatchNorm2D(32), nn.ReLU()) # 32*32 self.residual_block1 = ResidualBlock(32, 128) # 32*32 self.attention_module1 = AttentionModule_stage1_cifar( 128, 128, size1=(32, 32), size2=(16, 16)) # 32*32 self.residual_block2 = ResidualBlock(128, 256, 2) # 16*16 self.attention_module2 = AttentionModule_stage2_cifar( 256, 256, size=(16, 16)) # 16*16 self.attention_module2_2 = AttentionModule_stage2_cifar( 256, 256, size=(16, 16)) # 16*16 # tbq add self.residual_block3 = ResidualBlock(256, 512, 2) # 4*4 self.attention_module3 = AttentionModule_stage3_cifar(512, 512) # 8*8 self.attention_module3_2 = AttentionModule_stage3_cifar( 512, 512) # 8*8 # tbq add self.attention_module3_3 = AttentionModule_stage3_cifar( 512, 512) # 8*8 # tbq add self.residual_block4 = ResidualBlock(512, 1024) # 8*8 self.residual_block5 = ResidualBlock(1024, 1024) # 8*8 self.residual_block6 = ResidualBlock(1024, 1024) # 8*8 self.mpool2 = nn.Sequential(nn.BatchNorm2D(1024), nn.ReLU(), nn.AvgPool2D(kernel_size=8)) self.fc = nn.Linear(1024, num_classes)
def __init__(self, num_classes): super(ResidualAttentionModel_448input, self).__init__() self.conv1 = nn.Sequential( nn.Conv2D(3, 64, kernel_size=7, stride=2, padding=3, bias_attr=False), nn.BatchNorm2D(64), nn.ReLU()) self.mpool1 = nn.MaxPool2D(kernel_size=3, stride=2, padding=1) # tbq add # 112*112 self.residual_block0 = ResidualBlock(64, 128) self.attention_module0 = AttentionModule_stage0(128, 128) # tbq add end self.residual_block1 = ResidualBlock(128, 256, 2) # 56*56 self.attention_module1 = AttentionModule_stage1(256, 256) self.residual_block2 = ResidualBlock(256, 512, 2) self.attention_module2 = AttentionModule_stage2(512, 512) self.attention_module2_2 = AttentionModule_stage2(512, 512) # tbq add self.residual_block3 = ResidualBlock(512, 1024, 2) self.attention_module3 = AttentionModule_stage3(1024, 1024) self.attention_module3_2 = AttentionModule_stage3(1024, 1024) # tbq add self.attention_module3_3 = AttentionModule_stage3(1024, 1024) # tbq add self.residual_block4 = ResidualBlock(1024, 2048, 2) self.residual_block5 = ResidualBlock(2048, 2048) self.residual_block6 = ResidualBlock(2048, 2048) self.mpool2 = nn.Sequential(nn.BatchNorm2D(2048), nn.ReLU(), nn.AvgPool2D(kernel_size=7, stride=1)) self.fc = nn.Linear(2048, num_classes)
def __init__(self, inplanes: int, planes: int, stride: int = 2, norm_layer: nn.Layer = nn.BatchNorm2D): super(UpBottleneck, self).__init__() self.expansion = 4 self.residual_layer = UpsampleConvLayer(inplanes, planes * self.expansion, kernel_size=1, stride=1, upsample=stride) conv_block = [] conv_block += [ norm_layer(inplanes), nn.ReLU(), nn.Conv2D(inplanes, planes, kernel_size=1, stride=1) ] conv_block += [ norm_layer(planes), nn.ReLU(), UpsampleConvLayer(planes, planes, kernel_size=3, stride=1, upsample=stride) ] conv_block += [ norm_layer(planes), nn.ReLU(), nn.Conv2D(planes, planes * self.expansion, kernel_size=1, stride=1) ] self.conv_block = nn.Sequential(*conv_block)
def __init__(self, num_classes=751): super(Net, self).__init__() # 3 128 64 self.conv = nn.Sequential( nn.Conv2D(3, 64, 3, stride=1, padding=1), nn.BatchNorm2D(64), nn.ReLU(), # nn.Conv2d(32,32,3,stride=1,padding=1), # nn.BatchNorm2d(32), # nn.ReLU(inplace=True), nn.MaxPool2D(3, 2, padding=1), ) # 32 64 32 self.layer1 = make_layers(64, 64, 2, False) # 32 64 32 self.layer2 = make_layers(64, 128, 2, True) # 64 32 16 self.layer3 = make_layers(128, 256, 2, True) # 128 16 8 self.layer4 = make_layers(256, 512, 2, True) # 256 8 4 self.avgpool = nn.AvgPool2D((8, 4), 1) # 256 1 1 self.classifier = nn.Sequential( nn.Linear(512, 256), nn.BatchNorm1D(256), nn.ReLU(), nn.Dropout(), nn.Linear(256, num_classes), )
def __init__(self, num_convs=0, in_channels=2048, out_channels=256): super(MaskFeat, self).__init__() self.num_convs = num_convs self.in_channels = in_channels self.out_channels = out_channels fan_conv = out_channels * 3 * 3 fan_deconv = out_channels * 2 * 2 mask_conv = nn.Sequential() for i in range(self.num_convs): conv_name = 'mask_inter_feat_{}'.format(i + 1) mask_conv.add_sublayer( conv_name, nn.Conv2D(in_channels=in_channels if i == 0 else out_channels, out_channels=out_channels, kernel_size=3, padding=1, weight_attr=paddle.ParamAttr( initializer=KaimingNormal(fan_in=fan_conv)))) mask_conv.add_sublayer(conv_name + 'act', nn.ReLU()) mask_conv.add_sublayer( 'conv5_mask', nn.Conv2DTranspose( in_channels=self.in_channels, out_channels=self.out_channels, kernel_size=2, stride=2, weight_attr=paddle.ParamAttr(initializer=KaimingNormal( fan_in=fan_deconv)))) mask_conv.add_sublayer('conv5_mask' + 'act', nn.ReLU()) self.upsample = mask_conv
def __init__(self, backbone): super(FMFModel, self).__init__() self.backbone = backbone self.se1, self.se2, self.se3, self.se4, self.se5 = SEModule( 64), SEModule(64), SEModule(64), SEModule(64), SEModule(64) self.squeeze5 = nn.Sequential(nn.Conv2D(2048, 64, 3, 1, 1), nn.BatchNorm2D(64), nn.ReLU()) self.squeeze4 = nn.Sequential(nn.Conv2D(1024, 64, 3, 1, 1), nn.BatchNorm2D(64), nn.ReLU()) self.squeeze3 = nn.Sequential(nn.Conv2D(512, 64, 3, 1, 1), nn.BatchNorm2D(64), nn.ReLU()) self.squeeze2 = nn.Sequential(nn.Conv2D(256, 64, 3, 1, 1), nn.BatchNorm2D(64), nn.ReLU()) self.squeeze1 = nn.Sequential(nn.Conv2D(64, 64, 3, 1, 1), nn.BatchNorm2D(64), nn.ReLU()) self.fa1, self.fa2, self.fa3, self.fa4, self.fa5 = SSM(), \ SSM(), \ SSM(), \ SSM(), \ SSM() self.FMF1, self.FMF2 = FMFMs(), FMFMs() self.FMF3 = FMFMs() self.mso = Progressive_fusion_module() self.linear = nn.Conv2D(64, 1, 3, 1, 1) for p in self.backbone.parameters(): p.optimize_attr['learning_rate'] /= 10.0
def __init__(self, num_classes, backbone, BatchNorm): super(Decoder, self).__init__() if backbone == 'resnet' or backbone == 'drn' or backbone == 'resnet_edge': low_level_inplanes = 256 elif backbone == 'xception': low_level_inplanes = 128 elif backbone == 'mobilenet': low_level_inplanes = 24 else: raise NotImplementedError self.conv1 = nn.Conv2D(low_level_inplanes, 48, 1, bias_attr=False) self.bn1 = BatchNorm(48) self.relu = nn.ReLU(True) self.last_conv = nn.Sequential( nn.Conv2D(304, 256, kernel_size=3, stride=1, padding=1, bias_attr=False), BatchNorm(256), nn.ReLU(True), nn.Sequential(), nn.Conv2D(256, 256, kernel_size=3, stride=1, padding=1, bias_attr=False), BatchNorm(256), nn.ReLU(True), nn.Sequential()) self._init_weight()
def _make_transition_layer(self, num_channels_pre_layer, num_channels_cur_layer): num_branches_cur = len(num_channels_cur_layer) num_branches_pre = len(num_channels_pre_layer) transition_layers = [] for i in range(num_branches_cur): if i < num_branches_pre: if num_channels_cur_layer[i] != num_channels_pre_layer[i]: transition_layers.append( nn.Sequential( # nn.Conv2d( # num_channels_pre_layer[i], # num_channels_cur_layer[i], # 3, 1, 1, bias=False # ), nn.Conv2D(num_channels_pre_layer[i], num_channels_cur_layer[i], 3, 1, 1, weight_attr=weight_attr_conv, bias_attr=False), # nn.BatchNorm2d(num_channels_cur_layer[i]), nn.BatchNorm2D(num_channels_cur_layer[i], weight_attr=weight_attr_bn, bias_attr=bias_attr_constant_0), # nn.ReLU(inplace=True) nn.ReLU())) else: # transition_layers.append(None) transition_layers.append(equalmap()) else: conv3x3s = [] for j in range(i + 1 - num_branches_pre): inchannels = num_channels_pre_layer[-1] outchannels = num_channels_cur_layer[i] \ if j == i-num_branches_pre else inchannels conv3x3s.append( nn.Sequential( # nn.Conv2d( # inchannels, outchannels, 3, 2, 1, bias=False # ), nn.Conv2D(inchannels, outchannels, 3, 2, 1, weight_attr=weight_attr_conv, bias_attr=False), # nn.BatchNorm2d(outchannels), nn.BatchNorm2D(outchannels, weight_attr=weight_attr_bn, bias_attr=bias_attr_constant_0), # nn.ReLU(inplace=True) nn.ReLU())) transition_layers.append(nn.Sequential(*conv3x3s)) # return nn.ModuleList(transition_layers) return nn.LayerList(transition_layers)
def __init__(self, in_channels, out_channels, is_batchnorm, num_conv=2, kernel_size=3, stride=1, padding=1): super(UnetConv2D, self).__init__() self.num_conv = num_conv for i in range(num_conv): conv = (nn.Sequential(nn.Conv2D(in_channels, out_channels, kernel_size, stride, padding), nn.BatchNorm(out_channels), nn.ReLU()) \ if is_batchnorm else \ nn.Sequential(nn.Conv2D(in_channels, out_channels, kernel_size, stride, padding), nn.ReLU())) setattr(self, 'conv%d' % (i + 1), conv) in_channels = out_channels # initialise the blocks for children in self.children(): children.weight_attr = paddle.framework.ParamAttr( initializer=paddle.nn.initializer.KaimingNormal) children.bias_attr = paddle.framework.ParamAttr( initializer=paddle.nn.initializer.KaimingNormal)
def __init__(self, in_channels, out_channels, size=(8, 8)): super(AttentionModule_stage2_cifar, self).__init__() self.first_residual_blocks = ResidualBlock(in_channels, out_channels) self.trunk_branches = nn.Sequential( ResidualBlock(in_channels, out_channels), ResidualBlock(in_channels, out_channels)) self.mpool1 = nn.MaxPool2D(kernel_size=3, stride=2, padding=1) # 4*4 self.middle_2r_blocks = nn.Sequential( ResidualBlock(in_channels, out_channels), ResidualBlock(in_channels, out_channels)) self.interpolation1 = nn.UpsamplingBilinear2D(size=size) # 8*8 self.conv1_1_blocks = nn.Sequential( nn.BatchNorm2D(out_channels), nn.ReLU(), nn.Conv2D(out_channels, out_channels, kernel_size=1, stride=1, bias_attr=False), nn.BatchNorm2D(out_channels), nn.ReLU(), nn.Conv2D(out_channels, out_channels, kernel_size=1, stride=1, bias_attr=False), nn.Sigmoid()) self.last_blocks = ResidualBlock(in_channels, out_channels)
def __init__(self, gate_channel, reduction_ratio=16, dilation_conv_num=2, dilation_val=4): super(SpatialGate, self).__init__() self.gate_s = nn.Sequential() self.gate_s.add_sublayer( 'gate_s_conv_reduce0', nn.Conv2D(gate_channel, gate_channel // reduction_ratio, kernel_size=1)) self.gate_s.add_sublayer( 'gate_s_bn_reduce0', nn.BatchNorm2D(gate_channel // reduction_ratio)) self.gate_s.add_sublayer('gate_s_relu_reduce0', nn.ReLU()) for i in range(dilation_conv_num): self.gate_s.add_sublayer( 'gate_s_conv_di_%d'%i, nn.Conv2D(gate_channel//reduction_ratio, gate_channel//reduction_ratio, kernel_size=3, \ padding=dilation_val, dilation=dilation_val) ) self.gate_s.add_sublayer( 'gate_s_bn_di_%d' % i, nn.BatchNorm2D(gate_channel // reduction_ratio)) self.gate_s.add_sublayer('gate_s_relu_di_%d' % i, nn.ReLU()) self.gate_s.add_sublayer( 'gate_s_conv_final', nn.Conv2D(gate_channel // reduction_ratio, 1, kernel_size=1))
def __init__(self, inp, oup, stride=1): super(ResidualBlock, self).__init__() self.block = nn.Sequential( ConvDw(inp, oup, 3, stride=stride), nn.Conv2D(in_channels=oup, out_channels=oup, kernel_size=3, stride=1, padding=1, groups=oup, bias_attr=False), nn.BatchNorm2D(num_features=oup, epsilon=1e-05, momentum=0.1), nn.ReLU(), nn.Conv2D(in_channels=oup, out_channels=oup, kernel_size=1, stride=1, padding=0, bias_attr=False), nn.BatchNorm2D(num_features=oup, epsilon=1e-05, momentum=0.1), ) if inp == oup: self.residual = None else: self.residual = nn.Sequential( nn.Conv2D(in_channels=inp, out_channels=oup, kernel_size=1, stride=1, padding=0, bias_attr=False), nn.BatchNorm2D(num_features=oup, epsilon=1e-05, momentum=0.1), ) self.relu = nn.ReLU()
def __init__(self, block, layers, num_filters, feature_dim, encoder_type='SAP', n_mels=40, log_input=True, **kwargs): super(ResNetSE, self).__init__() print('Embedding size is %d, encoder %s.' % (feature_dim, encoder_type)) self.inplanes = num_filters[0] self.encoder_type = encoder_type self.n_mels = n_mels self.log_input = log_input self.conv1 = nn.Conv2D(1, num_filters[0], kernel_size=3, stride=1, padding=1) self.relu = nn.ReLU() self.bn1 = nn.BatchNorm2D(num_filters[0]) self.layer1 = self._make_layer(block, num_filters[0], layers[0]) self.layer2 = self._make_layer(block, num_filters[1], layers[1], stride=(2, 2)) self.layer3 = self._make_layer(block, num_filters[2], layers[2], stride=(2, 2)) self.layer4 = self._make_layer(block, num_filters[3], layers[3], stride=(2, 2)) outmap_size = int(self.n_mels / 8) self.attention = nn.Sequential( nn.Conv1D(num_filters[3] * outmap_size, 128, kernel_size=1), nn.ReLU(), nn.BatchNorm1D(128), nn.Conv1D(128, num_filters[3] * outmap_size, kernel_size=1), nn.Softmax(axis=2), ) if self.encoder_type == "SAP": out_dim = num_filters[3] * outmap_size elif self.encoder_type == "ASP": out_dim = num_filters[3] * outmap_size * 2 else: raise ValueError('Undefined encoder') self.fc = nn.Linear(out_dim, feature_dim)
def __init__(self): super(LeNetDygraph, self).__init__() self.features = nn.Sequential(nn.Conv2D(1, 6, 3, stride=1, padding=1), nn.ReLU(), paddle.fluid.dygraph.Pool2D(2, 'max', 2), nn.Conv2D(6, 16, 5, stride=1, padding=0), nn.ReLU(), paddle.fluid.dygraph.Pool2D(2, 'max', 2))