|
|
|
from abc import abstractmethod |
|
|
|
import torch |
|
import torch.nn as nn |
|
import torch.nn.functional as F |
|
|
|
from ..cnn import ConvModule |
|
|
|
|
|
class BaseMergeCell(nn.Module): |
|
"""The basic class for cells used in NAS-FPN and NAS-FCOS. |
|
|
|
BaseMergeCell takes 2 inputs. After applying convolution |
|
on them, they are resized to the target size. Then, |
|
they go through binary_op, which depends on the type of cell. |
|
If with_out_conv is True, the result of output will go through |
|
another convolution layer. |
|
|
|
Args: |
|
in_channels (int): number of input channels in out_conv layer. |
|
out_channels (int): number of output channels in out_conv layer. |
|
with_out_conv (bool): Whether to use out_conv layer |
|
out_conv_cfg (dict): Config dict for convolution layer, which should |
|
contain "groups", "kernel_size", "padding", "bias" to build |
|
out_conv layer. |
|
out_norm_cfg (dict): Config dict for normalization layer in out_conv. |
|
out_conv_order (tuple): The order of conv/norm/activation layers in |
|
out_conv. |
|
with_input1_conv (bool): Whether to use convolution on input1. |
|
with_input2_conv (bool): Whether to use convolution on input2. |
|
input_conv_cfg (dict): Config dict for building input1_conv layer and |
|
input2_conv layer, which is expected to contain the type of |
|
convolution. |
|
Default: None, which means using conv2d. |
|
input_norm_cfg (dict): Config dict for normalization layer in |
|
input1_conv and input2_conv layer. Default: None. |
|
upsample_mode (str): Interpolation method used to resize the output |
|
of input1_conv and input2_conv to target size. Currently, we |
|
support ['nearest', 'bilinear']. Default: 'nearest'. |
|
""" |
|
|
|
def __init__(self, |
|
fused_channels=256, |
|
out_channels=256, |
|
with_out_conv=True, |
|
out_conv_cfg=dict( |
|
groups=1, kernel_size=3, padding=1, bias=True), |
|
out_norm_cfg=None, |
|
out_conv_order=('act', 'conv', 'norm'), |
|
with_input1_conv=False, |
|
with_input2_conv=False, |
|
input_conv_cfg=None, |
|
input_norm_cfg=None, |
|
upsample_mode='nearest'): |
|
super(BaseMergeCell, self).__init__() |
|
assert upsample_mode in ['nearest', 'bilinear'] |
|
self.with_out_conv = with_out_conv |
|
self.with_input1_conv = with_input1_conv |
|
self.with_input2_conv = with_input2_conv |
|
self.upsample_mode = upsample_mode |
|
|
|
if self.with_out_conv: |
|
self.out_conv = ConvModule( |
|
fused_channels, |
|
out_channels, |
|
**out_conv_cfg, |
|
norm_cfg=out_norm_cfg, |
|
order=out_conv_order) |
|
|
|
self.input1_conv = self._build_input_conv( |
|
out_channels, input_conv_cfg, |
|
input_norm_cfg) if with_input1_conv else nn.Sequential() |
|
self.input2_conv = self._build_input_conv( |
|
out_channels, input_conv_cfg, |
|
input_norm_cfg) if with_input2_conv else nn.Sequential() |
|
|
|
def _build_input_conv(self, channel, conv_cfg, norm_cfg): |
|
return ConvModule( |
|
channel, |
|
channel, |
|
3, |
|
padding=1, |
|
conv_cfg=conv_cfg, |
|
norm_cfg=norm_cfg, |
|
bias=True) |
|
|
|
@abstractmethod |
|
def _binary_op(self, x1, x2): |
|
pass |
|
|
|
def _resize(self, x, size): |
|
if x.shape[-2:] == size: |
|
return x |
|
elif x.shape[-2:] < size: |
|
return F.interpolate(x, size=size, mode=self.upsample_mode) |
|
else: |
|
assert x.shape[-2] % size[-2] == 0 and x.shape[-1] % size[-1] == 0 |
|
kernel_size = x.shape[-1] // size[-1] |
|
x = F.max_pool2d(x, kernel_size=kernel_size, stride=kernel_size) |
|
return x |
|
|
|
def forward(self, x1, x2, out_size=None): |
|
assert x1.shape[:2] == x2.shape[:2] |
|
assert out_size is None or len(out_size) == 2 |
|
if out_size is None: |
|
out_size = max(x1.size()[2:], x2.size()[2:]) |
|
|
|
x1 = self.input1_conv(x1) |
|
x2 = self.input2_conv(x2) |
|
|
|
x1 = self._resize(x1, out_size) |
|
x2 = self._resize(x2, out_size) |
|
|
|
x = self._binary_op(x1, x2) |
|
if self.with_out_conv: |
|
x = self.out_conv(x) |
|
return x |
|
|
|
|
|
class SumCell(BaseMergeCell): |
|
|
|
def __init__(self, in_channels, out_channels, **kwargs): |
|
super(SumCell, self).__init__(in_channels, out_channels, **kwargs) |
|
|
|
def _binary_op(self, x1, x2): |
|
return x1 + x2 |
|
|
|
|
|
class ConcatCell(BaseMergeCell): |
|
|
|
def __init__(self, in_channels, out_channels, **kwargs): |
|
super(ConcatCell, self).__init__(in_channels * 2, out_channels, |
|
**kwargs) |
|
|
|
def _binary_op(self, x1, x2): |
|
ret = torch.cat([x1, x2], dim=1) |
|
return ret |
|
|
|
|
|
class GlobalPoolingCell(BaseMergeCell): |
|
|
|
def __init__(self, in_channels=None, out_channels=None, **kwargs): |
|
super().__init__(in_channels, out_channels, **kwargs) |
|
self.global_pool = nn.AdaptiveAvgPool2d((1, 1)) |
|
|
|
def _binary_op(self, x1, x2): |
|
x2_att = self.global_pool(x2).sigmoid() |
|
return x2 + x2_att * x1 |
|
|
