def __init__(self, config: EfficientNetConfig): super(EfficientNet, self).__init__() bef_filter_num = round_filters(32, config.width, 8) self.modules = [ nn.Sequential( nn.Conv2d(in_channels=3, out_channels=bef_filter_num, kernel_size=3, padding=1, stride=2, bias=False), nn.BatchNorm2d(num_features=bef_filter_num, momentum=config.batch_norm_momentum), nn.SiLU()) ] sum_layers = 0 for k in self.baseline: k[0] = round_filters(k[0], config.width, 8) k[4] = round_repeats(k[4], config.depth) sum_layers += k[4] cnt_layers = 0 for k in self.baseline: channels, stride, kernel_size, expansion_ratio, num_layers = k cur_dropout = (cnt_layers / sum_layers) * config.dropout_rate block_conf = MBConvConfig(in_channels=bef_filter_num, out_channels=channels, kernel_size=kernel_size, stride=stride, expansion_ratio=expansion_ratio, se_ratio=0.25, dropout_rate=cur_dropout) self.modules.append(MBConv(block_conf, config)) cnt_layers += 1 if num_layers > 1: new_conf = copy.deepcopy(block_conf) new_conf.get_zero() for _ in range(num_layers - 1): cur_dropout = (cnt_layers / sum_layers) * config.dropout_rate new_conf.dropout_rate = cur_dropout self.modules.append(MBConv(new_conf, config)) cnt_layers += 1 bef_filter_num = channels # End of Conv final_channel = round_filters(1280, width=config.width, depth_divisor=8) self.modules.append( nn.Sequential( nn.Conv2d(in_channels=bef_filter_num, out_channels=final_channel, kernel_size=1, bias=False), nn.BatchNorm2d(num_features=final_channel, momentum=config.batch_norm_momentum), nn.SiLU(), nn.AdaptiveAvgPool2d(1), nn.Dropout(config.dropout_rate), nn.Flatten(), nn.Linear(final_channel, config.num_classes))) self.model = nn.Sequential(*self.modules)
def __init__(self, blocks_args=None, global_params=None): super().__init__() assert isinstance(blocks_args, list), 'blocks_args should be a list' assert len(blocks_args) > 0, 'block args must be greater than 0' self._global_params = global_params self._blocks_args = blocks_args # Batch norm parameters bn_mom = 1 - self._global_params.batch_norm_momentum bn_eps = self._global_params.batch_norm_epsilon # Get stem static or dynamic convolution depending on image size image_size = global_params.image_size Conv2d = get_same_padding_conv2d(image_size=image_size) # Stem in_channels = 3 # rgb out_channels = round_filters(32, self._global_params) # number of output channels self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False) self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) image_size = calculate_output_image_size(image_size, 2) # Build blocks self._blocks = nn.ModuleList([]) for block_args in self._blocks_args: # Update block input and output filters based on depth multiplier. block_args = block_args._replace( input_filters=round_filters(block_args.input_filters, self._global_params), output_filters=round_filters(block_args.output_filters, self._global_params), num_repeat=round_repeats(block_args.num_repeat, self._global_params) ) # The first block needs to take care of stride and filter size increase. self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size)) image_size = calculate_output_image_size(image_size, block_args.stride) if block_args.num_repeat > 1: # modify block_args to keep same output size block_args = block_args._replace(input_filters=block_args.output_filters, stride=1) for _ in range(block_args.num_repeat - 1): self._blocks.append(MBConvBlock(block_args, self._global_params, image_size=image_size)) # image_size = calculate_output_image_size(image_size, block_args.stride) # stride = 1 # Head in_channels = block_args.output_filters # output of final block out_channels = round_filters(1280, self._global_params) Conv2d = get_same_padding_conv2d(image_size=image_size) self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False) self._bn1 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) # Final linear layer self._avg_pooling = nn.AdaptiveAvgPool2d(1) self._dropout = nn.Dropout(self._global_params.dropout_rate) self._fc = nn.Linear(out_channels, self._global_params.num_classes) self._swish = MemoryEfficientSwish()
def _change_in_channels(self, in_channels): """Adjust model's first convolution layer to in_channels, if in_channels not equals 3. Args: in_channels (int): Input data's channel number. """ if in_channels != 3: Conv2d = get_same_padding_conv2d(image_size = self._global_params.image_size) out_channels = round_filters(32, self._global_params) self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
def from_pretrained(cls, model_name, num_classes=1000, in_channels=3): model = cls.from_name(model_name, override_params={'num_classes': num_classes}) load_pretrained_weights(model, model_name, load_fc=(num_classes == 1000)) if in_channels != 3: Conv2d = get_same_padding_conv2d( image_size=model._global_params.image_size) out_channels = round_filters(32, model._global_params) model._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False) return model
def __init__(self, width_coefficient, depth_coefficient, dropout_rate, drop_connect_rate=0.2): super(EfficientNet, self).__init__() print("EFFICIENTNET CLASS __INIT__") self.conv1 = Conv2D(filters=round_filters(32, width_coefficient), kernel_size=(3, 3), strides=2, padding='same', use_bias=False) self.bn1 = BatchNormalization() self.block1 = MBConvBlock( in_channels=round_filters(32, width_coefficient), out_channels=round_filters(16, width_coefficient), layer=round_repeats(1, depth_coefficient), stride=1, expansion_factor=1, k=3, drop_connect_rate=drop_connect_rate) self.block2 = MBConvBlock( in_channels=round_filters(16, width_coefficient), out_channels=round_filters(24, width_coefficient), layer=round_repeats(2, depth_coefficient), stride=2, expansion_factor=6, k=3, drop_connect_rate=drop_connect_rate) self.block3 = MBConvBlock( in_channels=round_filters(24, width_coefficient), out_channels=round_filters(40, width_coefficient), layer=round_repeats(2, depth_coefficient), stride=2, expansion_factor=6, k=5, drop_connect_rate=drop_connect_rate) self.block4 = MBConvBlock( in_channels=round_filters(40, width_coefficient), out_channels=round_filters(80, width_coefficient), layer=round_repeats(3, depth_coefficient), stride=2, expansion_factor=6, k=3, drop_connect_rate=drop_connect_rate) self.block5 = MBConvBlock( in_channels=round_filters(80, width_coefficient), out_channels=round_filters(112, width_coefficient), layer=round_repeats(3, depth_coefficient), stride=1, expansion_factor=6, k=5, drop_connect_rate=drop_connect_rate) self.block6 = MBConvBlock( in_channels=round_filters(112, width_coefficient), out_channels=round_filters(192, width_coefficient), layer=round_repeats(4, depth_coefficient), stride=2, expansion_factor=6, k=5, drop_connect_rate=drop_connect_rate) self.block7 = MBConvBlock( in_channels=round_filters(192, width_coefficient), out_channels=round_filters(320, width_coefficient), layer=round_repeats(1, depth_coefficient), stride=1, expansion_factor=6, k=3, drop_connect_rate=drop_connect_rate) self.conv2 = Conv2D(filters=round_filters(1280, width_coefficient), kernel_size=(1, 1), strides=1, padding='same', use_bias=False) self.bn2 = BatchNormalization() self.pool = GlobalAveragePooling2D() self.dropout = Dropout(rate=dropout_rate) self.fc = Dense(units=NUM_CLASSES, activation=softmax)
def __init__(self, blocks_args=None, global_params=None, ds_low=None, ds_high=None): super().__init__() assert isinstance(blocks_args, list), 'blocks_args should be a list' assert len(blocks_args) > 0, 'block args must be greater than 0' assert ds_high > ds_low, 'ds_high must be greater than ds_low' assert max( ds_high, ds_low) <= 32, 'downsampling time should not be greater than 32' self._global_params = global_params self._blocks_args = blocks_args self.ds_low = ds_low self.ds_high = ds_high # Get static or dynamic convolution depending on image size Conv2d = get_same_padding_conv2d(image_size=global_params.image_size) # Batch norm parameters bn_mom = 1 - self._global_params.batch_norm_momentum bn_eps = self._global_params.batch_norm_epsilon # Stem in_channels = 3 # rgb out_channels = round_filters( 32, self._global_params) # number of output channels self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False) self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) # Build blocks self._blocks = nn.ModuleList([]) # Calculate the number of blocks block_indexs = [0, 1, 2, 4, 5, 6] if ds_high == None: self.num_blocks = 7 else: self.num_blocks = round(math.log(self.ds_high, 2)) for block_args in self._blocks_args[0:block_indexs[self.num_blocks]]: # Update block input and output filters based on depth multiplier. block_args = block_args._replace( input_filters=round_filters(block_args.input_filters, self._global_params), output_filters=round_filters(block_args.output_filters, self._global_params), num_repeat=round_repeats(block_args.num_repeat, self._global_params)) # The first block needs to take care of stride and filter size increase. self._blocks.append(MBConvBlock(block_args, self._global_params)) if block_args.num_repeat > 1: block_args = block_args._replace( input_filters=block_args.output_filters, stride=1) for _ in range(block_args.num_repeat - 1): self._blocks.append( MBConvBlock(block_args, self._global_params)) # Head in_channels = block_args.output_filters # output of final block out_channels = round_filters(1280, self._global_params) #self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False) #self._bn1 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) # Final linear layer #self._avg_pooling = nn.AdaptiveAvgPool2d(1) #self._dropout = nn.Dropout(self._global_params.dropout_rate) #self._fc = nn.Linear(out_channels, self._global_params.num_classes) self._swish = MemoryEfficientSwish()
def __init__(self, blocks_args=None, global_params=None, norm='', model_version=4): super().__init__() assert isinstance(blocks_args, list), 'blocks_args should be a list' assert len(blocks_args) > 0, 'block args must be greater than 0' self.g_cfg = global_params self.b_cfgs = blocks_args # Get static or dynamic convolution depending on image size Conv2d = get_same_padding_conv2d(image_size=global_params.image_size) # Batch norm parameters bn_mom = 1 - self.g_cfg.batch_norm_momentum bn_eps = self.g_cfg.batch_norm_epsilon # Stem in_channels = 3 # rgb out_channels = round_filters(32, self.g_cfg) # number of output channels self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False) # self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) self._bn0 = get_norm(norm, out_channels) # Build blocks self._blocks = nn.ModuleList([]) idx = 0 out_inds = [] out_channels = [] for b_cfg in self.b_cfgs: # Update block input and output filters based on depth multiplier. b_cfg = b_cfg._replace( input_filters=round_filters(b_cfg.input_filters, self.g_cfg), output_filters=round_filters(b_cfg.output_filters, self.g_cfg), num_repeat=round_repeats(b_cfg.num_repeat, self.g_cfg)) # The first block needs to take care of stride and filter size increase. self._blocks.append(MBConvBlock(b_cfg, self.g_cfg, norm)) print(b_cfg.stride) if b_cfg.stride[0] != 1: out_inds.append(idx - 1) out_channels.append(b_cfg.input_filters) idx += 1 if b_cfg.num_repeat > 1: b_cfg = b_cfg._replace(input_filters=b_cfg.output_filters, stride=1) for _ in range(b_cfg.num_repeat - 1): self._blocks.append(MBConvBlock(b_cfg, self.g_cfg, norm)) idx += 1 out_inds.append(idx - 1) out_channels.append(b_cfg.output_filters) self.out_block_inds_all_stage = out_inds self.out_block_inds = out_inds[1:] self._out_feature_channels = out_channels[1:] # Head # in_channels = block_args.output_filters # output of final block # out_channels = round_filters(1280, self._global_params) # self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False) # self._bn1 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) # # # Final linear layer # self._avg_pooling = nn.AdaptiveAvgPool2d(1) # self._dropout = nn.Dropout(self._global_params.dropout_rate) # self._fc = nn.Linear(out_channels, self._global_params.num_classes) self._swish = MemoryEfficientSwish()
def __init__(self, blocks_args, global_params, heads, head_conv): super(EfficientNet, self).__init__() assert isinstance(blocks_args, list), 'blocks_args should be a list' assert len(blocks_args) > 0, 'block args must be greater than 0' self._global_params = global_params self._blocks_args = blocks_args self._heads = heads # Batch norm parameters bn_mom = 1 - self._global_params.batch_norm_momentum bn_eps = self._global_params.batch_norm_epsilon # Stem in_channels = 3 # rgb out_channels = round_filters( 32, self._global_params) # number of output channels self._conv_stem = Conv2dSamePadding(in_channels, out_channels, kernel_size=3, stride=2, bias=False) self._bn0 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps) # Build blocks self._blocks = nn.ModuleList([]) for block_args in self._blocks_args: # Update block input and output filters based on depth multiplier. block_args = block_args._replace( input_filters=round_filters(block_args.input_filters, self._global_params), output_filters=round_filters(block_args.output_filters, self._global_params), num_repeat=round_repeats(block_args.num_repeat, self._global_params)) # The first block needs to take care of stride and filter size increase. self._blocks.append(MBConvBlock(block_args, self._global_params)) if block_args.num_repeat > 1: block_args = block_args._replace( input_filters=block_args.output_filters, stride=1) for _ in range(block_args.num_repeat - 1): self._blocks.append( MBConvBlock(block_args, self._global_params)) self._blocks = self._blocks[0:11] for head in self._heads: classes = self._heads[head] if head_conv > 0: fc = nn.Sequential( nn.Conv2d(112, head_conv, kernel_size=3, padding=1, bias=True), nn.ReLU(inplace=True), nn.Conv2d(head_conv, classes, kernel_size=1, stride=1, padding=0, bias=True)) if 'hm' in head: fc[-1].bias.data.fill_(-2.19) else: fill_fc_weights(fc) else: fc = nn.Conv2d(112, classes, kernel_size=1, stride=1, padding=0, bias=True) if 'hm' in head: fc.bias.data.fill_(-2.19) else: fill_fc_weights(fc) self.__setattr__(head, fc) '''