Python torch.nn.AdaptiveAvgPool2d() Examples
The following are 30
code examples of torch.nn.AdaptiveAvgPool2d().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
torch.nn
, or try the search function
.
.
Example #1
| Source File: rfp.py From mmdetection with Apache License 2.0 | 7 votes |
|
def __init__(self, in_channels, out_channels, dilations=(1, 3, 6, 1)):
super().__init__()
assert dilations[-1] == 1
self.aspp = nn.ModuleList()
for dilation 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,
stride=1,
dilation=dilation,
padding=padding,
bias=True)
self.aspp.append(conv)
self.gap = nn.AdaptiveAvgPool2d(1)
self.init_weights()
Example #2
| Source File: simple_attention.py From argus-freesound with MIT License | 6 votes |
|
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),
)
Example #3
| Source File: operators.py From Fast_Seg with Apache License 2.0 | 6 votes |
|
def __init__(self, in_planes, out_planes,
reduction=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 // reduction, 1, 1, 0,
has_bn=False, norm_layer=norm_layer,
has_relu=True, has_bias=False),
ConvBnRelu(out_planes // reduction, out_planes, 1, 1, 0,
has_bn=False, norm_layer=norm_layer,
has_relu=False, has_bias=False),
nn.Sigmoid()
)
Example #4
| Source File: MobileNetV3.py From MobileNetV3-pytorch with MIT License | 6 votes |
|
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
Example #5
| Source File: MobileNetV3.py From MobileNetV3-pytorch with MIT License | 6 votes |
|
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 = num_classes
Example #6
| Source File: MobileNet.py From Pytorch-Networks with MIT License | 6 votes |
|
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)
)
Example #7
| Source File: DenseNet2016.py From Pytorch-Networks with MIT License | 6 votes |
|
def __init__(self,k,block_list,num_init_features=64, bn_size=4,
drop_rate=0, memory_efficient=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_efficient)
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()
Example #8
| Source File: squeeze_excitation.py From Parsing-R-CNN with MIT License | 6 votes |
|
def __init__(self, inplanes, kernel=3, reduction=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 // reduction),
nn.ReLU(inplace=True),
nn.Linear(inplanes // reduction, inplanes),
nn.Sigmoid()
)
self._init_weights()
Example #9
| Source File: roi_box_predictors.py From Res2Net-maskrcnn with MIT License | 6 votes |
|
def __init__(self, config, in_channels):
super(FastRCNNPredictor, self).__init__()
assert in_channels is not 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)
Example #10
| Source File: base.py From fast-MPN-COV with MIT License | 6 votes |
|
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,
basemodel.Conv2d_4a_3x3,
nn.MaxPool2d(kernel_size=3, stride=2),
basemodel.Mixed_5b,
basemodel.Mixed_5c,
basemodel.Mixed_5d,
basemodel.Mixed_6a,
basemodel.Mixed_6b,
basemodel.Mixed_6c,
basemodel.Mixed_6d,
basemodel.Mixed_6e,
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)
return model
Example #11
| Source File: outputs.py From Parsing-R-CNN with MIT License | 6 votes |
|
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 and fg
self.bbox_pred = nn.Linear(self.dim_in, 4 * 2)
else:
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)
Example #12
| Source File: ResNeXt2016.py From Pytorch-Networks with MIT License | 6 votes |
|
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,cardinality)
self.layer_2 = self._make_layer(block,128*b_,256*b_,block_list[1],2,cardinality)
self.layer_3 = self._make_layer(block,256*b_,512*b_,block_list[2],2,cardinality)
self.layer_4 = self._make_layer(block,512*b_,1024*b_,block_list[3],2,cardinality)
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()
Example #13
| Source File: ResNetV2.py From Pytorch-Networks with MIT License | 6 votes |
|
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.Sequential(
nn.Flatten(),
nn.Linear(512*b_,1000),
nn.Softmax(dim = 1),)
self._initialization()
Example #14
| Source File: detnet_backbone.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
|
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 64
super(DetNet, 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)
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_new_layer(256, layers[3])
self.layer5 = self._make_new_layer(256, layers[4])
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Linear(1024, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
Example #15
| Source File: detnet_backbone.py From cascade-rcnn_Pytorch with MIT License | 6 votes |
|
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 64
super(DetNet, 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)
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_new_layer(256, layers[3])
self.layer5 = self._make_new_layer(256, layers[4])
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Linear(1024, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
Example #16
| Source File: roi_box_predictors.py From R2CNN.pytorch with MIT License | 6 votes |
|
def __init__(self, config, in_channels):
super(FastRCNNPredictor, self).__init__()
assert in_channels is not 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)
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)
nn.init.normal_(self.quad_pred.weight, mean=0, std=0.001)
nn.init.constant_(self.quad_pred.bias, 0)
Example #17
| Source File: senet.py From pneumothorax-segmentation with MIT License | 5 votes |
|
def __init__(self, channels, reduction, concat=False):
super(SEModule, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = nn.Conv2d(channels, channels // reduction, kernel_size=1, padding=0)
self.relu = nn.ReLU(inplace=True)
self.fc2 = nn.Conv2d(channels // reduction, channels, kernel_size=1, padding=0)
self.sigmoid = nn.Sigmoid()
Example #18
| Source File: outputs.py From Parsing-R-CNN with MIT License | 5 votes |
|
def __init__(self, dim_in):
super().__init__()
self.dim_in = dim_in
self.cls_score = nn.Linear(self.dim_in, cfg.MODEL.NUM_CLASSES)
# self.avgpool = nn.AdaptiveAvgPool2d(1)
if cfg.FAST_RCNN.CLS_AGNOSTIC_BBOX_REG: # bg and fg
self.bbox_pred = nn.Linear(self.dim_in, 4 * 2)
else:
raise NotImplementedError
# self.bbox_pred = nn.Linear(self.dim_in, 4 * cfg.MODEL.NUM_CLASSES)
self._init_weights()
Example #19
| Source File: dpn.py From pneumothorax-segmentation with MIT License | 5 votes |
|
def __init__(self, output_size=1, pool_type='avg'):
super(AdaptiveAvgMaxPool2d, self).__init__()
self.output_size = output_size
self.pool_type = pool_type
if pool_type == 'avgmaxc' or pool_type == 'avgmax':
self.pool = nn.ModuleList([nn.AdaptiveAvgPool2d(output_size), nn.AdaptiveMaxPool2d(output_size)])
elif pool_type == 'max':
self.pool = nn.AdaptiveMaxPool2d(output_size)
else:
if pool_type != 'avg':
print('Invalid pool type %s specified. Defaulting to average pooling.' % pool_type)
self.pool = nn.AdaptiveAvgPool2d(output_size)
Example #20
| Source File: ghostnet.py From ghostnet with Apache License 2.0 | 5 votes |
|
def __init__(self, in_chs, se_ratio=0.25, reduced_base_chs=None,
act_layer=nn.ReLU, gate_fn=hard_sigmoid, divisor=4, **_):
super(SqueezeExcite, self).__init__()
self.gate_fn = gate_fn
reduced_chs = _make_divisible((reduced_base_chs or in_chs) * se_ratio, divisor)
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.conv_reduce = nn.Conv2d(in_chs, reduced_chs, 1, bias=True)
self.act1 = act_layer(inplace=True)
self.conv_expand = nn.Conv2d(reduced_chs, in_chs, 1, bias=True)
Example #21
| Source File: operators.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def __init__(self, in_planes, out_planes,
norm_layer=nn.BatchNorm2d):
super(AttentionRefinement, self).__init__()
self.conv_3x3 = ConvBnRelu(in_planes, out_planes, 3, 1, 1,
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, 1, 1, 0,
has_bn=True, norm_layer=norm_layer,
has_relu=False, has_bias=False),
nn.Sigmoid()
)
Example #22
| Source File: operators.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def _make_stage(self, features, out_features, size, norm_layer):
prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
conv = nn.Conv2d(features, out_features, kernel_size=1, bias=False)
bn = norm_layer(out_features)
return nn.Sequential(prior, conv, bn)
Example #23
| Source File: operators.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def __init__(self, features, inner_features=256, out_features=512, dilations=(12, 24, 36), norm_layer=nn.BatchNorm2d):
super(ASPPModule, self).__init__()
self.conv1 = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1,
bias=False),
norm_layer(inner_features),
nn.ReLU()
)
self.conv2 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1, bias=False),
norm_layer(inner_features), nn.ReLU())
self.conv3 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[0], dilation=dilations[0], bias=False),
norm_layer(inner_features), nn.ReLU())
self.conv4 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[1], dilation=dilations[1], bias=False),
norm_layer(inner_features), nn.ReLU())
self.conv5 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[2], dilation=dilations[2], bias=False),
norm_layer(inner_features), nn.ReLU())
self.bottleneck = nn.Sequential(
nn.Conv2d(inner_features * 5, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
norm_layer(out_features),
nn.ReLU(),
nn.Dropout2d(0.1)
)
Example #24
| Source File: xception.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def __init__(self, num_classes=1000, norm_layer=nn.BatchNorm2d):
super(XceptionA, self).__init__()
self.conv1 = nn.Sequential(nn.Conv2d(3, 8, 3, 2, 1, bias=False),
norm_layer(8),
nn.ReLU())
self.enc2 = Enc(8, 48, 4, norm_layer=norm_layer)
self.enc3 = Enc(48, 96, 6, norm_layer=norm_layer)
self.enc4 = Enc(96, 192, 4, norm_layer=norm_layer)
self.fca = FCAttention(192, norm_layer=norm_layer)
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Linear(192, num_classes)
Example #25
| Source File: xception.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def __init__(self, in_channels, norm_layer=nn.BatchNorm2d):
super(FCAttention, self).__init__()
self.avgpool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Linear(in_channels, 1000)
self.conv = nn.Sequential(
nn.Conv2d(1000, in_channels, 1, bias=False),
norm_layer(in_channels),
nn.ReLU())
Example #26
| Source File: FastSCNN.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def pool(self, x, size):
avgpool = nn.AdaptiveAvgPool2d(size)
return avgpool(x)
Example #27
| Source File: PSPNet.py From Fast_Seg with Apache License 2.0 | 5 votes |
|
def _make_stage(self, features, out_features, size):
prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
conv = nn.Conv2d(features, out_features, kernel_size=1, bias=False)
bn = BatchNorm2d(out_features)
return nn.Sequential(prior, conv, bn)
Example #28
| Source File: SemBranch.py From Semantic-Aware-Scene-Recognition with MIT License | 5 votes |
|
def __init__(self, in_planes, ratio=16):
super(ChannelAttention, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.max_pool = nn.AdaptiveMaxPool2d(1)
self.fc1 = nn.Conv2d(in_planes, in_planes // 16, 1, bias=False)
self.fc2 = nn.Conv2d(in_planes // 16, in_planes, 1, bias=False)
self.relu1 = nn.ReLU()
self.sigmoid = nn.Sigmoid()
Example #29
| Source File: SASceneNet.py From Semantic-Aware-Scene-Recognition with MIT License | 5 votes |
|
def __init__(self, in_planes, ratio=16):
super(ChannelAttention, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.max_pool = nn.AdaptiveMaxPool2d(1)
self.fc1 = nn.Conv2d(in_planes, in_planes // 16, 1, bias=False)
self.fc2 = nn.Conv2d(in_planes // 16, in_planes, 1, bias=False)
self.relu1 = nn.ReLU()
self.sigmoid = nn.Sigmoid()
Example #30
| Source File: senet.py From Visualizing-CNNs-for-monocular-depth-estimation with MIT License | 5 votes |
|
def __init__(self, channels, reduction):
super(SEModule, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = nn.Conv2d(channels, channels // reduction, kernel_size=1,
padding=0)
self.relu = nn.ReLU(inplace=True)
self.fc2 = nn.Conv2d(channels // reduction, channels, kernel_size=1,
padding=0)
self.sigmoid = nn.Sigmoid()
