Python Examples of arch.nn.AdaptiveAvgPool2d (2023)

def __init__(self, in_channels, out_channels, dilatations=(1, 3, 6, 1)): super().__init__() Assertion dilatations[-1] == 1 self.aspp = nn.ModuleList() for dilatation in Dilations: kernel size = 3 if dilation > 1 else 1, padding = dilation if dilation > 1 else 0, conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, step=1, dilation=dilation, padding= padding, bias =True) self.aspp.append(conv) self.gap = nn.AdaptiveAvgPool2d(1) self.init_weights()

def __init__(self, block, layer, num_classes=1000): self.inplanes = 64 super(DetNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, passo=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) self .layer1 = self._make_layer(block, 64, Schichten[0]) self.layer2 = self._make_layer(block, 128, Schichten[1], passo=2) self.layer3 = self._make_layer(block, 256, Schichten [2], passo=2) self.layer4 = self._make_new_layer(256, Schichten[3]) self.layer5 = self._make_new_layer(256, Schichten[4]) self.avgpool = nn.AdaptiveAvgPool2d(1) self. fc = nn.Linear(1024, num_classes) para m em 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, block, layer, num_classes=1000): self.inplanes = 64 super(DetNet, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=7, passo=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) self .layer1 = self._make_layer(block, 64, Schichten[0]) self.layer2 = self._make_layer(block, 128, Schichten[1], passo=2) self.layer3 = self._make_layer(block, 256, Schichten [2], passo=2) self.layer4 = self._make_new_layer(256, Schichten[3]) self.layer5 = self._make_new_layer(256, Schichten[4]) self.avgpool = nn.AdaptiveAvgPool2d(1) self. fc = nn.Linear(1024, num_classes) para m em 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,block,block_list): super(ResNet,self).__init__() self.head_conv = nn.Sequential( nn.Conv2d(3,64,7,2,3,bias=False), nn.BatchNorm2d (64), nn.ReLU(inplace=True),) self.maxpool_1 = nn.MaxPool2d(3,2,1) b_ = block.expansion self.layer_1 = self._make_layer(block,64,64*b_,block_list [0],1) self.layer_2 = self._make_layer(block,64*b_,128*b_,block_list[1],2) self.layer_3 = self._make_layer(block,128*b_,256*b_,block_list [2],2) self.layer_4 = self._make_layer(block,256*b_,512*b_,block_list[3],2) self.avgpool_1 = nn.AdaptiveAvgPool2d((1,1)) self.fc_1 = nn .Sequencial( nn.Flatten(), nn.Linear(512*b_,1000), nn.Softmax(dim = 1),) self._initialization()

def __init__(self,block,block_list,cardinality): super(ResNet,self).__init__() self.head_conv = nn.Sequential( nn.Conv2d(3,64,7,2,3,bias=False), nn .BatchNorm2d(64), nn.ReLU(inplace=True),) self.maxpool_1 = nn.MaxPool2d(3,2,1) b_ = block.expansion self.layer_1 = self._make_layer(block,64,128*b_,block_list [0],1,Kardinalität) self.layer_2 = self._make_layer(block,128*b_,256*b_,block_list[1],2,cardinalidade) self.layer_3 = self._make_layer(block,256*b_,512 *b_,Blockliste[2],2,Kardinalität) self.layer_4 = self._make_layer(block,512*b_,1024*b_,block_list[3],2,Kardinalität) self.avgpool_1 = nn.AdaptiveAvgPool2d((1, 1)) self.fc_1 = nn.Sequential( nn.Flatten(), nn.Linear(1024*b_,1000), nn.Softmax(dim = 1),) self._initialization()

def __init__(self,k,block_list,num_init_features=64, bn_size=4, drop_rate=0, memory_ficient=False): super(DenseNet,self).__init__() self.head_conv = nn.Sequential( nn.Conv2d(3, num_init_features,7,2,3,bias=False), nn.BatchNorm2d(num_init_features), nn.ReLU(inplace=True),) self.maxpool_1 = nn.MaxPool2d(3,2,1) self.dense_body, self. final_channels = self._make_layers(num_init_features, bn_size,block_list,k,drop_rate, memory_eficiente) self.avgpool_1 = nn.AdaptiveAvgPool2d((1,1)) self.fc_1 = nn.Sequential( nn.Flatten(), nn.Linear( self.final_channels,1000), nn.Softmax(dim = 1),) self._initialization()

