def __init__(self, activation=SILU(), pretrained=True):
super(MobilePredictor, self).__init__()
self.activation = activation
base_model = mobile_net_v2(dimension=DIMENSION, channels = CHANNELS, input_size=IMAGE_SIZE, width_mult=1., pretrained = pretrained)
base_model = nn.Sequential(*list(base_model.children())[:-1])
conv = nn.Conv2d(CHANNELS, 32, kernel_size=3, stride=2, padding=3, bias=False)
weight = torch.FloatTensor(32, CHANNELS, 3, 3)
parameters = list(base_model.parameters())
for i in range(32):
if CHANNELS == 1:
weight[i, :, :, :] = parameters[0].data[i].mean(0)
else:
weight[i, :, :, :] = parameters[0].data[i]
conv.weight.data.copy_(weight)
for m in base_model.modules():
if isinstance(m, InvertedResidual):
m.conv[2] = activation
m.conv[5] = activation
self.features =base_model
self.features[0][0]= conv
self.predictor = nn.Sequential(
Perceptron(1280, 1280),
nn.Dropout(p=0),
activation,
Perceptron( 1280, DIMENSION),
)
def __init__(self,
channels=3,
dimension=35,
activation=nn.ReLU(),
pretrained=True):
super(SqueezeResidualPredictor, self).__init__(channels, dimension,
activation, pretrained)
final_norm_layer = nn.BatchNorm2d(LATENT_DIM)
self.features = nn.Sequential(
nn.Conv2d(LATENT_DIM, LATENT_DIM, kernel_size=1),
final_norm_layer,
activation,
nn.AvgPool2d(kernel_size=12, stride=1),
)
reduce_number = int((LATENT_DIM + dimension) / 2.0)
sub_dimension = reduce_number if reduce_number > dimension else (
reduce_number + dimension)
self.predictor = nn.Sequential(
Perceptron(LATENT_DIM, sub_dimension),
nn.Dropout(p=0),
activation,
Perceptron(sub_dimension, dimension),
)
def __init__(self,
channels=3,
dimension=1,
activation=SILU(),
pretrained=True):
super(MnasPredictor, self).__init__()
self.activation = activation
input_size = IMAGE_SIZE
assert input_size % 32 == 0
input_channel = int(32 * 1.1)
self.last_channel = 1280
self.interverted_residual_setting = [
# t, c, n, s, k
[3, 24, 3, 2, 3],
[3, 40, 3, 2, 5],
[6, 80, 3, 2, 5],
[6, 96, 2, 1, 3],
[6, 192, 4, 2, 5],
[6, 320, 1, 1, 3],
]
# building first two layer
self.features = [
conv_3x3(channels, input_channel, 2, activation),
SepConv_3x3(input_channel, 16, activation)
]
input_channel = 16
# building inverted residual blocks (MBConv)
for t, c, n, s, k in self.interverted_residual_setting:
output_channel = int(c * 1.1)
for i in range(n):
if i == 0:
self.features.append(
InvertedResidual(input_channel, output_channel, s, t,
k, activation))
else:
self.features.append(
InvertedResidual(input_channel, output_channel, 1, t,
k, activation))
input_channel = output_channel
# building last several layers
self.features.append(conv_1x1(input_channel, self.last_channel))
self.features.append(nn.AdaptiveAvgPool2d(1))
# make it nn.Sequential
self.features = nn.Sequential(*self.features)
self._initialize_weights()
self.predictor = nn.Sequential(
activation,
Perceptron(1280, 1280),
activation,
Perceptron(1280, dimension),
)
def __init__(self, activation = SILU(), pretrained = True):
super(ResidualRecognitron, self).__init__()
self.activation = activation
self.inplanes = FEATURES
layers = [2,2,2,2]
block = BasicBlock
base_model = models.resnet18(pretrained=pretrained)
conv = nn.Conv2d(CHANNELS, FEATURES, kernel_size=7, stride=2, padding=3, bias=False)
weight = torch.FloatTensor(FEATURES, CHANNELS, 7, 7)
parameters = list(base_model.parameters())
for i in range(FEATURES):
if CHANNELS == 1:
weight[i, :, :, :] = parameters[0].data[i].mean(0)
else:
weight[i, :, :, :] = parameters[0].data[i]
conv.weight.data.copy_(weight)
self.conv1 = conv
self.bn1 = nn.BatchNorm2d(FEATURES)
self.activation = activation
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0], stride=1, activation = activation)
self.layer2 = self._make_layer(block, 128, layers[1], stride=2, activation = activation)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2, activation = activation)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2, activation = activation)
self.avgpool = nn.AdaptiveAvgPool2d(1)
if pretrained:
self.bn1.weight.data.copy_(base_model.bn1.weight)
self.bn1.bias.data.copy_(base_model.bn1.bias)
self.bn1.affine = (base_model.bn1.affine)
for i in range(layers[0]):
self.layer1[i].configure(base_model.layer1[i])
for i in range(layers[0]):
self.layer2[i].configure(base_model.layer2[i])
for i in range(layers[0]):
self.layer3[i].configure(base_model.layer3[i])
for i in range(layers[0]):
self.layer4[i].configure(base_model.layer4[i])
self.recognitron = nn.Sequential(
Perceptron(LATENT, LATENT),
nn.Dropout(p=0.0),
activation,
Perceptron(LATENT, DIMENSION),
)
def __init__(self, activation=nn.ReLU(), pretrained=True):
super(SqueezeResidualPredictor, self).__init__(activation, pretrained)
final_norm_layer = nn.BatchNorm2d(LATENT_DIM)
self.features = nn.Sequential(
nn.Conv2d(LATENT_DIM, LATENT_DIM, kernel_size=1),
final_norm_layer,
activation,
nn.AdaptiveAvgPool2d(1),
)
reduce_number = int((LATENT_DIM + CHANNELS) / 2.0)
sub_dimension = reduce_number if reduce_number > CHANNELS else (
reduce_number + CHANNELS)
self.predictor = nn.Sequential(
Perceptron(LATENT_DIM, sub_dimension),
nn.Dropout(p=0),
activation,
Perceptron(sub_dimension, CHANNELS),
)