Class EfficientNet

CV/Pytorch_classification/EfficientNet/model.py:186–284

        return result
        
class EfficientNet(nn.Module):
    def __init__(self,
                width_coefficient: float,
                depth_coefficient: float,
                num_classes: int = 1000,
                dropout_rate: float = 0.2,
                drop_connect_rate: float = 0.2,
                block: Optional[Callable[..., nn.Module]] = None,
                norm_layer: Optional[Callable[..., nn.Module]] = None):
        super(EfficientNet, self).__init__()
        
        # kernel_size, in_channel, out_channel, exp_ratio, strides, use_SE, drop_connect_rate, repeats
        default_cnf = [[3, 32, 16, 1, 1, True, drop_connect_rate, 1],
                       [3, 16, 24, 6, 2, True, drop_connect_rate, 2],
                       [5, 24, 40, 6, 2, True, drop_connect_rate, 2],
                       [3, 40, 80, 6, 2, True, drop_connect_rate, 3],
                       [5, 80, 112, 6, 1, True, drop_connect_rate, 3],
                       [5, 112, 192, 6, 2, True, drop_connect_rate, 4],
                       [3, 192, 320, 6, 1, True, drop_connect_rate, 1]]

        def round_repeats(repeats):
            """Round number of repeats based on depth multiplier."""
            return int(math.ceil(depth_coefficient * repeats))
        
        if block is None:
            block = InvertedResidual
            
        if norm_layer is None:
            norm_layer = partial(nn.BatchNorm2d, eps=1e-3, momentum=0.1)

        adjust_channels = partial(InvertedResidualConfig.adjust_channels, width_coefficient=width_coefficient)
        
        # build inverted_rsidual_setting
        bneck_conf = partial(InvertedResidualConfig, width_coefficient=width_coefficient)
        
        b = 0
        num_blocks = float(sum(round_repeats(i[-1]) for i in default_cnf))
        inverted_residual_setting = []
        for stage, args in enumerate(default_cnf):
            cnf = copy.copy(args)
            for i in range(round_repeats(cnf.pop(-1))):
                if i > 0:
                    # strides equal 1 except first cnf
                    cnf[-3] = 1 # strides
                    cnf[1] = cnf[2] # input_channel equal output_channel
                cnf[-1] = args[-2] * b / num_blocks # update dropout ratio
                index = str(stage + 1) + chr(i + 97)
                inverted_residual_setting.append(bneck_conf(*cnf, index))
        # create layers
        layers = OrderedDict()
        
        # first conv
        layers.update({"stem_conv": ConvBNActivation(in_planes=3,
                                                     out_planes=adjust_channels(32),
                                                     kernel_size=3,
                                                     stride=2,
                                                     norm_layer=norm_layer)})        
        # building inverted residual blocks