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)
