def __init__(
self, in_channels:int, out_features:int, pool_output_size:int,
hidden_layer_sizes:Sequence=(512,), activation:nn.Module=nn.ReLU,
normalization=nn.BatchNorm1d, bn_final:bool=False, drop_p=0.5
):
layers = [AdaptiveConcatPool2d(sz=pool_output_size), Flatten()]
for i in range(len(hidden_layer_sizes)):
if i == 0:
in_features = in_channels * 2 * pool_output_size * pool_output_size
else:
in_features = hidden_layer_sizes[i - 1]
layers.append(normalization(num_features=in_features))
if drop_p != 0:
layers.append(nn.Dropout(p=drop_p / 2))
layers.append(nn.Linear(
in_features=in_features,
out_features=hidden_layer_sizes[i]
))
layers.append(activation())
if bn_final:
layers.append(normalization(num_features=hidden_layer_sizes[-1], momentum=0.001)) #follows fast ai
if drop_p != 0:
layers.append(nn.Dropout(p=drop_p))
layers.append(nn.Linear(in_features=hidden_layer_sizes[-1], out_features=out_features))
super(FeedforwardBlock, self).__init__(*layers)
def __init__(self, in_features, NUM_CATEGORIES, NUM_GENERA, NUM_FAMILIES):
super(Head, self).__init__()
self.cat_pool = AdaptiveConcatPool2d()
self.flat = nn.Flatten()
# self.bn1 = nn.BatchNorm1d(
# num_features=2*in_features, eps=1e-05, momentum=0.1,
# affine=True, track_running_stats=True
# )
# self.dp1 = nn.Dropout(p=0.5)
self.linear = nn.Linear(
in_features=2*in_features,
out_features=in_features, bias=True
)
self.relu = nn.ReLU()
# self.bn2 = nn.BatchNorm1d(
# num_features=in_features, eps=1e-05, momentum=0.1,
# affine=True, track_running_stats=True
# )
# self.dp2 = nn.Dropout(p=0.5)
self.categories_layer = nn.Linear(
in_features, NUM_CATEGORIES
)
self.genera_layer = nn.Linear(
in_features, NUM_GENERA
)
self.families_level = nn.Linear(
in_features, NUM_FAMILIES
)
def __init__(self, nc):
super(PoolTileNetList, self).__init__()
# net = torchvision.models.resnext50_32x4d(pretrained = True)
net = torchvision.models.resnet34(pretrained = True)
infeature = net.fc.in_features
self.net1 = torch.nn.Sequential(*list(net.children())[:-2])
self.head = nn.Sequential(AdaptiveConcatPool2d(),Flatten(), nn.Linear(infeature * 2,512), Mish(),nn.BatchNorm1d(512), nn.Dropout(0.5),nn.Linear(512,nc))
def __init__(self, nc, n, ps=0.5):
super().__init__()
layers = [AdaptiveConcatPool2d(), Mish(), Flatten()] + \
bn_drop_lin(nc*2, 512, True, ps, Mish()) + \
bn_drop_lin(512, n, True, ps)
self.fc = nn.Sequential(*layers)
self._init_weight()
def __init__(self, arch='resnext50_32x4d_ssl', n=6, pre=True):
super().__init__()
m = torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', arch)
self.enc = nn.Sequential(*list(m.children())[:-2])
nc = list(m.children())[-1].in_features
self.head = nn.Sequential(AdaptiveConcatPool2d(), Flatten(),nn.Linear(2*nc,512),
Mish(),nn.BatchNorm1d(512), nn.Dropout(0.5),nn.Linear(512,n))
def __init__(self, encode_size, hidden_size, num_layers, bs, output_size):
super().__init__()
self.encode_size = encode_size
self.hidden_size = hidden_size
self.num_layers = num_layers
self.bs = bs
self.output_size = output_size
resnet_model = resnet34(pretrained=True)
encoder_layers = list(resnet_model.children())[:8] + [
AdaptiveConcatPool2d(), Flatten()
]
self.encoder = nn.Sequential(*encoder_layers).cuda()
for param in self.encoder.parameters():
param.requires_grad = False
set_trainable(self.encoder, False) # fastai fit bug
self.encoder_linear = nn.Sequential(nn.BatchNorm1d(1024),
nn.Dropout(p=0.25),
nn.Linear(1024, 512), nn.ReLU(),
nn.BatchNorm1d(512),
nn.Dropout(p=0.5),
nn.Linear(512,
encode_size)).cuda()
set_trainable(self.encoder_linear, True) # fastai fit bug
self.lstm = nn.LSTM(encode_size, hidden_size, num_layers).cuda()
self.h, self.c = self.init_hidden()
set_trainable(self.lstm, True) # fastai fit bug
self.linear = nn.Linear(hidden_size, output_size).cuda()
set_trainable(self.linear, True) # fastai fit bug
self.init_weights()
def __init__(self):
super().__init__()
resnet_model = resnet34(pretrained=True)
encoder_layers = list(resnet_model.children())[:8] + [
AdaptiveConcatPool2d(), Flatten()
]
self.encoder = nn.Sequential(*encoder_layers).cuda()
for param in self.encoder.parameters():
param.requires_grad = False
set_trainable(self.encoder, False) # fastai fit bug
self.linear = nn.Sequential(nn.BatchNorm1d(1024), nn.Dropout(p=0.25),
nn.Linear(1024, 512), nn.ReLU(),
nn.BatchNorm1d(512), nn.Dropout(p=0.5),
nn.Linear(512, 14)).cuda()
apply_init(self.linear, kaiming_normal)
set_trainable(self.linear, True) # fastai fit bug
def __init__(self, nc):
super(MyEfficientNet, self).__init__()
self.net = EfficientNet.from_pretrained('efficientnet-b0')
infeature = self.net._conv_head.out_channels
self.head = nn.Sequential(AdaptiveConcatPool2d(),Flatten(), nn.Linear(infeature * 2,512), Mish(),nn.BatchNorm1d(512), nn.Dropout(0.5),nn.Linear(512,nc),MemoryEfficientSwish())
# Check that the IR is well formed
onnx.checker.check_model(onnx_model)
# Print a human readable representation of the graph
# onnx.helper.printable_graph(onnx_model.graph)
return onnx_model
class ImageScale(nn.Module):
def __init__(self):
super().__init__()
self.denorminator = torch.full((3, 299, 299),
255.0,
device=torch.device("cuda"))
def forward(self, x):
return torch.div(x, self.denorminator).unsqueeze(0)
def make_fastai_be_coreml_compatible(learner):
# Suggestion for using softmax didn't work for me
#final_model = [ImageScale()] + (list(learn.model.children())[:-1] + [nn.Softmax()])
return nn.Sequential(ImageScale(), *learner.model)
if __name__ == "__main__":
foo = AdaptiveConcatPool2d()
monkeypatch_fastai_for_onnx()
bar = AdaptiveConcatPool2d()