def __init__(self,): super(MobileNet_V1,self).__init__() self.conv = nn.Sequential(BasicConv(3,32,3,2,1), DPConv(32,64,1), DPConv(64,128 ,2), DPConv(128.128,1), DPConv(128.256,2), DPConv(256.256,1), DPConv(256.512,2), DPConv(512.512,1), DPConv(512.512,1), DPConv(512.512, 1), DPConv(512.512,1), DPConv(512.512,1), DPConv(512.1024,2), DPConv(1024,1024,1),) self.final = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn .Flatten(), nn.Linear(1024,1000), nn.Softmax(dim=1) )

def _reconstruct_inception(self, basemodel): model = nn.Module() model.features = nn.Sequential(basemodel.Conv2d_1a_3x3, basemodel.Conv2d_2a_3x3, basemodel.Conv2d_2b_3x3, nn.MaxPool2d(kernel_size=3, stride=2), basemodel. Conv2d_3b_1x1, Basismodell.Conv2d_4a_3x3, nn.MaxPool2d(kernel_size=3, passo=2), Basismodell.Mixed_5b, Basismodell.Mixed_5c, Basismodell.Mixed_5d, Basismodell.Mixed_6a, Basismodell.Mixed_6b, Basismodell.Mixed_6c, Basismodell.Mixed_6c, Basismodell.Mixed_6a, Basismodell.Mixed_6b, Basismodell.Mixed_6c, Basedismodell. , basemodel.Mixed_7a, basemodel.Mixed_7b, basemodel.Mixed_7c) model.representation = nn.AdaptiveAvgPool2d((1, 1)) model.classifier = basemodel.fc model.representation_dim=basemodel.fc.weight.size(1) Rückgabemodell

def __init__(self, num_classes, base_size=64, dropout=0.2, ratio=16, kernel_size=7): super().__init__() self.conv = nn.Sequential( ConvBlock(in_channels=3, out_channels=base_size), ConvBlock(in_channels=base_size, out_channels=base_size*2), ConvBlock(in_channels=base_size*2, out_channels=base_size*4), ConvBlock(in_channels=base_size*4, out_channels=base_size*8), ) self.attention = ConvolutionalBlockAttentionModule( base_size*8, ratio=ratio, kernel_size=kernel_size) self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( nn.Dropout(dropout), nn.Linear(base_size*8, base_size*2), nn.PReLU(), nn.BatchNorm1d(base_size*2), nn.Dropout(dropout/2), nn.Linear(base_size*2, num_classes), )

