def make_image_feature_extractor(model_name):
if model_name == 'inceptionv4':
net = nn.Sequential(
*[inceptionv4().features[i] for i in range(7)],
nn.Conv2d(384, 128, 1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
)
for module in net.modules():
if isinstance(module, nn.Conv2d) or isinstance(module, nn.MaxPool2d):
kernel_size = module.kernel_size
if isinstance(kernel_size, int):
module.padding = kernel_size // 2
else:
module.padding = tuple([k // 2 for k in kernel_size])
return net
elif model_name in {'resnet18', 'resnet34', 'resnet50'}:
resnet = getattr(torchvision.models, model_name)(pretrained=True)
net = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
)
return net
raise Exception('unsupported image feature extractor model name: ' + model_name)
def __init__(self, pretrained=True):
super(FurnitureInceptionV4_350_FC2, self).__init__()
self.model = inceptionv4(num_classes=1000, pretrained=pretrained)
self.model.avg_pool = AdaptiveAvgPool2d(1)
self.final_classifier = Sequential(
Linear(1000, 512),
ReLU(inplace=True),
Dropout(p=0.5),
Linear(512, 128),
)
for m in self.final_classifier.modules():
if isinstance(m, Linear):
m.weight.data.normal_(0, 0.01)
m.bias.data.zero_()
# create aliases:
self.stem = ModuleList([
self.model.features[0],
self.model.features[1],
self.model.features[2],
])
self.features = ModuleList([
self.model.features[i] for i in range(3, len(self.model.features))
])
self.classifier = self.model.last_linear
def get_inceptionv4_model(gpu):
print("==>Loading InceptionV4 model...")
model = inceptionv4(num_classes=7)
num_layers_freeze = 50
for i, param in enumerate(model.parameters()):
if i > num_layers_freeze:
param.requires_grad = True
else:
param.requires_grad = False
summary(model.cuda(), (3, height, width))
return model, "inception_v4_{}_adam".format(gpu)
def __init__(self, num_classes=128, pretrained=True):
super(FurnitureInceptionV4_350, self).__init__()
self.model = inceptionv4(num_classes=1000, pretrained=pretrained)
self.model.avg_pool = AdaptiveAvgPool2d(1)
self.model.last_linear = Linear(1536, num_classes)
for m in self.model.last_linear.modules():
if isinstance(m, Linear):
m.weight.data.normal_(0, 0.01)
m.bias.data.zero_()
# create aliases:
self.stem = ModuleList([
self.model.features[0],
self.model.features[1],
self.model.features[2],
])
self.features = ModuleList([
self.model.features[i] for i in range(3, len(self.model.features))
])
self.classifier = self.model.last_linear
def get_inception_v4_model():
model = inceptionv4()
model.avg_pool = nn.AvgPool2d(2, count_include_pad=False)
model.last_linear = nn.Linear(1536, 7)
# todo freeze few layers in first
# todo augement data set and use random crop, pair augment
# todo mix the emotional images like image pair
# todo cut the face and add another emotion
# todo add random
# todo new loss function
# todo new optimization
# todo new training proceudres
# todo augment imagea fter every epoch.
## Freezing the first few layers. Here I am freezing the first 7 layers
num_layers_freeze = 15
for name, child in model.named_children():
if name == 'features':
for name, chile in child.named_children():
if int(name) < num_layers_freeze:
for params in chile.parameters():
params.requires_grad = False
return model
dataset = FilesFromCsvDataset("output/unique_filtered_train_dataset.csv")
TRAIN_LOADER = get_data_loader(dataset,
data_transform=TRAIN_TRANSFORMS,
batch_size=BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory='cuda' in DEVICE)
val_dataset = FilesFromCsvDataset("output/unique_filtered_val_dataset.csv")
VAL_LOADER = get_data_loader(val_dataset,
data_transform=VAL_TRANSFORMS,
batch_size=BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory='cuda' in DEVICE)
base_model = inceptionv4(num_classes=1000, pretrained='imagenet')
MODEL = FurnitureModelOnCrops(features=base_model.features,
featuremap_output_size=1536,
n_cls_layers=1024)
N_EPOCHS = 100
OPTIM = Adam(params=[
{
"params": MODEL.base_features.parameters(),
'lr': 0.0001
},
{
"params": MODEL.crop_classifiers.parameters(),
'lr': 0.001
},