def __init__(self, encoder_name, classes, pretrained, in_channels='rgb', verbose=0): super().__init__(verbose) if pretrained: self.encoder = EfficientNet.from_pretrained(encoder_name, num_classes=classes) else: self.encoder = EfficientNet.from_name( encoder_name, override_params={'num_classes': classes}) # modify input channels Conv2d = get_same_padding_conv2d( image_size=self.encoder._global_params.image_size) conv_stem = Conv2d(len(in_channels), self.encoder._conv_stem.out_channels, kernel_size=3, stride=2, bias=False) transfer_weights(self.encoder._conv_stem, conv_stem, in_channels) self.encoder._conv_stem = conv_stem self.decoder = Noop() # for compatibility with segmentation models self.logger.info(f'<init>: \n{self}')
def from_pretrained(cls, model_name, advprop=False, 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), advprop=advprop) 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 _change_in_channels(model, in_channels): 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)
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 # 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 # Build blocks self._blocks = nn.ModuleList([]) for i, block_args in enumerate(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), ) print(i, block_args) # 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) # Define the activation function 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 __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 # 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([]) 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)) # 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, 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 = InPlaceABN(oup) # 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 = InPlaceABN(oup) # Squeeze and Excitation layer, if desired ## Deleted it from here # 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 = InPlaceABN(final_oup)
def __init__(self, model_name='efficientnet-b0', use_pretrained=False, in_channels=3): super(EfficientNetWrapper, self).__init__() if use_pretrained: self.model = EfficientNet.from_pretrained(model_name=model_name, in_channels=in_channels) else: model = EfficientNet.from_name(model_name, 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) self.model = model
def __init__(self, name='efficientnet-b0', pretrained=True, input_bn=True, dropout=0.3, head='V1'): super().__init__() self.input_bn = input_bn self.name = name if pretrained: self.net = EfficientNet.from_pretrained(model_name=name) else: self.net = EfficientNet.from_name(model_name=name) params = efficientnet_params(model_name=name) Conv2d = get_same_padding_conv2d(image_size=params[2]) conv_stem_filts = { 'efficientnet-b0': 32, 'efficientnet-b4': 48, 'efficientnet-b7': 64, } linear_size = { 'efficientnet-b0': 1280, 'efficientnet-b4': 1792, 'efficientnet-b7': 2560 } self.net._conv_stem = Conv2d(1, conv_stem_filts[name], kernel_size=(3, 3), stride=(2, 2), bias=False) self.cls1, self.cls2, self.cls3 = get_head(False, head, in_size=linear_size[name]) if input_bn: self.bn_in = nn.BatchNorm2d(1)
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()
import torch
def __init__(self, blocks, blocks_args=None, global_params=None, out_channels=256): 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 # Get static or dynamic convolution depending on image size Conv2d = get_same_padding_conv2d(image_size=global_params.image_size) # Stem self._conv_stem = Conv2d(3, 48, kernel_size=3, stride=2, bias=False) self._bn0 = InPlaceABN(48) #blocks self.blocks0 = blocks[0] self.blocks1 = blocks[1] self.blocks2 = blocks[2] self.blocks3 = blocks[3] self.blocks4 = blocks[4] self.blocks5 = blocks[5] self.blocks6 = blocks[6] # Head self._conv_head = Conv2d(512, 2048, kernel_size=1, bias=False) self._bn1 = InPlaceABN(2048) same_Conv2d = get_same_padding_conv2d( image_size=global_params.image_size) # upper pyramid self.conv_up1 = same_Conv2d(40, 256, kernel_size=1, stride=1, bias=False) self.conv_up2 = same_Conv2d(64, 256, kernel_size=1, stride=1, bias=False) self.conv_up3 = same_Conv2d(176, 256, kernel_size=1, stride=1, bias=False) self.conv_up4 = same_Conv2d(2048, 256, kernel_size=1, stride=1, bias=False) self.inABNone = InPlaceABN(256) self.inABNtwo = InPlaceABN(256) self.inABNthree = InPlaceABN(256) self.inABNfour = InPlaceABN(256) #separable self.separable1 = SeparableConv2d(256, 256, 3) self.separable2 = SeparableConv2d(256, 256, 3) self.separable3 = SeparableConv2d(256, 256, 3) self.separable4 = SeparableConv2d(256, 256, 3) self.SepinABNone = InPlaceABN(256) self.SepinABNtwo = InPlaceABN(256) self.SepinABNthree = InPlaceABN(256) self.SepinABNfour = InPlaceABN(256) # upsample bilinear self.up1 = nn.Upsample(scale_factor=2, mode='bilinear') self.up2 = nn.Upsample(scale_factor=2, mode='bilinear') self.up3 = nn.Upsample(scale_factor=2, mode='bilinear') # downsample self.down1 = nn.MaxPool2d(2, stride=2) self.down2 = nn.MaxPool2d(2, stride=2) self.down3 = nn.MaxPool2d(2, stride=2) #additional layer self.additional_down = nn.MaxPool2d(2, stride=2) self.out_channels = out_channels
def __init__(self, input_filters, output_filters, image_size, expand_ratio, kernel_size=3, stride=1, has_se=True, id_skip=True, se_ratio=0.25): super().__init__() self._bn_mom = 1 - 0.99 self._bn_eps = 0.001 self.has_se = has_se self.id_skip = id_skip self.stride = stride self.input_filters = input_filters self.output_filters = output_filters self.expand_ratio = expand_ratio # Get static or dynamic convolution depending on image size Conv2d = get_same_padding_conv2d(image_size=image_size) # Expansion phase inp = input_filters # number of input channels oup = input_filters * expand_ratio # number of output channels if 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 = kernel_size s = 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(input_filters * 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 = 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)