def __init__(self, in_planes, out_planes, redução=1, norm_layer=nn.BatchNorm2d): super(FeatureFusion, self).__init__() self.conv_1x1 = ConvBnRelu(in_planes, out_planes, 1, 1, 0, has_bn=True, norm_layer=norm_layer, has_relu=True, has_bias=False) self.channel_attention = nn.Sequential( nn.AdaptiveAvgPool2d(1), ConvBnRelu(out_planes, out_planes // Reduzierung, 1, 1, 0, has_bn=False, norm_layer=norm_layer, has_relu=True, has_bias=False), ConvBnRelu(out_planes // Reduzierung, out_planes, 1, 1, 0, has_bn=False, norm_layer=norm_layer, has_relu=False, has_bias=False), nn.Sigmoid() )

def __init__(self, config, in_channels): super(FastRCNNPredictor, self).__init__() behaupten in_channels ist nicht None num_inputs = in_channels num_classes = config.MODEL.ROI_BOX_HEAD.NUM_CLASSES self.avgpool = nn.AdaptiveAvgPool2d(1) self.cls_score = nn.Linear(num_inputs, num_classes) num_bbox_reg_classes = 2 if config.MODEL.CLS_AGNOSTIC_BBOX_REG else num_classes self.bbox_pred = nn.Linear(num_inputs, num_bbox_reg_classes * 4) nn.init.normal_(self.cls_score.weight, mean=0, std=0,01) nn.init.constant_(self.cls_score.bias, 0) nn.init.normal_(self.bbox_pred.weight, mean=0, std=0,001) nn.init.constant_(self.bbox_pred.bias, 0)

def __init__(self, inplanes, num_classes, expplanes1, expplanes2): super(LastBlockLarge, self).__init__() self.conv1 = nn.Conv2d(inplanes, expplanes1, kernel_size=1, bias=False) self.bn1 = nn. BatchNorm2d(expplanes1) self.act1 = HardSwish(inplace=True) self.avgpool = nn.AdaptiveAvgPool2d(1) self.conv2 = nn.Conv2d(expplanes1, expplanes2, kernel_size=1, stride=1) self.act2 = HardSwish( inplace=True) self.dropout = nn.Dropout(p=0.2, inplace=True) self.fc = nn.Linear(expplanes2, num_classes) self.expplanes1 = expplanes1 self.expplanes2 = expplanes2 self.inplanes = inplanes self.num_classes = Anzahl_Klassen

def __init__(self, inplanes, num_classes, expplanes1, expplanes2): super(LastBlockSmall, self).__init__() self.conv1 = nn.Conv2d(inplanes, expplanes1, kernel_size=1, bias=False) self.bn1 = nn. BatchNorm2d(expplanes1) self.act1 = HardSwish(inplace=True) self.se = SqEx(expplanes1) self.avgpool = nn.AdaptiveAvgPool2d(1) self.conv2 = nn.Conv2d(expplanes1, expplanes2, kernel_size=1, stride= 1, bias=False) self.act2 = HardSwish(inplace=True) self.dropout = nn.Dropout(p=0.2, inplace=True) self.fc = nn.Linear(expplanes2, num_classes) self.expplanes1 = expplanes1 self .expplanes2 = expplanes2 self.inplanes = inplanes self.num_classes = num_classes

def __init__(self, inplanes, kernel=3, redução=16, with_padding=False): super(GDWSe2d, self).__init__() if with_padding: padding = kernel // 2 else: padding = 0 self.globle_dw = nn. Conv2d(inplanes, inplanes, kernel_size=kernel, padding=padding, stride=1, groups=inplanes, bias=False) self.bn = nn.BatchNorm2d(inplanes) self.relu = nn.ReLU(inplace=True) self. avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( nn.Linear(Inplanes, Inplanes // Reduktion), nn.ReLU(inplace=True), nn.Linear(Inplanes // Reduktion, Inplanes), nn .Sigmoid() ) self._init_weights()

def __init__(self, dim_in): super().__init__() self.dim_in = dim_in self.cls_on = cfg.FAST_RCNN.CLS_ON self.reg_on = cfg.FAST_RCNN.REG_ON if self.cls_on: self.cls_score = nn.Linear (self.dim_in, cfg.MODEL.NUM_CLASSES) init.normal_(self.cls_score.weight, std=0.01) init.constant_(self.cls_score.bias, 0) # self.avgpool = nn.AdaptiveAvgPool2d(1) if self .reg_on: if cfg.FAST_RCNN.CLS_AGNOSTIC_BBOX_REG: # bg und fg self.bbox_pred = nn.Linear(self.dim_in, 4 * 2) sonst: self.bbox_pred = nn.Linear(self.dim_in, 4 * cfg.MODEL. NUM_CLASSES) init.normal_(self.bbox_pred.weight, std=0.001) init.constant_(self.bbox_pred.bias, 0)

def __init__(self, config, in_channels): super(FastRCNNPredictor, self).__init__() behaupten in_channels ist nicht None num_inputs = in_channels num_classes = config.MODEL.ROI_BOX_HEAD.NUM_CLASSES self.avgpool = nn.AdaptiveAvgPool2d(1) self.cls_score = nn.Linear(num_inputs, num_classes) num_bbox_reg_classes = 2 if config.MODEL.CLS_AGNOSTIC_BBOX_REG else num_classes self.bbox_pred = nn.Linear(num_inputs, num_bbox_reg_classes * 4) self.quad_pred = nn.Linear(num_inputs, num_bbox_reg_classes * 8) init. normal_(self.cls_score.weight, average=0, std=0,01) nn.init.constant_(self.cls_score.bias, 0) nn.init.normal_(self.bbox_pred.weight, average=0, std= 0,001) nn.init.constant_(self.bbox_pred.bias, 0) nn.init.normal_(self.quad_pred.weight, mean=0, std=0,001) nn.init.constant_(self.quad_pred.bias, 0)

def __init__(self, in_channels, ratio, pooling_type='att', fusion_types=('channel_add', )): super(ContextBlock, self).__init__() assert pooling_type in ['avg', 'att'] assert isinstance( fusion_types, (list, tuple)) valid_fusion_types = ['channel_add', 'channel_mul'] assert all([f in valid_fusion_types for f in fusion_types]) assert len(fusion_types) > 0, 'mindestens eine Fusion sollte verwendet werden' self . in_channels = in_channels self.ratio = proporção self.planes = int(in_channels * proporção) self.pooling_type = pooling_type self.fusion_types = fusion_types if pooling_type == 'att': self.conv_mask = nn.Conv2d(in_channels, 1, kernel_size = 1) self.softmax = nn.Softmax(dim=2) sonst: self.avg_pool = nn.AdaptiveAvgPool2d(1) se 'channel_add' em fusion_types: self.channel_add_conv = nn.Sequential( nn.Conv2d(self.in_channels, self .planes, kernel_size=1), nn.LayerNorm([self.planes, 1, 1]), nn.ReLU(inplace=True), # yapf: disable nn.Conv2d(self.planes, self.in_channels, kernel_size = 1)) filho: eu .channel_add_conv = Keine, wenn 'channel_mul' in fusion_types: self.channel_mul_conv = nn.Sequential( nn.Conv2d(self.in_channels, self.planes, kernel_size=1), nn.LayerNorm([self.planes, 1, 1] ), nn .ReLU(inplace=True), # yapf: nn.Conv2d(self.planes, self.in_channels, kernel_size=1) deaktivieren sonst: self.channel_mul_conv = Keine self.reset_parameters()

def __init__(self, in_channels=Nenhum, out_channels=Nenhum, **kwargs): super().__init__(in_channels, out_channels, **kwargs) self.global_pool = nn.AdaptiveAvgPool2d((1, 1))

def __init__(self, block, layer, num_classes=1000,zero_init_residual=False, groups=1, width_per_group=64, norm_layer=None): super(ResNet, self).__init__() if norm_layer ist None: norm_layer = nn.BatchNorm2d self.inplanes = 64 self.groups = Gruppen self.base_width = width_per_group self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, passo=2, padding=3, bias=False) self.bn1 = norm_layer (self.inplanes) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, passo=2, padding=1) self.layer1 = self._make_layer(block, 64, Schichten [0], norm_layer=norm_layer) self.layer2 = self._make_layer(block, 128, Schichten[1], passo=2, norm_layer=norm_layer) self.layer3 = self._make_layer(block, 256, Schichten[2], stride=2, norm_layer=norm_layer) self.layer4 = self._make_layer(block, 512, layer[3], stride=2, norm_layer=norm_layer) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(512 * block.expansion, num_classes) für m in self.modules(): if isinstance(m, nn.Co nv2d): nn.i nit.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)): nn.init.constant_(m. peso, 1) nn. init.constant_(m.bias, 0) if zero_init_residual: for m in self.modules(): if isinstance(m, Gargalo): nn.init.constant_(m.bn3.weight, 0) elif isinstance(m, BasicBlock ): nn.init.constant_(m.bn2.weight, 0)

