import torch.nn as nn import torch from torchvision.ops.boxes import nms as nms_torch import torch.nn.functional as F import math from functools import partial def nms(dets, thresh): return nms_torch(dets[:, :4], dets[:, 4], thresh) class SeparableConvBlock(nn.Module): def __init__(self, in_channels, out_channels=None, norm=True, activation=False, onnx_export=False): super(SeparableConvBlock, self).__init__() if out_channels is None: out_channels = in_channels # Q: whether separate conv # share bias between depthwise_conv and pointwise_conv # or just pointwise_conv apply bias. # A: Confirmed, just pointwise_conv applies bias, depthwise_conv has no bias. self.depthwise_conv = Conv2dStaticSamePadding(in_channels, in_channels, kernel_size=3, stride=1, groups=in_channels, bias=False) self.pointwise_conv = Conv2dStaticSamePadding(in_channels, out_channels, kernel_size=1, stride=1) self.norm = norm if self.norm: # Warning: pytorch momentum is different from tensorflow's, momentum_pytorch = 1 - momentum_tensorflow self.bn = nn.BatchNorm2d(num_features=out_channels, momentum=0.01, eps=1e-3) self.activation = activation if self.activation: self.swish = MemoryEfficientSwish() if not onnx_export else Swish() def forward(self, x): x = self.depthwise_conv(x) x = self.pointwise_conv(x) if self.norm: x = self.bn(x) if self.activation: x = self.swish(x) return x class BiFPN(nn.Module): def __init__(self, num_channels, conv_channels, first_time=False, epsilon=1e-4, onnx_export=False, attention=True, use_p8=False): """ Args: num_channels: conv_channels: first_time: whether the input comes directly from the efficientnet, if True, downchannel it first, and downsample P5 to generate P6 then P7 epsilon: epsilon of fast weighted attention sum of BiFPN, not the BN's epsilon onnx_export: if True, use Swish instead of MemoryEfficientSwish """ super(BiFPN, self).__init__() self.epsilon = epsilon self.use_p8 = use_p8 # Conv layers self.conv6_up = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv5_up = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv4_up = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv3_up = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv4_down = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv5_down = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv6_down = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv7_down = SeparableConvBlock(num_channels, onnx_export=onnx_export) if use_p8: self.conv7_up = SeparableConvBlock(num_channels, onnx_export=onnx_export) self.conv8_down = SeparableConvBlock(num_channels, onnx_export=onnx_export) # Feature scaling layers self.p6_upsample = nn.Upsample(scale_factor=2, mode='nearest') self.p5_upsample = nn.Upsample(scale_factor=2, mode='nearest') self.p4_upsample = nn.Upsample(scale_factor=2, mode='nearest') self.p3_upsample = nn.Upsample(scale_factor=2, mode='nearest') self.p4_downsample = MaxPool2dStaticSamePadding(3, 2) self.p5_downsample = MaxPool2dStaticSamePadding(3, 2) self.p6_downsample = MaxPool2dStaticSamePadding(3, 2) self.p7_downsample = MaxPool2dStaticSamePadding(3, 2) if use_p8: self.p7_upsample = nn.Upsample(scale_factor=2, mode='nearest') self.p8_downsample = MaxPool2dStaticSamePadding(3, 2) self.swish = MemoryEfficientSwish() if not onnx_export else Swish() self.first_time = first_time if self.first_time: self.p5_down_channel = nn.Sequential( Conv2dStaticSamePadding(conv_channels[2], num_channels, 1), nn.BatchNorm2d(num_channels, momentum=0.01, eps=1e-3), ) self.p4_down_channel = nn.Sequential( Conv2dStaticSamePadding(conv_channels[1], num_channels, 1), nn.BatchNorm2d(num_channels, momentum=0.01, eps=1e-3), ) self.p3_down_channel = nn.Sequential( Conv2dStaticSamePadding(conv_channels[0], num_channels, 1), nn.BatchNorm2d(num_channels, momentum=0.01, eps=1e-3), ) self.p5_to_p6 = nn.Sequential( Conv2dStaticSamePadding(conv_channels[2], num_channels, 1), nn.BatchNorm2d(num_channels, momentum=0.01, eps=1e-3), MaxPool2dStaticSamePadding(3, 2) ) self.p6_to_p7 = nn.Sequential( MaxPool2dStaticSamePadding(3, 2) ) if use_p8: self.p7_to_p8 = nn.Sequential( MaxPool2dStaticSamePadding(3, 2) ) self.p4_down_channel_2 = nn.Sequential( Conv2dStaticSamePadding(conv_channels[1], num_channels, 1), nn.BatchNorm2d(num_channels, momentum=0.01, eps=1e-3), ) self.p5_down_channel_2 = nn.Sequential( Conv2dStaticSamePadding(conv_channels[2], num_channels, 1), nn.BatchNorm2d(num_channels, momentum=0.01, eps=1e-3), ) # Weight self.p6_w1 = nn.Parameter(torch.ones(2, dtype=torch.float32), requires_grad=True) self.p6_w1_relu = nn.ReLU() self.p5_w1 = nn.Parameter(torch.ones(2, dtype=torch.float32), requires_grad=True) self.p5_w1_relu = nn.ReLU() self.p4_w1 = nn.Parameter(torch.ones(2, dtype=torch.float32), requires_grad=True) self.p4_w1_relu = nn.ReLU() self.p3_w1 = nn.Parameter(torch.ones(2, dtype=torch.float32), requires_grad=True) self.p3_w1_relu = nn.ReLU() self.p4_w2 = nn.Parameter(torch.ones(3, dtype=torch.float32), requires_grad=True) self.p4_w2_relu = nn.ReLU() self.p5_w2 = nn.Parameter(torch.ones(3, dtype=torch.float32), requires_grad=True) self.p5_w2_relu = nn.ReLU() self.p6_w2 = nn.Parameter(torch.ones(3, dtype=torch.float32), requires_grad=True) self.p6_w2_relu = nn.ReLU() self.p7_w2 = nn.Parameter(torch.ones(2, dtype=torch.float32), requires_grad=True) self.p7_w2_relu = nn.ReLU() self.attention = attention def forward(self, inputs): """ illustration of a minimal bifpn unit P7_0 -------------------------> P7_2 --------> |-------------| ↑ ↓ | P6_0 ---------> P6_1 ---------> P6_2 --------> |-------------|--------------↑ ↑ ↓ | P5_0 ---------> P5_1 ---------> P5_2 --------> |-------------|--------------↑ ↑ ↓ | P4_0 ---------> P4_1 ---------> P4_2 --------> |-------------|--------------↑ ↑ |--------------↓ | P3_0 -------------------------> P3_2 --------> """ # downsample channels using same-padding conv2d to target phase's if not the same # judge: same phase as target, # if same, pass; # elif earlier phase, downsample to target phase's by pooling # elif later phase, upsample to target phase's by nearest interpolation if self.attention: outs = self._forward_fast_attention(inputs) else: outs = self._forward(inputs) return outs def _forward_fast_attention(self, inputs): if self.first_time: p3, p4, p5 = inputs p6_in = self.p5_to_p6(p5) p7_in = self.p6_to_p7(p6_in) p3_in = self.p3_down_channel(p3) p4_in = self.p4_down_channel(p4) p5_in = self.p5_down_channel(p5) else: # P3_0, P4_0, P5_0, P6_0 and P7_0 p3_in, p4_in, p5_in, p6_in, p7_in = inputs # P7_0 to P7_2 # Weights for P6_0 and P7_0 to P6_1 p6_w1 = self.p6_w1_relu(self.p6_w1) weight = p6_w1 / (torch.sum(p6_w1, dim=0) + self.epsilon) # Connections for P6_0 and P7_0 to P6_1 respectively p6_up = self.conv6_up(self.swish(weight[0] * p6_in + weight[1] * self.p6_upsample(p7_in))) # Weights for P5_0 and P6_1 to P5_1 p5_w1 = self.p5_w1_relu(self.p5_w1) weight = p5_w1 / (torch.sum(p5_w1, dim=0) + self.epsilon) # Connections for P5_0 and P6_1 to P5_1 respectively p5_up = self.conv5_up(self.swish(weight[0] * p5_in + weight[1] * self.p5_upsample(p6_up))) # Weights for P4_0 and P5_1 to P4_1 p4_w1 = self.p4_w1_relu(self.p4_w1) weight = p4_w1 / (torch.sum(p4_w1, dim=0) + self.epsilon) # Connections for P4_0 and P5_1 to P4_1 respectively p4_up = self.conv4_up(self.swish(weight[0] * p4_in + weight[1] * self.p4_upsample(p5_up))) # Weights for P3_0 and P4_1 to P3_2 p3_w1 = self.p3_w1_relu(self.p3_w1) weight = p3_w1 / (torch.sum(p3_w1, dim=0) + self.epsilon) # Connections for P3_0 and P4_1 to P3_2 respectively p3_out = self.conv3_up(self.swish(weight[0] * p3_in + weight[1] * self.p3_upsample(p4_up))) if self.first_time: p4_in = self.p4_down_channel_2(p4) p5_in = self.p5_down_channel_2(p5) # Weights for P4_0, P4_1 and P3_2 to P4_2 p4_w2 = self.p4_w2_relu(self.p4_w2) weight = p4_w2 / (torch.sum(p4_w2, dim=0) + self.epsilon) # Connections for P4_0, P4_1 and P3_2 to P4_2 respectively p4_out = self.conv4_down( self.swish(weight[0] * p4_in + weight[1] * p4_up + weight[2] * self.p4_downsample(p3_out))) # Weights for P5_0, P5_1 and P4_2 to P5_2 p5_w2 = self.p5_w2_relu(self.p5_w2) weight = p5_w2 / (torch.sum(p5_w2, dim=0) + self.epsilon) # Connections for P5_0, P5_1 and P4_2 to P5_2 respectively p5_out = self.conv5_down( self.swish(weight[0] * p5_in + weight[1] * p5_up + weight[2] * self.p5_downsample(p4_out))) # Weights for P6_0, P6_1 and P5_2 to P6_2 p6_w2 = self.p6_w2_relu(self.p6_w2) weight = p6_w2 / (torch.sum(p6_w2, dim=0) + self.epsilon) # Connections for P6_0, P6_1 and P5_2 to P6_2 respectively p6_out = self.conv6_down( self.swish(weight[0] * p6_in + weight[1] * p6_up + weight[2] * self.p6_downsample(p5_out))) # Weights for P7_0 and P6_2 to P7_2 p7_w2 = self.p7_w2_relu(self.p7_w2) weight = p7_w2 / (torch.sum(p7_w2, dim=0) + self.epsilon) # Connections for P7_0 and P6_2 to P7_2 p7_out = self.conv7_down(self.swish(weight[0] * p7_in + weight[1] * self.p7_downsample(p6_out))) return p3_out, p4_out, p5_out, p6_out, p7_out def _forward(self, inputs): if self.first_time: p3, p4, p5 = inputs p6_in = self.p5_to_p6(p5) p7_in = self.p6_to_p7(p6_in) if self.use_p8: p8_in = self.p7_to_p8(p7_in) p3_in = self.p3_down_channel(p3) p4_in = self.p4_down_channel(p4) p5_in = self.p5_down_channel(p5) else: if self.use_p8: # P3_0, P4_0, P5_0, P6_0, P7_0 and P8_0 p3_in, p4_in, p5_in, p6_in, p7_in, p8_in = inputs else: # P3_0, P4_0, P5_0, P6_0 and P7_0 p3_in, p4_in, p5_in, p6_in, p7_in = inputs if self.use_p8: # P8_0 to P8_2 # Connections for P7_0 and P8_0 to P7_1 respectively p7_up = self.conv7_up(self.swish(p7_in + self.p7_upsample(p8_in))) # Connections for P6_0 and P7_0 to P6_1 respectively p6_up = self.conv6_up(self.swish(p6_in + self.p6_upsample(p7_up))) else: # P7_0 to P7_2 # Connections for P6_0 and P7_0 to P6_1 respectively p6_up = self.conv6_up(self.swish(p6_in + self.p6_upsample(p7_in))) # Connections for P5_0 and P6_1 to P5_1 respectively p5_up = self.conv5_up(self.swish(p5_in + self.p5_upsample(p6_up))) # Connections for P4_0 and P5_1 to P4_1 respectively p4_up = self.conv4_up(self.swish(p4_in + self.p4_upsample(p5_up))) # Connections for P3_0 and P4_1 to P3_2 respectively p3_out = self.conv3_up(self.swish(p3_in + self.p3_upsample(p4_up))) if self.first_time: p4_in = self.p4_down_channel_2(p4) p5_in = self.p5_down_channel_2(p5) # Connections for P4_0, P4_1 and P3_2 to P4_2 respectively p4_out = self.conv4_down( self.swish(p4_in + p4_up + self.p4_downsample(p3_out))) # Connections for P5_0, P5_1 and P4_2 to P5_2 respectively p5_out = self.conv5_down( self.swish(p5_in + p5_up + self.p5_downsample(p4_out))) # Connections for P6_0, P6_1 and P5_2 to P6_2 respectively p6_out = self.conv6_down( self.swish(p6_in + p6_up + self.p6_downsample(p5_out))) if self.use_p8: # Connections for P7_0, P7_1 and P6_2 to P7_2 respectively p7_out = self.conv7_down( self.swish(p7_in + p7_up + self.p7_downsample(p6_out))) # Connections for P8_0 and P7_2 to P8_2 p8_out = self.conv8_down(self.swish(p8_in + self.p8_downsample(p7_out))) return p3_out, p4_out, p5_out, p6_out, p7_out, p8_out else: # Connections for P7_0 and P6_2 to P7_2 p7_out = self.conv7_down(self.swish(p7_in + self.p7_downsample(p6_out))) return p3_out, p4_out, p5_out, p6_out, p7_out class Regressor(nn.Module): def __init__(self, in_channels, num_anchors, num_layers, pyramid_levels=5, onnx_export=False): super(Regressor, self).__init__() self.num_layers = num_layers self.conv_list = nn.ModuleList( [SeparableConvBlock(in_channels, in_channels, norm=False, activation=False) for i in range(num_layers)]) self.bn_list = nn.ModuleList( [nn.ModuleList([nn.BatchNorm2d(in_channels, momentum=0.01, eps=1e-3) for i in range(num_layers)]) for j in range(pyramid_levels)]) self.header = SeparableConvBlock(in_channels, num_anchors * 4, norm=False, activation=False) self.swish = MemoryEfficientSwish() if not onnx_export else Swish() def forward(self, inputs): feats = [] for feat, bn_list in zip(inputs, self.bn_list): for i, bn, conv in zip(range(self.num_layers), bn_list, self.conv_list): feat = conv(feat) feat = bn(feat) feat = self.swish(feat) feat = self.header(feat) feat = feat.permute(0, 2, 3, 1) feat = feat.contiguous().view(feat.shape[0], -1, 4) feats.append(feat) feats = torch.cat(feats, dim=1) return feats class Conv3x3BNSwish(nn.Module): def __init__(self, in_channels, out_channels, upsample=False): super().__init__() self.swish = Swish() self.upsample = upsample self.block = nn.Sequential( Conv2dStaticSamePadding(in_channels, out_channels, kernel_size=(3, 3), stride=1, padding=1, bias=False), nn.BatchNorm2d(out_channels, momentum=0.01, eps=1e-3), ) self.conv_sp = SeparableConvBlock(out_channels, onnx_export=False) # self.block = nn.Sequential( # nn.Conv2d( # in_channels, out_channels, (3, 3), stride=1, padding=1, bias=False # ), # nn.GroupNorm(32, out_channels), # nn.ReLU(inplace=True), # ) def forward(self, x): x = self.conv_sp(self.swish(self.block(x))) if self.upsample: x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True) return x class SegmentationBlock(nn.Module): def __init__(self, in_channels, out_channels, n_upsamples=0): super().__init__() blocks = [Conv3x3BNSwish(in_channels, out_channels, upsample=bool(n_upsamples))] if n_upsamples > 1: for _ in range(1, n_upsamples): blocks.append(Conv3x3BNSwish(out_channels, out_channels, upsample=True)) self.block = nn.Sequential(*blocks) def forward(self, x): return self.block(x) class MergeBlock(nn.Module): def __init__(self, policy): super().__init__() if policy not in ["add", "cat"]: raise ValueError( "`merge_policy` must be one of: ['add', 'cat'], got {}".format( policy ) ) self.policy = policy def forward(self, x): if self.policy == 'add': return sum(x) elif self.policy == 'cat': return torch.cat(x, dim=1) else: raise ValueError( "`merge_policy` must be one of: ['add', 'cat'], got {}".format(self.policy) ) class BiFPNDecoder(nn.Module): def __init__( self, encoder_depth=5, pyramid_channels=64, segmentation_channels=64, dropout=0.2, merge_policy="add", ): super().__init__() self.seg_blocks = nn.ModuleList([ SegmentationBlock(pyramid_channels, segmentation_channels, n_upsamples=n_upsamples) for n_upsamples in [5,4, 3, 2, 1] ]) self.seg_p2 = SegmentationBlock(32, 64, n_upsamples=0) self.merge = MergeBlock(merge_policy) self.dropout = nn.Dropout2d(p=dropout, inplace=True) def forward(self, inputs): p2, p3, p4, p5, p6, p7 = inputs feature_pyramid = [seg_block(p) for seg_block, p in zip(self.seg_blocks, [p7, p6, p5, p4, p3])] p2 = self.seg_p2(p2) p3,p4,p5,p6,p7 = feature_pyramid x = self.merge((p2,p3,p4,p5,p6,p7)) x = self.dropout(x) return x class Classifier(nn.Module): def __init__(self, in_channels, num_anchors, num_classes, num_layers, pyramid_levels=5, onnx_export=False): super(Classifier, self).__init__() self.num_anchors = num_anchors self.num_classes = num_classes self.num_layers = num_layers self.conv_list = nn.ModuleList( [SeparableConvBlock(in_channels, in_channels, norm=False, activation=False) for i in range(num_layers)]) self.bn_list = nn.ModuleList( [nn.ModuleList([nn.BatchNorm2d(in_channels, momentum=0.01, eps=1e-3) for i in range(num_layers)]) for j in range(pyramid_levels)]) self.header = SeparableConvBlock(in_channels, num_anchors * num_classes, norm=False, activation=False) self.swish = MemoryEfficientSwish() if not onnx_export else Swish() def forward(self, inputs): feats = [] for feat, bn_list in zip(inputs, self.bn_list): for i, bn, conv in zip(range(self.num_layers), bn_list, self.conv_list): feat = conv(feat) feat = bn(feat) feat = self.swish(feat) feat = self.header(feat) feat = feat.permute(0, 2, 3, 1) feat = feat.contiguous().view(feat.shape[0], feat.shape[1], feat.shape[2], self.num_anchors, self.num_classes) feat = feat.contiguous().view(feat.shape[0], -1, self.num_classes) feats.append(feat) feats = torch.cat(feats, dim=1) feats = feats.sigmoid() return feats class SwishImplementation(torch.autograd.Function): @staticmethod def forward(ctx, i): result = i * torch.sigmoid(i) ctx.save_for_backward(i) return result @staticmethod def backward(ctx, grad_output): i = ctx.saved_variables[0] sigmoid_i = torch.sigmoid(i) return grad_output * (sigmoid_i * (1 + i * (1 - sigmoid_i))) class MemoryEfficientSwish(nn.Module): def forward(self, x): return SwishImplementation.apply(x) class Swish(nn.Module): def forward(self, x): return x * torch.sigmoid(x) def drop_connect(inputs, p, training): """ Drop connect. """ if not training: return inputs batch_size = inputs.shape[0] keep_prob = 1 - p random_tensor = keep_prob random_tensor += torch.rand([batch_size, 1, 1, 1], dtype=inputs.dtype, device=inputs.device) binary_tensor = torch.floor(random_tensor) output = inputs / keep_prob * binary_tensor return output def get_same_padding_conv2d(image_size=None): """ Chooses static padding if you have specified an image size, and dynamic padding otherwise. Static padding is necessary for ONNX exporting of models. """ if image_size is None: return Conv2dDynamicSamePadding else: return partial(Conv2dStaticSamePadding, image_size=image_size) class Conv2dDynamicSamePadding(nn.Conv2d): """ 2D Convolutions like TensorFlow, for a dynamic image size """ def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, groups=1, bias=True): super().__init__(in_channels, out_channels, kernel_size, stride, 0, dilation, groups, bias) self.stride = self.stride if len(self.stride) == 2 else [self.stride[0]] * 2 def forward(self, x): ih, iw = x.size()[-2:] kh, kw = self.weight.size()[-2:] sh, sw = self.stride oh, ow = math.ceil(ih / sh), math.ceil(iw / sw) pad_h = max((oh - 1) * self.stride[0] + (kh - 1) * self.dilation[0] + 1 - ih, 0) pad_w = max((ow - 1) * self.stride[1] + (kw - 1) * self.dilation[1] + 1 - iw, 0) if pad_h > 0 or pad_w > 0: x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2]) return F.conv2d(x, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups) class MBConvBlock(nn.Module): """ Mobile Inverted Residual Bottleneck Block Args: block_args (namedtuple): BlockArgs, see above global_params (namedtuple): GlobalParam, see above Attributes: has_se (bool): Whether the block contains a Squeeze and Excitation layer. """ def __init__(self, block_args, global_params): super().__init__() self._block_args = block_args self._bn_mom = 1 - global_params.batch_norm_momentum self._bn_eps = global_params.batch_norm_epsilon self.has_se = (self._block_args.se_ratio is not None) and (0 < self._block_args.se_ratio <= 1) self.id_skip = block_args.id_skip # skip connection and drop connect # Get static or dynamic convolution depending on image size Conv2d = get_same_padding_conv2d(image_size=global_params.image_size) # Expansion phase inp = self._block_args.input_filters # number of input channels oup = self._block_args.input_filters * self._block_args.expand_ratio # number of output channels if self._block_args.expand_ratio != 1: self._expand_conv = Conv2d(in_channels=inp, out_channels=oup, kernel_size=1, bias=False) self._bn0 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps) # Depthwise convolution phase k = self._block_args.kernel_size s = self._block_args.stride self._depthwise_conv = Conv2d( in_channels=oup, out_channels=oup, groups=oup, # groups makes it depthwise kernel_size=k, stride=s, bias=False) self._bn1 = nn.BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps) # Squeeze and Excitation layer, if desired if self.has_se: num_squeezed_channels = max(1, int(self._block_args.input_filters * self._block_args.se_ratio)) self._se_reduce = Conv2d(in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1) self._se_expand = Conv2d(in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1) # Output phase final_oup = self._block_args.output_filters self._project_conv = Conv2d(in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False) self._bn2 = nn.BatchNorm2d(num_features=final_oup, momentum=self._bn_mom, eps=self._bn_eps) self._swish = MemoryEfficientSwish() def forward(self, inputs, drop_connect_rate=None): """ :param inputs: input tensor :param drop_connect_rate: drop connect rate (float, between 0 and 1) :return: output of block """ # Expansion and Depthwise Convolution x = inputs if self._block_args.expand_ratio != 1: x = self._expand_conv(inputs) x = self._bn0(x) x = self._swish(x) x = self._depthwise_conv(x) x = self._bn1(x) x = self._swish(x) # Squeeze and Excitation if self.has_se: x_squeezed = F.adaptive_avg_pool2d(x, 1) x_squeezed = self._se_reduce(x_squeezed) x_squeezed = self._swish(x_squeezed) x_squeezed = self._se_expand(x_squeezed) x = torch.sigmoid(x_squeezed) * x x = self._project_conv(x) x = self._bn2(x) # Skip connection and drop connect input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters: if drop_connect_rate: x = drop_connect(x, p=drop_connect_rate, training=self.training) x = x + inputs # skip connection return x def set_swish(self, memory_efficient=True): """Sets swish function as memory efficient (for training) or standard (for export)""" self._swish = MemoryEfficientSwish() if memory_efficient else Swish() class Conv2dStaticSamePadding(nn.Module): """ The real keras/tensorflow conv2d with same padding """ def __init__(self, in_channels, out_channels, kernel_size, stride=1, bias=True, groups=1, dilation=1, **kwargs): super().__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, bias=bias, groups=groups) self.stride = self.conv.stride self.kernel_size = self.conv.kernel_size self.dilation = self.conv.dilation if isinstance(self.stride, int): self.stride = [self.stride] * 2 elif len(self.stride) == 1: self.stride = [self.stride[0]] * 2 if isinstance(self.kernel_size, int): self.kernel_size = [self.kernel_size] * 2 elif len(self.kernel_size) == 1: self.kernel_size = [self.kernel_size[0]] * 2 def forward(self, x): h, w = x.shape[-2:] extra_h = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1] extra_v = (math.ceil(h / self.stride[0]) - 1) * self.stride[0] - h + self.kernel_size[0] left = extra_h // 2 right = extra_h - left top = extra_v // 2 bottom = extra_v - top x = F.pad(x, [left, right, top, bottom]) x = self.conv(x) return x class MaxPool2dStaticSamePadding(nn.Module): """ The real keras/tensorflow MaxPool2d with same padding """ def __init__(self, *args, **kwargs): super().__init__() self.pool = nn.MaxPool2d(*args, **kwargs) self.stride = self.pool.stride self.kernel_size = self.pool.kernel_size if isinstance(self.stride, int): self.stride = [self.stride] * 2 elif len(self.stride) == 1: self.stride = [self.stride[0]] * 2 if isinstance(self.kernel_size, int): self.kernel_size = [self.kernel_size] * 2 elif len(self.kernel_size) == 1: self.kernel_size = [self.kernel_size[0]] * 2 def forward(self, x): h, w = x.shape[-2:] extra_h = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1] extra_v = (math.ceil(h / self.stride[0]) - 1) * self.stride[0] - h + self.kernel_size[0] left = extra_h // 2 right = extra_h - left top = extra_v // 2 bottom = extra_v - top x = F.pad(x, [left, right, top, bottom]) x = self.pool(x) return x class Activation(nn.Module): def __init__(self, name, **params): super().__init__() if name is None or name == 'identity': self.activation = nn.Identity(**params) elif name == 'sigmoid': self.activation = nn.Sigmoid() elif name == 'softmax2d': self.activation = nn.Softmax(dim=1, **params) elif name == 'softmax': self.activation = nn.Softmax(**params) elif name == 'logsoftmax': self.activation = nn.LogSoftmax(**params) elif name == 'tanh': self.activation = nn.Tanh() # elif name == 'argmax': # self.activation = ArgMax(**params) # elif name == 'argmax2d': # self.activation = ArgMax(dim=1, **params) # elif name == 'clamp': # self.activation = Clamp(**params) elif callable(name): self.activation = name(**params) else: raise ValueError('Activation should be callable/sigmoid/softmax/logsoftmax/tanh/None; got {}'.format(name)) def forward(self, x): return self.activation(x) class SegmentationHead(nn.Sequential): def __init__(self, in_channels, out_channels, kernel_size=3, activation=None, upsampling=1): conv2d = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, padding=kernel_size // 2) upsampling = nn.UpsamplingBilinear2d(scale_factor=upsampling) if upsampling > 1 else nn.Identity() activation = Activation(activation) super().__init__(conv2d, upsampling, activation) class ClassificationHead(nn.Sequential): def __init__(self, in_channels, classes, pooling="avg", dropout=0.2, activation=None): if pooling not in ("max", "avg"): raise ValueError("Pooling should be one of ('max', 'avg'), got {}.".format(pooling)) pool = nn.AdaptiveAvgPool2d(1) if pooling == 'avg' else nn.AdaptiveMaxPool2d(1) flatten = nn.Flatten() dropout = nn.Dropout(p=dropout, inplace=True) if dropout else nn.Identity() linear = nn.Linear(in_channels, classes, bias=True) activation = Activation(activation) super().__init__(pool, flatten, dropout, linear, activation) if __name__ == '__main__': from tensorboardX import SummaryWriter def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad)