def mobv1_ssdlite_create(num_classes, alpha=1., is_test=False):
#Verandert bij het gebruik van LSTM
alpha_base = alpha
alpha_ssd = alpha
alpha_lstm = alpha
base_net = MobileNetV1(1001).model
source_layer_indexes = [
12,
14,
]
extras = nn.ModuleList([
nn.Sequential(
nn.Conv2d(in_channels=int(1024 * alpha_ssd),
out_channels=int(256 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=256 * alpha_ssd,
out_channels=512 * alpha_ssd,
kernel_size=3,
stride=2,
padding=1),
),
nn.Sequential(
nn.Conv2d(in_channels=int(256 * alpha_ssd),
out_channels=int(128 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=128 * alpha_ssd,
out_channels=256 * alpha_ssd,
kernel_size=3,
stride=2,
padding=1),
),
nn.Sequential(
nn.Conv2d(in_channels=int(256 * alpha_ssd),
out_channels=int(128 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=128 * alpha_ssd,
out_channels=256 * alpha_ssd,
kernel_size=3,
stride=2,
padding=1),
),
nn.Sequential(
nn.Conv2d(in_channels=int(256 * alpha_ssd),
out_channels=int(128 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=128 * alpha_ssd,
out_channels=256 * alpha_ssd,
kernel_size=3,
stride=2,
padding=1),
)
])
regression_headers = nn.ModuleList([
SeperableConv2d(in_channels=512 * alpha_base,
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=1024 * alpha_base,
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=512 * alpha_ssd,
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=256 * alpha_ssd,
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=256 * alpha_ssd,
out_channels=6 * 4,
kernel_size=3,
padding=1),
nn.Conv2d(in_channels=int(256 * alpha_ssd),
out_channels=6 * 4,
kernel_size=1),
])
classification_headers = nn.ModuleList([
SeperableConv2d(in_channels=512 * alpha_base,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=1024 * alpha_base,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=512 * alpha_ssd,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=256 * alpha_ssd,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=256 * alpha_ssd,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
nn.Conv2d(in_channels=int(256 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=1),
])
ssd = SSD(num_classes=num_classes,
base_net=base_net,
source_layer_indexes=source_layer_indexes,
extras=extras,
classification_headers=classification_headers,
regression_headers=regression_headers,
is_test=is_test,
config=config)
return ssd
'name': 'yolo',
'classes': 1,
'ignore_thresh': .5,
'bbox_loss': 'giou',
'l1_loss_gain': 0.1,
},
'dropout': {
'probability': 0.5,
}
}
ACTIVATION_MAP = {
'logistic': nn.Sigmoid,
'leaky': lambda: nn.LeakyReLU(0.1, inplace=True),
'relu': lambda: nn.ReLU(inplace=True),
'relu6': lambda: nn.ReLU6(inplace=True),
'tanh': nn.Tanh,
}
def str2value(ns):
try:
if '.' not in ns:
return int(ns)
return float(ns)
except ValueError:
return ns
class FC(nn.Module):
def __init__(self, input: int, output: int, activation: str):
super().__init__()
self.fc = nn.Linear(input, output)
def conv_1x1_bn(inp, oup):
return nn.Sequential(
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6(inplace=True)
)
def __init__(self, input_size, num_classes=100):
super(SimpleMLP, self).__init__()
self.simple = nn.Sequential(nn.Linear(input_size, 128),
nn.BatchNorm1d(128), nn.ReLU6(),
nn.Linear(128, num_classes))
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu6=False): super(_ConvBNReLU, self).__init__() self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias=False) self.bn = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU6(True) if relu6 else nn.ReLU(True)
def conv_bn(inp, oup, stride):
padding = (1, 1, 1, 1) if stride == 1 else (0, 1, 0, 1)
return nn.Sequential(nn.ConstantPad2d(padding, value=0.),
nn.Conv2d(inp, oup, 3, stride, 0, bias=False),
nn.BatchNorm2d(oup), nn.ReLU6(inplace=False))
def conv2d(self, inp, outp, stride):
kernel = 1 if stride == 1 else 3
padding = (kernel - 1) // 2
return nn.Sequential(
nn.Conv2d(inp, outp, kernel, stride, padding, bias=False),
nn.BatchNorm2d(outp), nn.ReLU6(True))
def __init__(self,
kernel_size,
in_channels,
out_channels,
stride,
expand_ratio=6,
se=False,
se_paras='s_4',
ratio=1.0):
super(MBInvertedConvLayer, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = kernel_size
self.stride = stride
self.expand_ratio = expand_ratio
if kernel_size == 1:
pad = 0
elif kernel_size == 3:
pad = 1
elif kernel_size == 5:
pad = 2
elif kernel_size == 7:
pad = 3
feature_dim = round(in_channels * self.expand_ratio)
middle_inc = int(feature_dim * ratio)
if middle_inc % 2 != 0:
middle_inc += 1
#print(feature_dim,middle_inc)
if se == False:
self.op = nn.Sequential(
nn.Conv2d(in_channels, middle_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(middle_inc),
nn.ReLU6(inplace=True),
nn.Conv2d(middle_inc,
middle_inc,
kernel_size,
stride,
pad,
groups=middle_inc,
bias=False),
nn.BatchNorm2d(middle_inc),
nn.ReLU6(inplace=True),
nn.Conv2d(middle_inc, out_channels, 1, 1, 0, bias=False),
nn.BatchNorm2d(out_channels),
)
else:
self.op = nn.Sequential(
nn.Conv2d(in_channels, middle_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(middle_inc),
nn.ReLU6(inplace=True),
nn.Conv2d(middle_inc,
middle_inc,
kernel_size,
stride,
pad,
groups=middle_inc,
bias=False),
nn.BatchNorm2d(middle_inc),
SEModule(middle_inc, se_paras),
nn.ReLU6(inplace=True),
nn.Conv2d(middle_inc, out_channels, 1, 1, 0, bias=False),
nn.BatchNorm2d(out_channels),
)
def __init__(self, activation, num_layers, in_dim, hidden_dim, out_dim):
super().__init__()
self.num_layers = num_layers
self.in_dim = in_dim
self.hidden_dim = hidden_dim
self.out_dim = out_dim
if activation is 'none':
self.activation = None
elif activation is 'hardtanh':
self.activation = nn.Hardtanh()
elif activation is 'sigmoid':
self.activation = nn.Sigmoid()
elif activation is 'relu6':
self.activation = nn.ReLU6()
elif activation is 'tanh':
self.activation = nn.Tanh()
elif activation is 'tanhshrink':
self.activation = nn.Tanhshrink()
elif activation is 'hardshrink':
self.activation = nn.Hardshrink()
elif activation is 'leakyrelu':
self.activation = nn.LeakyReLU()
elif activation is 'softshrink':
self.activation = nn.Softshrink()
elif activation is 'softsign':
self.activation = nn.Softsign()
elif activation is 'relu':
self.activation = nn.ReLU()
elif activation is 'prelu':
self.activation = nn.PReLU()
elif activation is 'softplus':
self.activation = nn.Softplus()
elif activation is 'elu':
self.activation = nn.ELU()
elif activation is 'selu':
self.activation = nn.SELU()
else:
raise ValueError("[!] Invalid activation function.")
layers = []
if self.activation is not None:
layers.extend([
nn.Linear(in_dim, hidden_dim),
self.activation,
])
else:
layers.append(nn.Linear(in_dim, hidden_dim))
for i in range(num_layers - 2):
if self.activation is not None:
layers.extend([
nn.Linear(hidden_dim, hidden_dim),
self.activation,
])
else:
layers.append(nn.Linear(hidden_dim, hidden_dim))
layers.append(nn.Linear(hidden_dim, out_dim))
self.model = nn.Sequential(*layers)
# init
for m in self.modules():
if isinstance(m, nn.Linear):
nn.init.kaiming_uniform_(m.weight, a=math.sqrt(5))
fan_in, _ = nn.init._calculate_fan_in_and_fan_out(m.weight)
bound = 1 / math.sqrt(fan_in)
nn.init.uniform_(m.bias, -bound, bound)
def __init__(self, num_classes = 2300):
super(MobileNetV2, self).__init__()
layers = []
## First Layer:
# [n, 3, 32, 32]
#input_conv = nn.Conv2d(3, 32, kernel_size = 3, stride = 2, padding = 1, bias = False)
input_conv = nn.Conv2d(3, 32, kernel_size = 1, stride = 1, padding = 0, bias = False)
input_bn = nn.BatchNorm2d(32)
input_relu = nn.ReLU6(inplace = True)
layers.append(input_conv)
layers.append(input_bn)
layers.append(input_relu)
# [n, 32, 16, 16]
# BottleNeck1
#layers.append(InvertedResidual(32, 16, t=1, kernel_size=3, stride=1))
layers.append(InvertedResidual(32, 16, t=1, kernel_size=1, stride=1))
#layers.append(nn.Dropout(p=0.2))
# [n, 16, 16, 16]
expansion = 6
# BottleNeck2
layers.append(InvertedResidual(16, 24, t=expansion, kernel_size=1, stride=1))
#layers.append(InvertedResidual(24, 24, t=expansion, kernel_size=1, stride=1))
#layers.append(InvertedResidual(16, 24, t=expansion, kernel_size=3, stride=2))
#layers.append(InvertedResidual(24, 24, t=expansion, kernel_size=3, stride=1))
#layers.append(InvertedResidual(24, 24, t=6, kernel_size=3, stride=1))
#layers.append(nn.Dropout(p=0.2))
# [n, 24, 8, 8]
# BottleNeck3
layers.append(InvertedResidual(24, 32, t=expansion, kernel_size=3, stride=1))
layers.append(InvertedResidual(32, 32, t=expansion, kernel_size=3, stride=1))
#layers.append(InvertedResidual(32, 32, t=expansion, kernel_size=3, stride=1))
#layers.append(nn.Dropout(p=0.1))
# [n, 32, 4, 4]
# BottleNeck4
layers.append(InvertedResidual(32, 64, t=expansion, kernel_size=3, stride=2))
layers.append(InvertedResidual(64, 64, t=expansion, kernel_size=3, stride=1))
#layers.append(InvertedResidual(64, 64, t=expansion, kernel_size=3, stride=1))
#layers.append(InvertedResidual(64, 64, t=expansion, kernel_size=3, stride=1))
# [n, 64, 4, 4]
# BottleNeck5
layers.append(InvertedResidual(64, 96, t=expansion, kernel_size=3, stride=2))
#layers.append(InvertedResidual(96, 96, t=expansion, kernel_size=3, stride=1))
#layers.append(InvertedResidual(96, 96, t=expansion, kernel_size=3, stride=1))
# [n, 96, 4, 4]
# BottleNeck6
#layers.append(InvertedResidual(96, 160, t=expansion, kernel_size=3, stride=2))
#layers.append(InvertedResidual(160, 160, t=expansion, kernel_size=3, stride=1))
#layers.append(InvertedResidual(160, 160, t=expansion, kernel_size=3, stride=1))
# [n, 160, 4, 4]
# BottleNeck7
#layers.append(InvertedResidual(160, 320, t=expansion, kernel_size=3, stride=1))
output_conv = nn.Conv2d(96, 512, kernel_size = 3, stride = 1, padding = 1, bias = False)
output_bn = nn.BatchNorm2d(512)
output_relu = nn.ReLU6(inplace = True)
layers.append(output_conv)
layers.append(output_bn)
layers.append(output_relu)
self.last_channel = 512
# building classifier
self.classifier = nn.Sequential(
nn.Dropout(0.3),
nn.Linear(self.last_channel, num_classes),
)
# weight initialization
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, nn.BatchNorm2d):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.zeros_(m.bias)
self.feature = nn.Sequential(*layers)
### THIS PART IS FOR CENTER LOSS
self.linear_closs = nn.Linear(512, 64, bias=False)
self.relu_closs = nn.ReLU(inplace=True)
def __init__(self,
num_classes=1000,
width_mult=1.0,
inverted_residual_setting=None,
round_nearest=8,
block=None,
norm_layer=None,
last_CN=None):
"""
MobileNet V2 main class
Args:
num_classes (int): Number of classes
width_mult (float): Width multiplier - adjusts number of channels in each layer by this amount
inverted_residual_setting: Network structure
round_nearest (int): Round the number of channels in each layer to be a multiple of this number
Set to 1 to turn off rounding
block: Module specifying inverted residual building block for mobilenet
norm_layer: Module specifying the normalization layer to use
"""
super(MobileNetV2, self).__init__()
if block is None:
block = InvertedResidual
if norm_layer is None:
norm_layer = nn.BatchNorm2d
input_channel = 32
last_channel = 1280
if inverted_residual_setting is None:
inverted_residual_setting = [
# t, c, n, s
[1, 16, 1, 1],
[6, 24, 2, 2],
[6, 32, 3, 2],
[6, 64, 4, 2],
[6, 96, 3, 1],
[6, 160, 3, 2],
[6, 320, 1, 1],
]
# only check the first element, assuming user knows t,c,n,s are required
if len(inverted_residual_setting) == 0 or len(
inverted_residual_setting[0]) != 4:
raise ValueError("inverted_residual_setting should be non-empty "
"or a 4-element list, got {}".format(
inverted_residual_setting))
# building first layer
input_channel = _make_divisible(input_channel * width_mult,
round_nearest)
self.last_channel = _make_divisible(
last_channel * max(1.0, width_mult), round_nearest)
features = [
ConvBNReLU(3, input_channel, stride=2, norm_layer=norm_layer)
]
# building inverted residual blocks
total = 0
for t, c, n, s in inverted_residual_setting:
output_channel = _make_divisible(c * width_mult, round_nearest)
for i in range(n):
total += 1
stride = s if i == 0 else 1
features.append(
block(input_channel,
output_channel,
stride,
expand_ratio=t,
norm_layer=norm_layer))
input_channel = output_channel
#building last several layers
features.append(
ConvBNReLU(input_channel,
self.last_channel,
kernel_size=1,
norm_layer=norm_layer))
# make it nn.Sequential
self.features = nn.Sequential(*features)
self.features_first = self.features[:9]
self.features_second = self.features[9:]
if not last_CN:
self.last_CN = self.last_channel
else:
self.last_CN = last_CN
# building classifier
self.num_ori = 12
self.num_shape = 40
self.num_exp = 10
self.num_texture = 40
self.num_bin = 121
self.num_scale = 1
self.num_trans = 3
if last_CN is not None:
self.connector = nn.Sequential(
nn.Linear(self.last_CN, self.last_CN // 16),
nn.ReLU6(inplace=True),
nn.Linear(self.last_CN // 16, self.last_CN),
nn.ReLU6(inplace=True), nn.Sigmoid())
self.adjuster = nn.Sequential(
nn.Linear(self.last_CN, self.last_CN),
nn.BatchNorm1d(self.last_CN))
self.classifier_ori = nn.Sequential(
nn.Dropout(0.2),
nn.Linear(self.last_CN, self.num_ori),
)
self.classifier_shape = nn.Sequential(
nn.Dropout(0.2),
nn.Linear(self.last_CN, self.num_shape),
)
self.classifier_exp = nn.Sequential(
nn.Dropout(0.2),
nn.Linear(self.last_CN, self.num_exp),
)
self.classifier_texture = nn.Sequential(
nn.Dropout(0.2),
nn.Linear(self.last_CN, self.num_texture),
)
# weight initialization
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.zeros_(m.bias)
def __init__(self, hidden_dim, input_dim=1):
super(ReadVideoEncoder, self).__init__()
self.W = nn.Parameter(torch.randn(hidden_dim, input_dim))
self.b = nn.Parameter(torch.randn(hidden_dim))
self.nonlinearity = nn.ReLU6()
def mobv2_ssdlite_lstm4_create(num_classes,
alpha=1.0,
use_batch_norm=True,
batch_size=None,
is_test=False):
#onderstaande verhoudingen staan rechtstreeks in de cijfers, je kan gewoon alpha gebruiken
alpha_base = alpha
alpha_ssd = 0.5 * alpha
alpha_lstm = 0.25 * alpha
base_net = MobileNetV2(width_mult=alpha_base,
use_batch_norm=use_batch_norm).features
source_layer_indexes = [
GraphPath(14, 'conv', 3),
19,
]
#input_channels krijgen multiplier van vorige soort laag !
extras = nn.ModuleList([
# verhouding input en output van bottleneck lstm is 1/4 vanwege 4 gates
# Bottleneck na laatste laag in base_net
BottleneckLSTM(input_channels=int(1280 * alpha),
hidden_channels=int(320 * alpha),
height=10,
width=10,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(320 * alpha),
out_channels=int(160 * alpha),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(160 * alpha),
out_channels=int(320 * alpha),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=int(320 * alpha),
hidden_channels=int(80 * alpha),
height=5,
width=5,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(80 * alpha),
out_channels=int(40 * alpha),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(40 * alpha),
out_channels=int(80 * alpha),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=int(80 * alpha),
hidden_channels=int(20 * alpha),
height=3,
width=3,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(20 * alpha),
out_channels=int(10 * alpha),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(10 * alpha),
out_channels=int(20 * alpha),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=int(20 * alpha),
hidden_channels=int(20 * alpha),
height=2,
width=2,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(20 * alpha),
out_channels=int(10 * alpha),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(10 * alpha),
out_channels=int(20 * alpha),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=int(20 * alpha),
hidden_channels=int(20 * alpha),
height=1,
width=1,
batch_size=batch_size),
])
regression_headers = nn.ModuleList([
SeperableConv2d(in_channels=int(576 * alpha),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(320 * alpha),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(80 * alpha),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(20 * alpha),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(20 * alpha),
out_channels=6 * 4,
kernel_size=3,
padding=1),
nn.Conv2d(in_channels=int(20 * alpha),
out_channels=6 * 4,
kernel_size=1)
])
classification_headers = nn.ModuleList([
SeperableConv2d(in_channels=int(576 * alpha),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(320 * alpha),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(80 * alpha),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(20 * alpha),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(20 * alpha),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
nn.Conv2d(in_channels=int(20 * alpha),
out_channels=6 * num_classes,
kernel_size=1)
])
"""
extras = nn.ModuleList([
#verhouding input en output van bottleneck lstm is 1/4 vanwege 4 gates
BottleneckLSTM(input_channels=int(1280*alpha_base), hidden_channels=int(320*alpha_lstm), height=10, width=10, batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(320*alpha_lstm), out_channels=int(160*alpha_ssd), kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(160*alpha_ssd), out_channels=int(320*alpha_ssd), kernel_size=3, stride=2, padding=1),
),
BottleneckLSTM(input_channels=int(320*alpha_ssd), hidden_channels=int(80*alpha_lstm), height=5, width=5, batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(80*alpha_lstm), out_channels=int(40*alpha_ssd), kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(40*alpha_ssd), out_channels=int(80*alpha_ssd), kernel_size=3, stride=2, padding=1),
),
BottleneckLSTM(input_channels=int(80*alpha_ssd), hidden_channels=int(20*alpha_lstm), height=3, width=3, batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(20*alpha_lstm), out_channels=int(10*alpha_ssd), kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(10*alpha_ssd), out_channels=int(20*alpha_ssd), kernel_size=3, stride=2, padding=1),
),
BottleneckLSTM(input_channels=int(20*alpha_ssd), hidden_channels=int(20*alpha_lstm), height=2, width=2, batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(20*alpha_ssd), out_channels=int(10*alpha_ssd), kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(10*alpha_ssd), out_channels=int(20*alpha_ssd), kernel_size=3, stride=2, padding=1),
)
])
regression_headers = nn.ModuleList([
SeperableConv2d(in_channels=int(576*alpha_base), out_channels=6 * 4, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(1280*alpha_base), out_channels=6 * 4, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(320*alpha_ssd), out_channels=6 * 4, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(80*alpha_ssd), out_channels=6 * 4, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(20*alpha_ssd), out_channels=6 * 4, kernel_size=3, padding=1),
nn.Conv2d(in_channels=int(20*alpha_ssd), out_channels=6 * 4, kernel_size=1)
])
classification_headers = nn.ModuleList([
SeperableConv2d(in_channels=int(576*alpha_base), out_channels=6 * num_classes, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(1280*alpha_base), out_channels=6 * num_classes, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(320*alpha_ssd), out_channels=6 * num_classes, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(80*alpha_ssd), out_channels=6 * num_classes, kernel_size=3, padding=1),
SeperableConv2d(in_channels=int(20*alpha_ssd), out_channels=6 * num_classes, kernel_size=3, padding=1),
nn.Conv2d(in_channels=int(20*alpha_ssd), out_channels=6 * num_classes, kernel_size=1)
])"""
ssd = SSD(num_classes=num_classes,
base_net=base_net,
source_layer_indexes=source_layer_indexes,
extras=extras,
classification_headers=classification_headers,
regression_headers=regression_headers,
is_test=is_test,
config=config)
return ssd
def mobv1_ssdlite_lstm4_create(num_classes,
alpha=1.,
batch_size=None,
is_test=False):
alpha_base = alpha
alpha_ssd = 0.5 * alpha
alpha_lstm = 0.25 * alpha
base_net = MobileNetV1(1001).model
source_layer_indexes = [
12,
14,
]
extras = nn.ModuleList([
BottleneckLSTM(input_channels=int(1024 * alpha_lstm),
hidden_channels=int(256 * alpha_lstm),
height=10,
width=10,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(256 * alpha_ssd),
out_channels=int(128 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(128 * alpha_ssd),
out_channels=int(256 * alpha_ssd),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=int(256 * alpha_lstm),
hidden_channels=int(64 * alpha_lstm),
height=5,
width=5,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(64 * alpha_ssd),
out_channels=int(32 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(32 * alpha_ssd),
out_channels=int(64 * alpha_ssd),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=64 * alpha_lstm,
hidden_channels=16 * alpha_lstm,
height=3,
width=3,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(16 * alpha_ssd),
out_channels=int(8 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(8 * alpha_ssd),
out_channels=int(16 * alpha_ssd),
kernel_size=3,
stride=2,
padding=1),
),
BottleneckLSTM(input_channels=int(16 * alpha_lstm),
hidden_channels=int(16 * alpha_lstm),
height=1,
width=1,
batch_size=batch_size),
nn.Sequential(
nn.Conv2d(in_channels=int(16 * alpha_ssd),
out_channels=int(8 * alpha_ssd),
kernel_size=1),
nn.ReLU6(inplace=False),
SeperableConv2d(in_channels=int(8 * alpha_ssd),
out_channels=int(16 * alpha_ssd),
kernel_size=3,
stride=2,
padding=1),
)
])
#op alles of enkel op laatste?
regression_headers = nn.ModuleList([
SeperableConv2d(in_channels=int(512 * alpha_ssd),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(256 * alpha_ssd),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(64 * alpha_ssd),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(16 * alpha_ssd),
out_channels=6 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(16 * alpha_ssd),
out_channels=6 * 4,
kernel_size=3,
padding=1),
nn.Conv2d(in_channels=int(16 * alpha_ssd),
out_channels=6 * 4,
kernel_size=1),
])
classification_headers = nn.ModuleList([
SeperableConv2d(in_channels=int(512 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(256 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(64 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(16 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=int(16 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
nn.Conv2d(in_channels=int(16 * alpha_ssd),
out_channels=6 * num_classes,
kernel_size=1),
])
ssd = SSD(num_classes=num_classes,
base_net=base_net,
source_layer_indexes=source_layer_indexes,
extras=extras,
classification_headers=classification_headers,
regression_headers=regression_headers,
is_test=is_test,
config=config)
return ssd
def conv_dw(inp, oup, stride, pad1=0, bias_ena=False):
padding = (1, 1, 1, 1) if stride == 1 else (0, 1, 0, 1)
return nn.Sequential(
nn.ConstantPad2d(padding, value=0.),
nn.Conv2d(inp, inp, 3, stride, 0, groups=inp, bias=bias_ena),
nn.BatchNorm2d(inp), nn.ReLU6(inplace=False))
def conv_block(inp, oup, stride, batch_norm):
return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
batch_norm(oup), nn.ReLU6(inplace=True))
def conv_pw(inp, oup, stride, bias_ena=False):
padding = (0, 0, 0, 0)
return nn.Sequential(nn.ConstantPad2d(padding, value=0.),
nn.Conv2d(inp, oup, 1, 1, 0, bias=bias_ena),
nn.BatchNorm2d(oup), nn.ReLU6(inplace=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._relu6 = nn.ReLU6()
self._swish = MemoryEfficientSwish()
def conv_bn(inp, oup, stride, BatchNorm):
return nn.Sequential(
nn.Conv3d(inp, oup, 3, stride, 1, bias=False), #in_ch, out_ch, kernel, stride, pad
BatchNorm(oup),
nn.ReLU6(inplace=True)
)
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
self.feature_input_size = [
56, 28, 14, 7
] # output sizes we are looking for overhaul distillation
# 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._relu6 = nn.ReLU6()
self._swish = MemoryEfficientSwish()
def __init__(self, inp, oup, stride, expand_ratio, keep_3x3=False):
super(I2RBlock, self).__init__()
assert stride in [1, 2]
hidden_dim = inp // expand_ratio
if hidden_dim < oup / 6.:
hidden_dim = math.ceil(oup / 6.)
hidden_dim = _make_divisible(hidden_dim, 16) # + 16
#self.relu = nn.ReLU6(inplace=True)
self.identity = False
self.identity_div = 1
self.expand_ratio = expand_ratio
if expand_ratio == 2:
self.conv = nn.Sequential(
# dw
nn.Conv2d(inp, inp, 3, 1, 1, groups=inp, bias=False),
nn.BatchNorm2d(inp),
nn.ReLU6(inplace=True),
# pw-linear
nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
nn.BatchNorm2d(hidden_dim),
# pw-linear
nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6(inplace=True),
# dw
nn.Conv2d(oup, oup, 3, stride, 1, groups=oup, bias=False),
nn.BatchNorm2d(oup),
)
elif inp != oup and stride == 1 and keep_3x3 == False:
self.conv = nn.Sequential(
# pw-linear
nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
nn.BatchNorm2d(hidden_dim),
# pw-linear
nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6(inplace=True),
)
elif inp != oup and stride == 2 and keep_3x3 == False:
self.conv = nn.Sequential(
# pw-linear
nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
nn.BatchNorm2d(hidden_dim),
# pw-linear
nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6(inplace=True),
# dw
nn.Conv2d(oup, oup, 3, stride, 1, groups=oup, bias=False),
nn.BatchNorm2d(oup),
)
else:
if keep_3x3 == False:
self.identity = True
self.conv = nn.Sequential(
# dw
# nn.Conv2d(inp, inp, 3, 1, 1, groups=inp, bias=False),
# nn.BatchNorm2d(inp),
# nn.ReLU6(inplace=True),
# pw
nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
nn.BatchNorm2d(hidden_dim),
#nn.ReLU6(inplace=True),
# pw
nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6(inplace=True),
# dw
nn.Conv2d(oup, oup, 3, 1, 1, groups=oup, bias=False),
nn.BatchNorm2d(oup),
)
def __init__(self, inplace=True):
super(h_sigmoid, self).__init__()
self.relu = nn.ReLU6(inplace=inplace)
def __init__(self):
super(HardSwish, self).__init__()
self.relu6 = nn.ReLU6()
def __init__(self,
baseWidth,
cardinality,
layers,
num_classes,
preactivation=True,
stochastic=True,
personalized=True,
activ_fun='relu'):
""" Constructor
Args:
baseWidth: baseWidth for ResNeXt.
cardinality: number of convolution groups.
layers: config of layers, e.g., [3, 4, 6, 3]
num_classes: number of classes
"""
super(ResNeXt, self).__init__()
block = Bottleneck
self.cardinality = cardinality
self.baseWidth = baseWidth
self.num_classes = num_classes
self.inplanes = 64
self.output_size = 64
self.depth = sum(layers)
self.preactivation = preactivation
self.stochastic = stochastic
self.personalized = personalized
self.activ_fun = activ_fun
self.conv1 = nn.Conv2d(3, 64, 7, 2, 3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
if activ_fun == 'relu':
self.relu = nn.ReLU(inplace=True)
else:
self.relu = nn.ReLU6(inplace=True)
self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.maxpool1 = nn.Conv2d(64, 64, 3, 2, 1, bias=False)
rel_depth = 0
self.layer1 = self._make_layer(block, 64, layers[0], rel_depth, 1,
self.preactivation, self.stochastic,
self.personalized)
rel_depth += layers[0]
self.layer2 = self._make_layer(block, 128, layers[1], rel_depth, 2,
self.preactivation, self.stochastic,
self.personalized)
rel_depth += layers[1]
self.layer3 = self._make_layer(block, 256, layers[2], rel_depth, 2,
self.preactivation, self.stochastic,
self.personalized)
rel_depth += layers[2]
self.layer4 = self._make_layer(block, 512, layers[3], rel_depth, 2,
self.preactivation, self.stochastic,
self.personalized)
self.avgpool = nn.AvgPool2d(7)
self.fc = nn.Linear(512 * block.expansion, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, inplace=True):
super(HSwish, self).__init__()
self.inplace = inplace
self.relu = nn.ReLU6(inplace=self.inplace)
def __init__(self,
inplanes,
planes,
baseWidth,
cardinality,
stride=1,
downsample=None,
drop_rate=0,
preactivation=True,
stochastic=True,
personalized=True,
activ_fun='relu'):
""" Constructor
Args:
inplanes: input channel dimensionality
planes: output channel dimensionality
baseWidth: base width.
cardinality: num of convolution groups.
stride: conv stride. Replaces pooling layer.
"""
super(Bottleneck, self).__init__()
D = int(math.floor(planes * (baseWidth / 64)))
C = cardinality
self.conv1 = nn.Conv2d(inplanes,
D * C,
kernel_size=1,
stride=1,
padding=0,
bias=False)
self.bn1 = nn.BatchNorm2d(D * C)
self.bn1p = nn.BatchNorm2d(inplanes)
self.conv2a = nn.Conv2d(D * C,
D * C // 2,
kernel_size=3,
stride=stride,
padding=1,
groups=C,
bias=False)
self.conv2b = nn.Sequential(
nn.Conv2d(D * C,
D * C,
kernel_size=3,
stride=1,
padding=1,
groups=C,
bias=False),
nn.Conv2d(D * C,
D * C // 2,
kernel_size=3,
stride=stride,
padding=1,
groups=C,
bias=False))
self.conv2c = nn.Conv2d(D * C,
D * C,
kernel_size=3,
stride=stride,
padding=1,
groups=C,
bias=False)
self.bn2 = nn.BatchNorm2d(D * C)
self.bn2p = nn.BatchNorm2d(D * C)
self.conv3 = nn.Conv2d(D * C,
planes * 4,
kernel_size=1,
stride=1,
padding=0,
bias=False)
self.bn3p = nn.BatchNorm2d(D * C)
self.bn3 = nn.BatchNorm2d(planes * 4)
self.activ_fun = activ_fun
if activ_fun == 'relu':
self.relu = nn.ReLU(inplace=True)
else:
self.relu = nn.ReLU6(inplace=True)
self.stocdepth = nn.Dropout(p=drop_rate)
self.activ_fun = activ_fun
self.downsample = downsample
self.preactivation = preactivation
self.stochastic = stochastic
self.personalized = personalized
def conv_3x3_bn(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6(inplace=True)
)
def __init__(self):
super().__init__()
self.relu6 = nn.ReLU6()
self.activations = nn.ModuleDict([
['lrelu', nn.LeakyReLU()],
['prelu', nn.PReLU()]
])
def forward(self, x, choice, act):
x = self.choices[choice](x)
x = self.activations[act](x)
return x
"""
_activations = nn.ModuleDict([
["lrelu", nn.LeakyReLU()],
["prelu", nn.PReLU()],
["relu", nn.ReLU(inplace=True)],
["relu6", nn.ReLU6(inplace=True)],
["hswish", activations.h_swish()],
["hsigmoid", activations.h_sigmoid()],
])
class BatchNorm2d(nn.Module):
def __init__(self, D, momentum=0.01):
super(BatchNorm2d, self).__init__()
slef.D = D
self.momentun = momentun
self.batch_norm = nn.BatchNorm2d(self.D, momentun=self.momentun)
def forward(self, x):
return self.batch_norm(x)
def h_sigmoid_fn(x, inplace=True):
relu = nn.ReLU6(inplace=inplace)
return relu(x + 3) / 6