def __init__(self,block_config): super(_DarkNet,self).__init__() self.headconv = nn.Sequential(BasicConv(3,32,3,1,1)) self.in_dim = 32 self.layers = self. _make_layers(block_config) self.final = nn.Sequential( nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(1024,1000), nn.Softmax(dim=1) )

def __init__(self,in_dim,ratio): super(SElayer,self).__init__() self.gap = nn.AdaptiveAvgPool2d((1,1)) Reduced_dim = max(1, in_dim//ratio) self.fc1 = nn .Sequential(nn.Flatten(), nn.Linear(in_dim, Reduced_dim), #_Swish(), nn.ReLU(inplace=True), nn.Linear(reduce_dim, in_dim), nn.Softmax(dim=1), )

def __init__(self,block_config,groups): super(_ShuffleNet,self).__init__() self.head_conv = nn.Sequential( nn.Conv2d(3,24,3,2,1,bias=False), nn.BatchNorm2d (24), nn.ReLU(inplace=True),) self.maxpool_1 = nn.MaxPool2d(3,2,1) self.layer_1 = self._make_layer(24,block_config[0][1],block_config[0] [0],Gruppen) self.layer_2 = self._make_layer(block_config[0][1],block_config[1][1],block_config[1][0],grupos) self.layer_3 = self._make_layer(block_config[ 1][1],block_config[2][1],block_config[2][0],grupos) self.avgpool_1 = nn.AdaptiveAvgPool2d((1,1)) self.fc_1 = nn.Sequential( nn.Flatten( ), nn.Linear(1536,1000), nn.Softmax(dim = 1),)

def __init__(self): super(EfficientNet_B0,self).__init__() self.HeadConv = _Conv(3,32,3,2,1) self.MBConv1_1 = _MBConv(32,16,1,3,1,0.2, 4) self.MBConv6_1 = _MBConv(16,24,6,3,2,0.2,4) self.MBConv6_2 = _MBConv(24,24,6,3,1,0.2,4) self.MBConv6_3 = _MBConv(24, 40,6,5,2,0.2,4) self.MBConv6_4 = _MBConv(40,40,6,5,1,0.2,4) self.MBConv6_5 = _MBConv(40,80,6,3,2,0,2, 4) self.MBConv6_6 = _MBConv(80,80,6,3,1,0.2,4) self.MBConv6_7 = _MBConv(80,80,6,3,1,0.2,4) self.MBConv6_8 = _MBConv(80,112, 6,5,1,0.2,4) self.MBConv6_9 = _MBConv(112,112,6,5,1,0.2,4) self.MBConv6_10 = _MBConv(112,112,6,5,1,0.2,4) self.MBConv6_11 = _MBConv(112,192,6,5,2,0.2,4) self.MBConv6_12 = _MBConv(192,192,6,5,1,0.2,4) self.MBConv6_13 = _MBConv(192,192,6,5,1,0.2,4) self.MBConv6_14 = _MBConv(192,192,6,5,1,0.2,4) self.MBConv6_15 = _MBConv(192,320,6,3,1,0.2,4) self.logits = nn.Sequential( #_Conv(320,1280 ,1,1,0), nn.AdaptiveAvgPool2d((1,1)), nn.Flatten(), nn.Linear(320,1000), nn.Softmax(dim=1))

def __init__(self, w_in, nc): super(AnyHead, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(w_in, nc, bias=True)

def __init__(self, w_in, w_se): super(SE, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.f_ex = nn.Sequential( nn.Conv2d(w_in, w_se, 1, bias=True), nn.ReLU(inplace=True), nn.Conv2d(w_se, w_in, 1, bias=True), nn.Sigmoid(), )

def __init__(self,in_dim,ratio): super(_SElayer,self).__init__() self.gap = nn.AdaptiveAvgPool2d((1,1)) Reduced_dim = max(1, in_dim//ratio) self.fc1 = nn .Sequential(nn.Flatten(), nn.Linear(in_dim, Reduced_dim), nn.ReLU(inplace=True), nn.Linear(reduce_dim, in_dim), nn.Softmax(dim=1),)

def __init__(self): super(MnasNet_A1,self).__init__() self.HeadConv = _Conv(3,32,3,2,1) self.Seq_1 = _SepConv(32,16,3) self.MBConv6_1 = _MBConv( 16,24,6,3,2) self.MBConv6_2 = _MBConv(24,24,6,3,1) self.MBConv3_1 = _MBConv(24,40,3,5,2,4) self.MBConv3_2 = _MBConv( 40,40,3,5,1,4) self.MBConv3_3 = _MBConv(40,40,3,5,1,4) self.MBConv6_3 = _MBConv(40,80,6,3,2) self.MBConv6_4 = _MBConv(80,80,6,3,1) self.MBConv6_5 = _MBConv(80,80,6,3,1) self.MBConv6_6 = _MBConv(80,80,6,3,1) self.MBConv6_7 = _MBConv( 80,112,6,3,1,4) self.MBConv6_8 = _MBConv(112,112,6,3,1,4) self.MBConv6_9 = _MBConv(112,160,6,5,2,4) self.MBConv6_10 = _MBConv(160,160, 6,5,1,4) self.MBConv6_11 = _MBConv(160,160,6,5,1,4) self.MBConv6_12 = _MBConv(160,320,6,3,1) self.logits = nn.Sequential( nn.AdaptiveAvgPool2d( (1,1)), nn.Flatten(), nn.Linear(320,1000), nn.Softmax(dim=1))

def __init__(self, w_in, w_se): super(SE, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.f_ex = nn.Sequential( nn.Conv2d(w_in, w_se,". ". ". 1, bias=True), Swish(), nn.Conv2d(w_se, w_in, 1, bias=True), nn.Sigmoid(), );

def __init__(self): super(NIN,self).__init__() self.net_layers=nn.Sequential( nn.Conv2d(3,96,11,4,0), nn.ReLU(), nn.Conv2d(96 ,96,1,1,0), nn.ReLU(), nn.Conv2d(96,96,1,1,0), nn.ReLU(), nn.Conv2d(96,256,5,1,2), nn.ReLU(), nn.Conv2d(256,256,1,1,0), nn.ReLU(), nn.Conv2d(256,256,1,1,0), nn.ReLU(), nn.MaxPool2d(2, 2), nn.Conv2d(256.384,3,1,1), nn.ReLU(), nn.Conv2d(384.384,1,1,0), nn.ReLU(), nn.Conv2d(384.384,1,1 ,0), nn.ReLU(), nn.MaxPool2d(2,2), nn.Conv2d(384,1024,3,1,1), nn.ReLU(), nn.Conv2d(1024,1024,1, 1,0), nn.ReLU(), nn.Conv2d(1024,1024,1,1,0), nn.ReLU(), nn.MaxPool2d(2,2), nn.AdaptiveAvgPool2d((1,1) ), nn.Softmax(dim=1), ) self.initialization()

def __init__(self, cfg, logger): ''' block, BLOCK_LIST, in_dim, class_num, BASE=64, use_fc=True, CONV1=(7,2,3), MAX_POOL=True, pré-treinado=False ''' super (ResNet,self).__init__() self.head_conv = nn.Sequential( nn.Conv2d(cfg.IN_DIM,cfg.BASE,cfg.CONV1[0],cfg.CONV1[1],cfg.CONV1[2], bias=False), nn.BatchNorm2d(cfg.BASE), nn.ReLU(inplace=True),) se cfg.MAX_POOL: self.maxpool_1 = nn.MaxPool2d(3,2,1) else: self.maxpool_1 = nn .Sequential() block = BottleNeck if cfg.BLOCK == 'Engpass' sonst BasicBlock b_ = block.expansion self.layer_1 = self._make_layer(block,cfg.BASE,cfg.BASE*b_,cfg.BLOCK_LIST[0], cfg.STRIDE1,cfg.OPERATION) self.layer_2 = self._make_layer(block,cfg.BASE*b_,cfg.BASE*2*b_,cfg.BLOCK_LIST[1],2,cfg.OPERATION) self.layer_3 = selbst ._make_layer(block,cfg.BASE*2*b_,cfg.BASE*4*b_,cfg.BLOCK_LIST[2],2,cfg.OPERATION) self.layer_4 = self._make_layer(block,cfg.BASE*4* b_,cfg.BASE*8*b_,cfg.BLOCK_LIST[3],2,cfg.OPERATION) final_feature = cfg.BASE*4*b_ if cfg.BLOCK_LIST[3] == 0 else cfg.BASE *8*b_if cfg.USE_FC: self.avgpool_1 = nn.AdaptiveAvgPool2d((1,1)) self.fc_1 = nn.Sequential( nn.Flatten(), nn.Linear(final_feature,cfg.CLASS_NUM),) filhost: self.avgpool_1 = nn.Sequential() self.fc_1 = nn.Sequential() wenn cfg.DROPOUT > 0: self.dropout = nn.Dropout(p=cfg.DROPOUT) filhos: self.dropout = nn.Sequential() self.logger = Logger selbst.vortrainiert = cfg.PRETRAINED selbst._initialization()