def SENet154(pretrained, num_classes):
if pretrained:
model = senet154(pretrained='imagenet')
else:
model = senet154()
model.avg_pool = nn.AdaptiveAvgPool2d(1)
model.last_linear = nn.Linear(2048, num_classes, bias=True)
return model
def __init__(self,
num_classes=1,
num_filters=32,
pretrained=True,
is_deconv=False):
super().__init__()
self.num_classes = num_classes
self.pool = nn.MaxPool2d(2, 2)
if pretrained:
self.encoder = senet154(num_classes=1000, pretrained='imagenet')
else:
self.encoder = senet154(num_classes=1000, pretrained=None)
self.conv1 = self.encoder.layer0
self.conv2 = self.encoder.layer1
self.conv3 = self.encoder.layer2
self.conv4 = self.encoder.layer3
self.conv5 = self.encoder.layer4
self.center = DecoderBlock(2048,
num_filters * 8,
num_filters * 8,
is_deconv=is_deconv)
self.dec5 = DecoderBlock(2048 + num_filters * 8,
num_filters * 8,
num_filters * 8,
is_deconv=is_deconv)
self.dec4 = DecoderBlock(1024 + num_filters * 8,
num_filters * 8,
num_filters * 8,
is_deconv=is_deconv)
self.dec3 = DecoderBlock(512 + num_filters * 8,
num_filters * 2,
num_filters * 2,
is_deconv=is_deconv)
self.dec2 = DecoderBlock(256 + num_filters * 2,
num_filters * 2,
num_filters,
is_deconv=is_deconv)
self.dec1 = DecoderBlock(128 + num_filters,
num_filters,
num_filters,
is_deconv=is_deconv)
self.dec0 = ConvRelu(num_filters, num_filters)
self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def load(info, Continue=False):
models = [None, None, None, None, None]
for i in range(5):
models[i] = pretrainedmodels.senet154(num_classes=1000,
pretrained='imagenet')
# Modify.
num_fcin = models[i].last_linear.in_features
models[i].last_linear = nn.Linear(num_fcin, len(info['classes']))
# print (model)
if Continue:
models = globalconfig.loadmodels(models)
else:
for i in range(5):
models[i].step = 0
models[i].epochs = 0
params = []
for i in range(5):
models[i] = models[i].to(device=os.environ['device'])
params_to_update = []
for name, param in models[i].named_parameters():
if param.requires_grad == True:
params_to_update.append(param)
params.append(params_to_update)
modelinfo = {'inputsize': (224, 224)}
return (models, params, modelinfo)
def __init__(self, num_classes):
super(SENet_154, self).__init__()
self.name = "SENET_154"
self.model = model_zoo.senet154()
self.fc = nn.Linear(2048, num_classes)
nn.init.xavier_uniform(self.fc.weight, gain=2)
def set_model (model_name, num_class, neurons_reducer_block=0, comb_method=None, comb_config=None, pretrained=True,
freeze_conv=False, p_dropout=0.5):
if pretrained:
pre_ptm = 'imagenet'
pre_torch = True
else:
pre_torch = False
pre_ptm = None
if model_name not in _MODELS:
raise Exception("The model {} is not available!".format(model_name))
model = None
if model_name == 'resnet-50':
model = MyResnet(models.resnet50(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'resnet-101':
model = MyResnet(models.resnet101(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'densenet-121':
model = MyDensenet(models.densenet121(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'vgg-13':
model = MyVGGNet(models.vgg13_bn(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'vgg-16':
model = MyVGGNet(models.vgg16_bn(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'vgg-19':
model = MyVGGNet(models.vgg19_bn(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'mobilenet':
model = MyMobilenet(models.mobilenet_v2(pretrained=pre_torch), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'efficientnet-b4':
if pretrained:
model = MyEffnet(EfficientNet.from_pretrained(model_name), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
else:
model = MyEffnet(EfficientNet.from_name(model_name), num_class, neurons_reducer_block, freeze_conv,
comb_method=comb_method, comb_config=comb_config)
elif model_name == 'inceptionv4':
model = MyInceptionV4(ptm.inceptionv4(num_classes=1000, pretrained=pre_ptm), num_class, neurons_reducer_block,
freeze_conv, comb_method=comb_method, comb_config=comb_config)
elif model_name == 'senet':
model = MySenet(ptm.senet154(num_classes=1000, pretrained=pre_ptm), num_class, neurons_reducer_block,
freeze_conv, comb_method=comb_method, comb_config=comb_config)
return model
def build_model(model_name):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# load pretrained model
model_name = model_name # could be fbresnet152 or inceptionresnetv2
if (model_name == 'senet154'):
model = pretrainedmodels.senet154(pretrained='imagenet')
elif (model_name == 'se_resnet152'):
model = pretrainedmodels.se_resnet152(pretrained='imagenet')
elif (model_name == 'se_resnext101_32x4d'):
model = pretrainedmodels.se_resnext101_32x4d(pretrained='imagenet')
elif (model_name == 'resnet152'):
model = pretrainedmodels.resnet152(pretrained='imagenet')
elif (model_name == 'resnet101'):
model = pretrainedmodels.resnet101(pretrained='imagenet')
elif (model_name == 'densenet201'):
model = pretrainedmodels.densenet201(pretrained='imagenet')
model.to(device)
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.last_linear.in_features
class CustomModel(nn.Module):
def __init__(self, model):
super(CustomModel, self).__init__()
self.features = nn.Sequential(*list(model.children())[:-1])
self.classifier = nn.Sequential(
torch.nn.Linear(num_ftrs, 128),
torch.nn.Dropout(0.3), # drop 50% of the neuron
torch.nn.Linear(128, 7))
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
model = CustomModel(model)
freeze_layer(model.features)
num_ftrs = list(model.classifier.children())[-1].out_features
model.to(device)
model.name = model_name
PATH = os.path.abspath(os.path.dirname(__file__))
PATH_par = os.path.abspath(os.path.join(PATH, os.pardir))
path_to_model = os.path.join(PATH_par, 'pretrained_model', '128_7')
model.load_state_dict(
torch.load(os.path.join(path_to_model, '%s.pth' % (model_name))))
model.to(device)
for param in model.parameters():
param.requires_grad = False
return model, num_ftrs
def __init__(self,
num_classes,
pretrained="senet154-c7b49a05.pth",
dropout=False,
arcface=False):
super().__init__()
self.net = senet154(pretrained=pretrained)
self.net.last_linear = nn.Linear(2048, num_classes)
def __init__(self,
num_classes,
pretrained="senet154-c7b49a05.pth",
dropout=False,
arcface=False):
super().__init__()
self.net = senet154(pretrained=pretrained)
self.net.avg_pool = AdaptiveConcatPool2d()
self.net.last_linear = nn.Sequential(Flatten(), SEBlock(2048 * 2),
nn.Linear(2048 * 2, num_classes))
def __init__(self, num_classs=100):
super(Modified_SENet154, self).__init__()
model = pretrainedmodels.senet154(num_classes=1000, pretrained='imagenet')
self.num_classs = num_classs
temp = []
for i, m in enumerate(model.children()):
if i <= 6:
temp.append(m)
else:
self.classifier = nn.Linear(in_features=2048, out_features=num_classs)
self.features = nn.Sequential(*temp)
def nets(model, num_class):
if model == 'inceptionv4':
model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'senet154':
model = ptm.senet154(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'pnasnet':
model = ptm.pnasnet5large(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'xception':
model = ptm.xception(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'incepresv2':
model = ptm.inceptionresnetv2(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'resnet152':
model = models.resnet152(pretrained=True)
model.fc = nn.Linear(2048, num_class)
return model
if model == 'se_resxt101':
model = ptm.se_resnext101_32x4d(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'nasnet':
model = ptm.nasnetalarge(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, num_class)
return model
if model == 'dpn': # 224 input size
model = ptm.dpn107(num_classes=1000, pretrained='imagenet+5k')
model.last_linear = nn.Conv2d(model.last_linear.in_channels, num_class,
kernel_size=1, bias=True)
return model
if model == 'resnext101':# 320 input size
model = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl')
model.fc = nn.Linear(2048, num_class)
return model
def get_base_model(config):
model_name = config.backbone
pretrained = config.pretrained
if pretrained is not None and pretrained != 'imagenet':
weights_path = pretrained
pretrained = None
else:
weights_path = None
if config.multibranch:
input_channels = config.multibranch_input_channels
else:
input_channels = config.num_slices
if hasattr(config, 'append_masks') and config.append_masks:
input_channels *= 2
_available_models = ['senet154', 'se_resnext50', 'resnet34', 'resnet18']
if model_name == 'senet154':
cut_point = -3
model = nn.Sequential(
*list(pretrainedmodels.senet154(
pretrained=pretrained).children())[:cut_point])
num_features = 2048
elif model_name == 'se_resnext50':
cut_point = -2
model = nn.Sequential(*list(
pretrainedmodels.se_resnext50_32x4d(
pretrained=pretrained).children())[:cut_point])
num_features = 2048
elif model_name == 'resnet34':
cut_point = -2
model = nn.Sequential(
*list(pretrainedmodels.resnet34(
pretrained=pretrained).children())[:cut_point])
num_features = 512
elif model_name == 'resnet18':
cut_point = -2
model = nn.Sequential(
*list(pretrainedmodels.resnet18(
pretrained=pretrained).children())[:cut_point])
num_features = 512
else:
raise ValueError('Unavailable backbone, choose one from {}'.format(
_available_models))
if model_name in ['senet154', 'se_resnext50']:
conv1 = model[0].conv1
else:
conv1 = model[0]
if input_channels != 3:
conv1_weights = deepcopy(conv1.weight)
new_conv1 = nn.Conv2d(input_channels,
conv1.out_channels,
kernel_size=conv1.kernel_size,
stride=conv1.stride,
padding=conv1.padding,
bias=conv1.bias)
if weights_path is None:
if input_channels == 1:
new_conv1.weight.data.fill_(0.)
new_conv1.weight[:, 0, :, :].data.copy_(conv1_weights[:,
0, :, :])
elif input_channels > 3:
diff = (input_channels - 3) // 2
new_conv1.weight.data.fill_(0.)
new_conv1.weight[:,
diff:diff + 3, :, :].data.copy_(conv1_weights)
if model_name in ['senet154', 'se_resnext50']:
model[0].conv1 = new_conv1
else:
model[0] = new_conv1
if weights_path is not None:
if model_name in ['senet154', 'se_resnext50']:
conv1_str = '0.conv1.weight'
else:
conv1_str = '0.weight'
weights = load_base_weights(weights_path, input_channels, conv1_str)
model.load_state_dict(weights)
return model, num_features
def __init__(self,
in_channels,
out_channels,
num_classes,
model='seresnext50',
pretrained=False,
dropout=0,
scale=64):
super().__init__()
assert model in ['seresnext50', 'seresnext101', 'senet154']
pretrained_dataset = 'imagenet' if pretrained else None
if model == 'seresnext50':
self.model = se_resnext50_32x4d(pretrained=pretrained_dataset)
inplanes = 64
elif model == 'seresnext101':
self.model = se_resnext101_32x4d(pretrained=pretrained_dataset)
inplanes = 64
elif model == 'senet154':
self.model = senet154(pretrained=pretrained_dataset)
self.model.dropout = nn.Identity()
inplanes = 128
else:
assert False
layer0_modules = [('conv1',
nn.Conv2d(in_channels,
64,
3,
stride=2,
padding=1,
bias=False)), ('bn1', nn.BatchNorm2d(64)),
('relu1', nn.ReLU(inplace=True)),
('conv2',
nn.Conv2d(64,
64,
3,
stride=1,
padding=1,
bias=False)), ('bn2', nn.BatchNorm2d(64)),
('relu2', nn.ReLU(inplace=True)),
('conv3',
nn.Conv2d(64,
inplanes,
3,
stride=1,
padding=1,
bias=False)),
('bn3', nn.BatchNorm2d(inplanes)),
('relu3', nn.ReLU(inplace=True)),
('pool', nn.MaxPool2d(3, stride=2, ceil_mode=True))]
self.model.layer0 = nn.Sequential(OrderedDict(layer0_modules))
self.model.avg_pool = nn.Sequential(CatPool2d(), GaussianNoise(),
nn.Flatten())
#self.dist = DistanceLayer(self.model.last_linear.in_features, num_classes, middle_feature=None, scale=64, n_centers=5, dropout=0)
#self.margin = ArcMarginProduct(self.model.last_linear.in_features, num_classes)
self.mos = MoSLayer(2 * self.model.last_linear.in_features,
num_classes,
middle_feature=512,
prior_feature=1024,
scale=64,
n_softmax=10,
dropout=0)
self.model.last_linear = nn.Identity()
replace_relu(self.model)
#self.out_proj = nn.Sequential(nn.Conv2d(self.model.layer4[-1].conv3.out_channels, out_channels, kernel_size=3, padding=1),
# nn.Sigmoid())
self.scale = scale
def build_model(model_name):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# load pretrained model
model_name = model_name # could be fbresnet152 or inceptionresnetv2
if(model_name == 'senet154'):
model = pretrainedmodels.senet154(pretrained='imagenet')
elif(model_name == 'se_resnet152'):
model = pretrainedmodels.se_resnet152(pretrained='imagenet')
elif(model_name == 'se_resnext101_32x4d'):
model = pretrainedmodels.se_resnext101_32x4d(pretrained='imagenet')
elif(model_name == 'resnet152'):
model = pretrainedmodels.resnet152(pretrained='imagenet')
elif(model_name == 'resnet101'):
model = pretrainedmodels.resnet101(pretrained='imagenet')
elif(model_name == 'densenet201'):
model = pretrainedmodels.densenet201(pretrained='imagenet')
model.to(device)
for param in model.parameters():
param.requires_grad = False
num_ftrs = model.last_linear.in_features
class CustomModel(nn.Module):
def __init__(self, model):
super(CustomModel, self).__init__()
self.features = nn.Sequential(*list(model.children())[:-1] )
self.classifier = nn.Sequential(
torch.nn.Linear(num_ftrs, 128),
torch.nn.Dropout(0.3), # drop 50% of the neuron
torch.nn.Linear(128, 7)
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
model = CustomModel(model)
freeze_layer(model.features)
model.to(device)
for param in model.parameters():
param.requires_grad = False
class CustomModel1(nn.Module):
def __init__(self, model):
super(CustomModel1, self).__init__()
self.features = nn.Sequential(*list(model.children())[:-1])
self.classifier = nn.Sequential(
*[list(model.classifier.children())[i] for i in [0]]
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
return x
CustomModel = CustomModel1(model)
num_ftrs = list(CustomModel.classifier.children())[-1].out_features
CustomModel.to(device)
return CustomModel, num_ftrs
args = parser.parse_args()
params = vars(args)
os.makedirs(params["output_dir"], exist_ok=True)
if params['model'] == 'inception_v3':
C, H, W = 3, 299, 299
model = pretrainedmodels.inceptionv3(pretrained='imagenet')
load_image_fn = utils.LoadTransformImage(model)
elif params['model'] == 'resnet152':
C, H, W = 3, 224, 224
model = pretrainedmodels.resnet152(pretrained='imagenet')
load_image_fn = utils.LoadTransformImage(model)
elif params['model'] == 'senet154':
C, H, W = 3, 224, 224
model = pretrainedmodels.senet154(pretrained='imagenet')
load_image_fn = utils.LoadTransformImage(model)
elif params['model'] == 'inception_v4':
C, H, W = 3, 299, 299
model = pretrainedmodels.inceptionv4(num_classes=1000,
pretrained='imagenet')
load_image_fn = utils.LoadTransformImage(model)
else:
print("doesn't support %s" % (params['model']))
model.last_linear = utils.Identity()
model = nn.DataParallel(model)
model = model.cuda()
def main(train_root, train_csv, train_split, val_root, val_csv, val_split,
epochs, aug, model_name, batch_size, num_workers, val_samples,
early_stopping_patience, n_classes, weighted_loss, balanced_loader,
_run):
assert (model_name
in ('inceptionv4', 'resnet152', 'densenet161', 'senet154'))
AUGMENTED_IMAGES_DIR = os.path.join(fs_observer.dir, 'images')
CHECKPOINTS_DIR = os.path.join(fs_observer.dir, 'checkpoints')
BEST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_best.pth')
LAST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_last.pth')
for directory in (AUGMENTED_IMAGES_DIR, CHECKPOINTS_DIR):
os.makedirs(directory)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if model_name == 'inceptionv4':
model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, n_classes)
aug['size'] = 299
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'resnet152':
model = models.resnet152(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, n_classes)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'densenet161':
model = models.densenet161(pretrained=True)
model.classifier = nn.Linear(model.classifier.in_features, n_classes)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'senet154':
model = ptm.senet154(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, n_classes)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
model.to(device)
augs = Augmentations(**aug)
model.aug_params = aug
train_ds = CSVDatasetWithName(train_root,
train_csv,
'image',
'label',
transform=augs.tf_transform,
add_extension='.jpg',
split=train_split)
val_ds = CSVDatasetWithName(val_root,
val_csv,
'image',
'label',
transform=augs.tf_transform,
add_extension='.jpg',
split=val_split)
datasets = {'train': train_ds, 'val': val_ds}
if balanced_loader:
data_sampler = sampler.WeightedRandomSampler(train_ds.sampler_weights,
len(train_ds))
shuffle = False
else:
data_sampler = None
shuffle = True
dataloaders = {
'train':
DataLoader(datasets['train'],
batch_size=batch_size,
shuffle=shuffle,
num_workers=num_workers,
sampler=data_sampler,
worker_init_fn=set_seeds),
'val':
DataLoader(datasets['val'],
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
worker_init_fn=set_seeds),
}
if weighted_loss:
criterion = nn.CrossEntropyLoss(
weight=torch.Tensor(datasets['train'].class_weights_list).cuda())
else:
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.001)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
factor=0.1,
min_lr=1e-5,
patience=10)
metrics = {
'train': pd.DataFrame(columns=['epoch', 'loss', 'acc']),
'val': pd.DataFrame(columns=['epoch', 'loss', 'acc'])
}
best_val_loss = 1000.0
epochs_without_improvement = 0
batches_per_epoch = None
for epoch in range(epochs):
print('train epoch {}/{}'.format(epoch + 1, epochs))
epoch_train_result = train_epoch(device, model, dataloaders, criterion,
optimizer, 'train', batches_per_epoch)
metrics['train'] = metrics['train'].append(
{
**epoch_train_result, 'epoch': epoch
}, ignore_index=True)
print('train', epoch_train_result)
epoch_val_result = train_epoch(device, model, dataloaders, criterion,
optimizer, 'val', batches_per_epoch)
metrics['val'] = metrics['val'].append(
{
**epoch_val_result, 'epoch': epoch
}, ignore_index=True)
print('val', epoch_val_result)
scheduler.step(epoch_val_result['loss'])
if epoch_val_result['loss'] < best_val_loss:
best_val_loss = epoch_val_result['loss']
epochs_without_improvement = 0
torch.save(model, BEST_MODEL_PATH)
print('Best loss at epoch {}'.format(epoch))
else:
epochs_without_improvement += 1
print('-' * 40)
if epochs_without_improvement > early_stopping_patience:
torch.save(model, LAST_MODEL_PATH)
break
if epoch == (epochs - 1):
torch.save(model, LAST_MODEL_PATH)
for phase in ['train', 'val']:
metrics[phase].epoch = metrics[phase].epoch.astype(int)
metrics[phase].to_csv(os.path.join(fs_observer.dir, phase + '.csv'),
index=False)
print('Best validation loss: {}'.format(best_val_loss))
# TODO: return more metrics
return {'max_val_acc': metrics['val']['acc'].max()}
def main(train_root, train_csv, val_root, val_csv, test_root, test_csv, epochs,
aug, model_name, batch_size, num_workers, val_samples, test_samples,
early_stopping_patience, limit_data, images_per_epoch, _run):
assert (model_name
in ('inceptionv4', 'resnet152', 'densenet161', 'senet154'))
AUGMENTED_IMAGES_DIR = os.path.join(fs_observer.dir, 'images')
CHECKPOINTS_DIR = os.path.join(fs_observer.dir, 'checkpoints')
BEST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_best.pth')
LAST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_last.pth')
RESULTS_CSV_PATH = os.path.join('results', 'results.csv')
EXP_NAME = _run.meta_info['options']['--name']
EXP_ID = _run._id
for directory in (AUGMENTED_IMAGES_DIR, CHECKPOINTS_DIR):
os.makedirs(directory)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if model_name == 'inceptionv4':
model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = 299
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'resnet152':
model = models.resnet152(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, 2)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'densenet161':
model = models.densenet161(pretrained=True)
model.classifier = nn.Linear(model.classifier.in_features, 2)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'senet154':
model = ptm.senet154(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
model.to(device)
augs = Augmentations(**aug)
model.aug_params = aug
datasets = {
'samples':
CSVDataset(train_root,
train_csv,
'image_id',
'melanoma',
transform=augs.tf_augment,
add_extension='.jpg',
limit=(400, 433)),
'train':
CSVDataset(train_root,
train_csv,
'image_id',
'melanoma',
transform=augs.tf_transform,
add_extension='.jpg',
random_subset_size=limit_data),
'val':
CSVDatasetWithName(val_root,
val_csv,
'image_id',
'melanoma',
transform=augs.tf_transform,
add_extension='.jpg'),
'test':
CSVDatasetWithName(test_root,
test_csv,
'image_id',
'melanoma',
transform=augs.tf_transform,
add_extension='.jpg'),
'test_no_aug':
CSVDatasetWithName(test_root,
test_csv,
'image_id',
'melanoma',
transform=augs.no_augmentation,
add_extension='.jpg'),
'test_144':
CSVDatasetWithName(test_root,
test_csv,
'image_id',
'melanoma',
transform=augs.inception_crop,
add_extension='.jpg'),
}
dataloaders = {
'train':
DataLoader(datasets['train'],
batch_size=batch_size,
shuffle=True,
num_workers=num_workers,
worker_init_fn=set_seeds),
'samples':
DataLoader(datasets['samples'],
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
worker_init_fn=set_seeds),
}
save_images(datasets['samples'], to=AUGMENTED_IMAGES_DIR, n=32)
sample_batch, _ = next(iter(dataloaders['samples']))
save_image(make_grid(sample_batch, padding=0),
os.path.join(AUGMENTED_IMAGES_DIR, 'grid.jpg'))
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.001)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[10],
gamma=0.1)
metrics = {
'train': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']),
'val': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc'])
}
best_val_auc = 0.0
best_epoch = 0
epochs_without_improvement = 0
if images_per_epoch:
batches_per_epoch = images_per_epoch // batch_size
else:
batches_per_epoch = None
for epoch in range(epochs):
print('train epoch {}/{}'.format(epoch + 1, epochs))
epoch_train_result = train_epoch(device, model, dataloaders, criterion,
optimizer, batches_per_epoch)
metrics['train'] = metrics['train'].append(
{
**epoch_train_result, 'epoch': epoch
}, ignore_index=True)
print('train', epoch_train_result)
epoch_val_result, _ = test_with_augmentation(model, datasets['val'],
device, num_workers,
val_samples)
metrics['val'] = metrics['val'].append(
{
**epoch_val_result, 'epoch': epoch
}, ignore_index=True)
print('val', epoch_val_result)
print('-' * 40)
scheduler.step()
if epoch_val_result['auc'] > best_val_auc:
best_val_auc = epoch_val_result['auc']
best_epoch = epoch
epochs_without_improvement = 0
torch.save(model, BEST_MODEL_PATH)
else:
epochs_without_improvement += 1
if epochs_without_improvement > early_stopping_patience:
torch.save(model, LAST_MODEL_PATH)
break
if epoch == (epochs - 1):
torch.save(model, LAST_MODEL_PATH)
for phase in ['train', 'val']:
metrics[phase].epoch = metrics[phase].epoch.astype(int)
metrics[phase].to_csv(os.path.join(fs_observer.dir, phase + '.csv'),
index=False)
# Run testing
test_result, _ = test_with_augmentation(torch.load(BEST_MODEL_PATH),
datasets['test'], device,
num_workers, test_samples)
print('test', test_result)
test_noaug_result, _ = test_with_augmentation(torch.load(BEST_MODEL_PATH),
datasets['test_no_aug'],
device, num_workers, 1)
print('test (no augmentation)', test_noaug_result)
test_144crop_result, _ = test_with_augmentation(
torch.load(BEST_MODEL_PATH), datasets['test_144'], device, num_workers,
1)
print('test (144-crop)', test_144crop_result)
with open(RESULTS_CSV_PATH, 'a') as file:
file.write(','.join((EXP_NAME, str(EXP_ID), str(best_epoch),
str(best_val_auc), str(test_noaug_result['auc']),
str(test_result['auc']),
str(test_144crop_result['auc']))) + '\n')
return (test_noaug_result['auc'], test_result['auc'],
test_144crop_result['auc'])
def get_senet154_pretrained_model(num_classes):
pretrained_senet154 = senet154()
pretrained_senet154.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
pretrained_senet154.last_linear = nn.Linear(2048, num_classes)
return pretrained_senet154
def senet154(num_classes=1000,pretrained=None):
model = pretrainedmodels.senet154(num_classes=num_classes,pretrained=pretrained)
return model
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 0
if model_name == "se_resnext50_32x4d":
model_ft = pretrainedmodels.se_resnext50_32x4d(num_classes=1000,
pretrained='imagenet')
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.last_linear.in_features
# print('model_ft.last_linear.in_features: ', num_ftrs)
model_ft.last_linear = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "se_resnext101_32x4d":
model_ft = pretrainedmodels.se_resnext101_32x4d(num_classes=1000,
pretrained='imagenet')
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.last_linear.in_features
model_ft.last_linear = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "PolyNet":
model_ft = pretrainedmodels.polynet(num_classes=1000,
pretrained='imagenet')
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.last_linear.in_features
model_ft.last_linear = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "SENet154":
model_ft = pretrainedmodels.senet154(num_classes=1000,
pretrained='imagenet')
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.last_linear.in_features
model_ft.last_linear = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet-18":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet-50":
""" Resnet50
"""
model_ft = models.resnet50(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
# model_ft.fc = nn.Linear(num_ftrs, num_classes)
model_ft.fc = nn.Sequential(nn.Dropout(p=0.4),
nn.Linear(num_ftrs, num_classes))
input_size = 224
elif model_name == "resnet-152":
""" Resnet152
"""
model_ft = models.resnet152(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "vgg":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "squeezenet":
""" Squeezenet
"""
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
model_ft.classifier[1] = nn.Conv2d(512,
num_classes,
kernel_size=(1, 1),
stride=(1, 1))
model_ft.num_classes = num_classes
input_size = 224
elif model_name == "densenet":
""" Densenet
"""
model_ft = models.densenet121(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# Handle the auxilary net
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
# Handle the primary net
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def main(args):
print(torch.cuda.device_count(), 'gpus available')
# 0. Initializing training
if args.fold is not None:
if args.fold_prefix is None:
print('Please add fold-prefix to arguments')
return
folder_name = f'{args.name}_{args.fold_prefix // 10}{args.fold_prefix % 10}_fold{args.fold}'
checkpoint_path = os.path.join(args.data, 'checkpoints', folder_name)
log_path = os.path.join(args.data, 'logs', folder_name)
if not os.path.exists(checkpoint_path):
os.mkdir(checkpoint_path)
else:
for i in range(100):
folder_name = f'{args.name}_{i // 10}{i % 10}'
checkpoint_path = os.path.join(args.data, 'checkpoints', folder_name)
log_path = os.path.join(args.data, 'logs', folder_name)
if not os.path.exists(checkpoint_path):
os.mkdir(checkpoint_path)
break
if args.checkpoint is None:
training_state = {
'best_checkpoints': [],
'best_scores': [],
'epoch': []
}
else:
# loading checkpoint
from_checkpoint = f'{args.name}_{args.checkpoint // 10}{args.checkpoint % 10}'
parent_checkpoint_path = os.path.join(args.data, 'checkpoints', from_checkpoint)
training_state = torch.load(os.path.join(parent_checkpoint_path, 'training_state.pth'))
training_state['from_checkpoint'] = from_checkpoint
print(f'Using checkpoint {from_checkpoint}')
print(f'Results can be found in {folder_name}')
writer = SummaryWriter(log_dir=log_path)
# 1. prepare data & models
if args.name == 'senet154':
crop_size = 224
else:
crop_size = CROP_SIZE
train_transforms = transforms.Compose([
# HorizontalFlip(p=0.5),
ScaleMinSideToSize((crop_size, crop_size)),
CropCenter(crop_size),
TransformByKeys(transforms.ToPILImage(), ('image',)),
TransformByKeys(transforms.ToTensor(), ('image',)),
TransformByKeys(transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ('image',)),
])
test_transforms = transforms.Compose([
ScaleMinSideToSize((crop_size, crop_size)),
CropCenter(crop_size),
TransformByKeys(transforms.ToPILImage(), ('image',)),
TransformByKeys(transforms.ToTensor(), ('image',)),
TransformByKeys(transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ('image',)),
])
albu_transforms = albu.Compose([
albu.Blur(p=0.1),
albu.MultiplicativeNoise(p=0.1, per_channel=True),
albu.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=20, val_shift_limit=20, p=0.2),
albu.ChannelShuffle(p=0.2)
],
keypoint_params=albu.KeypointParams(format='xy'))
print('\nTransforms:')
print(albu_transforms)
print(train_transforms)
print('\nReading data...')
datasets = torch.load(os.path.join(args.data, 'datasets.pth'))
for d in datasets:
datasets[d].transforms = train_transforms
if args.fold is None:
print('Using predefined data split')
train_dataset = datasets['train_dataset']
val_dataset = datasets['val_dataset']
else:
print(f'Using fold {args.fold}')
train_dataset = FoldDatasetDataset(datasets['train_dataset'], datasets['val_dataset'], train_transforms,
albu_transforms, split='train', fold=args.fold, seed=42)
val_dataset = FoldDatasetDataset(datasets['train_dataset'], datasets['val_dataset'], train_transforms,
None, split='val', fold=args.fold, seed=42)
test_dataset = datasets['test_dataset']
test_dataset.transforms = test_transforms
train_dataloader = data.DataLoader(train_dataset, batch_size=args.batch_size, num_workers=32, pin_memory=True,
shuffle=True, drop_last=True)
val_dataloader = data.DataLoader(val_dataset, batch_size=args.batch_size, num_workers=32, pin_memory=True,
shuffle=False, drop_last=False)
print('Creating model...')
device = torch.device('cuda: 0') if args.gpu else torch.device('cpu')
if args.name == 'senet154':
model = pretrainedmodels.senet154(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2 * NUM_PTS, bias=True)
else:
model = models.resnext50_32x4d(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, 2 * NUM_PTS, bias=True)
model = nn.DataParallel(model)
print(f'Using {torch.cuda.device_count()} gpus')
if args.checkpoint is not None:
model.load_state_dict(training_state['best_checkpoints'][0])
model.to(device)
# optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=0.9, nesterov=True)
optimizer = optim.Adam(model.parameters(), lr=args.learning_rate)
# optimizer = RAdam(model.parameters(), lr=args.learning_rate)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5, factor=0.5)
# scheduler = None
print(f'Optimizer: {optimizer}')
print(f'Scheduler: {scheduler}')
loss_fn = fnn.mse_loss
# 2. train & validate
print('Ready for training...')
if args.checkpoint is None:
start_epoch = 0
best_val_loss = np.inf
else:
start_epoch = training_state['epoch'][0]
best_val_loss = training_state['best_scores'][0]
for epoch in range(start_epoch, start_epoch + args.epochs):
train_loss = train(model, train_dataloader, loss_fn, optimizer, device, writer, epoch)
val_loss = validate(model, val_dataloader, loss_fn, device, writer, epoch, scheduler)
print('Epoch #{:2}:\ttrain loss: {:5.2}\tval loss: {:5.2}'.format(epoch, train_loss, val_loss))
print(f'Learning rate = {optimizer.param_groups[0]["lr"]}')
if len(training_state['best_scores']) == 0:
training_state['best_checkpoints'].append(model.state_dict())
training_state['best_scores'].append(val_loss)
training_state['epoch'].append(epoch)
with open(os.path.join(checkpoint_path, 'training_state.pth'), 'wb') as fp:
torch.save(training_state, fp)
elif len(training_state['best_scores']) < 3 or val_loss < training_state['best_scores'][-1]:
cur_val_index = 0
for cur_val_index in range(len(training_state['best_scores'])):
if val_loss < training_state['best_scores'][cur_val_index]:
break
training_state['best_scores'].insert(cur_val_index, val_loss)
training_state['best_checkpoints'].insert(cur_val_index, model.state_dict())
training_state['epoch'].insert(cur_val_index, epoch)
if len(training_state['best_scores']) > 3:
training_state['best_scores'] = training_state['best_scores'][:3]
training_state['best_checkpoints'] = training_state['best_checkpoints'][:3]
training_state['epoch'] = training_state['epoch'][:3]
with open(os.path.join(checkpoint_path, 'training_state.pth'), 'wb') as fp:
torch.save(training_state, fp)
if val_loss < best_val_loss:
best_val_loss = val_loss
with open(os.path.join(checkpoint_path, f'{args.name}_best.pth'), 'wb') as fp:
torch.save(model.state_dict(), fp)
print('Training finished')
print(f'Min val loss = {training_state["best_scores"]} at epoch {training_state["epoch"]}')
print()
# 3. predict
test_dataloader = data.DataLoader(test_dataset, batch_size=args.batch_size, num_workers=16, pin_memory=True,
shuffle=False, drop_last=False)
with open(os.path.join(checkpoint_path, f'{args.name}_best.pth'), 'rb') as fp:
best_state_dict = torch.load(fp, map_location='cpu')
model.load_state_dict(best_state_dict)
test_predictions = predict(model, test_dataloader, device)
with open(os.path.join(checkpoint_path, f'{args.name}_test_predictions.pkl'), 'wb') as fp:
pickle.dump({'image_names': test_dataset.image_names,
'landmarks': test_predictions}, fp)
create_submission(args.data, test_predictions, os.path.join(checkpoint_path, f'{args.name}_submit.csv'))
def main(train_root, train_csv, val_root, val_csv, test_root, test_csv,
epochs, aug, model_name, batch_size, num_workers, val_samples,
test_samples, early_stopping_patience, limit_data, images_per_epoch,
split_id, _run):
assert(model_name in ('inceptionv4', 'resnet152', 'densenet161',
'senet154', 'pnasnet5large', 'nasnetalarge',
'xception', 'squeezenet', 'resnext', 'dpn',
'inceptionresnetv2', 'mobilenetv2'))
cv2.setNumThreads(0)
AUGMENTED_IMAGES_DIR = os.path.join(fs_observer.dir, 'images')
CHECKPOINTS_DIR = os.path.join(fs_observer.dir, 'checkpoints')
BEST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_best.pth')
LAST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_last.pth')
RESULTS_CSV_PATH = os.path.join('results', 'results.csv')
EXP_NAME = _run.meta_info['options']['--name']
EXP_ID = _run._id
for directory in (AUGMENTED_IMAGES_DIR, CHECKPOINTS_DIR):
os.makedirs(directory)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if model_name == 'inceptionv4':
model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = 299
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'resnet152':
model = models.resnet152(pretrained=True)
model.fc = nn.Linear(model.fc.in_features, 2)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'densenet161':
model = models.densenet161(pretrained=True)
model.classifier = nn.Linear(model.classifier.in_features, 2)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
elif model_name == 'senet154':
model = ptm.senet154(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'squeezenet':
model = ptm.squeezenet1_1(num_classes=1000, pretrained='imagenet')
model.last_conv = nn.Conv2d(
512, 2, kernel_size=(1, 1), stride=(1, 1))
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'pnasnet5large':
model = ptm.pnasnet5large(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'nasnetalarge':
model = ptm.nasnetalarge(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'xception':
model = ptm.xception(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'dpn':
model = ptm.dpn131(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Conv2d(model.last_linear.in_channels, 2,
kernel_size=1, bias=True)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'resnext':
model = ptm.resnext101_64x4d(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'inceptionresnetv2':
model = ptm.inceptionresnetv2(num_classes=1000, pretrained='imagenet')
model.last_linear = nn.Linear(model.last_linear.in_features, 2)
aug['size'] = model.input_size[1]
aug['mean'] = model.mean
aug['std'] = model.std
elif model_name == 'mobilenetv2':
model = MobileNetV2()
model.load_state_dict(torch.load('./auglib/models/mobilenet_v2.pth'))
model.classifier = nn.Sequential(
nn.Dropout(0.2),
nn.Linear(model.last_channel, 2),
)
aug['size'] = 224
aug['mean'] = [0.485, 0.456, 0.406]
aug['std'] = [0.229, 0.224, 0.225]
model.to(device)
augs = Augmentations(**aug)
model.aug_params = aug
datasets = {
'samples': CSVDataset(train_root, train_csv, 'image_id', 'melanoma',
transform=augs.tf_augment, add_extension='.jpg',
limit=(400, 433)),
'train': CSVDataset(train_root, train_csv, 'image_id', 'melanoma',
transform=augs.tf_transform, add_extension='.jpg',
random_subset_size=limit_data),
'val': CSVDatasetWithName(
val_root, val_csv, 'image_id', 'melanoma',
transform=augs.tf_transform, add_extension='.jpg'),
'test': CSVDatasetWithName(
test_root, test_csv, 'image_id', 'melanoma',
transform=augs.tf_transform, add_extension='.jpg'),
'test_no_aug': CSVDatasetWithName(
test_root, test_csv, 'image_id', 'melanoma',
transform=augs.no_augmentation, add_extension='.jpg'),
'test_144': CSVDatasetWithName(
test_root, test_csv, 'image_id', 'melanoma',
transform=augs.inception_crop, add_extension='.jpg'),
}
dataloaders = {
'train': DataLoader(datasets['train'], batch_size=batch_size,
shuffle=True, num_workers=num_workers,
worker_init_fn=set_seeds),
'samples': DataLoader(datasets['samples'], batch_size=batch_size,
shuffle=False, num_workers=num_workers,
worker_init_fn=set_seeds),
}
save_images(datasets['samples'], to=AUGMENTED_IMAGES_DIR, n=32)
sample_batch, _ = next(iter(dataloaders['samples']))
save_image(make_grid(sample_batch, padding=0),
os.path.join(AUGMENTED_IMAGES_DIR, 'grid.jpg'))
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=0.001)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.1,
min_lr=1e-5,
patience=8)
metrics = {
'train': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']),
'val': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc'])
}
best_val_auc = 0.0
best_epoch = 0
epochs_without_improvement = 0
if images_per_epoch:
batches_per_epoch = images_per_epoch // batch_size
else:
batches_per_epoch = None
for epoch in range(epochs):
print('train epoch {}/{}'.format(epoch+1, epochs))
epoch_train_result = train_epoch(
device, model, dataloaders, criterion, optimizer,
batches_per_epoch)
metrics['train'] = metrics['train'].append(
{**epoch_train_result, 'epoch': epoch}, ignore_index=True)
print('train', epoch_train_result)
epoch_val_result, _ = test_with_augmentation(
model, datasets['val'], device, num_workers, val_samples)
metrics['val'] = metrics['val'].append(
{**epoch_val_result, 'epoch': epoch}, ignore_index=True)
print('val', epoch_val_result)
print('-' * 40)
scheduler.step(epoch_val_result['loss'])
if epoch_val_result['auc'] > best_val_auc:
best_val_auc = epoch_val_result['auc']
best_val_result = epoch_val_result
best_epoch = epoch
epochs_without_improvement = 0
torch.save(model, BEST_MODEL_PATH)
else:
epochs_without_improvement += 1
if epochs_without_improvement > early_stopping_patience:
last_val_result = epoch_val_result
torch.save(model, LAST_MODEL_PATH)
break
if epoch == (epochs-1):
last_val_result = epoch_val_result
torch.save(model, LAST_MODEL_PATH)
for phase in ['train', 'val']:
metrics[phase].epoch = metrics[phase].epoch.astype(int)
metrics[phase].to_csv(os.path.join(fs_observer.dir, phase + '.csv'),
index=False)
# Run testing
# TODO: reduce code repetition
test_result, preds = test_with_augmentation(
torch.load(BEST_MODEL_PATH), datasets['test'], device,
num_workers, test_samples)
print('[best] test', test_result)
test_noaug_result, preds_noaug = test_with_augmentation(
torch.load(BEST_MODEL_PATH), datasets['test_no_aug'], device,
num_workers, 1)
print('[best] test (no augmentation)', test_noaug_result)
test_result_last, preds_last = test_with_augmentation(
torch.load(LAST_MODEL_PATH), datasets['test'], device,
num_workers, test_samples)
print('[last] test', test_result_last)
test_noaug_result_last, preds_noaug_last = test_with_augmentation(
torch.load(LAST_MODEL_PATH), datasets['test_no_aug'], device,
num_workers, 1)
print('[last] test (no augmentation)', test_noaug_result_last)
# Save predictions
preds.to_csv(os.path.join(fs_observer.dir, 'test-aug-best.csv'),
index=False, columns=['image', 'label', 'score'])
preds_noaug.to_csv(os.path.join(fs_observer.dir, 'test-noaug-best.csv'),
index=False, columns=['image', 'label', 'score'])
preds_last.to_csv(os.path.join(fs_observer.dir, 'test-aug-last.csv'),
index=False, columns=['image', 'label', 'score'])
preds_noaug_last.to_csv(os.path.join(fs_observer.dir, 'test-noaug-last.csv'),
index=False, columns=['image', 'label', 'score'])
# TODO: Avoid repetition.
# use ordereddict, or create a pandas df before saving
with open(RESULTS_CSV_PATH, 'a') as file:
file.write(','.join((
EXP_NAME,
str(EXP_ID),
str(split_id),
str(best_epoch),
str(best_val_result['loss']),
str(best_val_result['acc']),
str(best_val_result['auc']),
str(best_val_result['avp']),
str(best_val_result['sens']),
str(best_val_result['spec']),
str(last_val_result['loss']),
str(last_val_result['acc']),
str(last_val_result['auc']),
str(last_val_result['avp']),
str(last_val_result['sens']),
str(last_val_result['spec']),
str(best_val_auc),
str(test_result['auc']),
str(test_result_last['auc']),
str(test_result['acc']),
str(test_result_last['acc']),
str(test_result['spec']),
str(test_result_last['spec']),
str(test_result['sens']),
str(test_result_last['sens']),
str(test_result['avp']),
str(test_result_last['avp']),
str(test_noaug_result['auc']),
str(test_noaug_result_last['auc']),
str(test_noaug_result['acc']),
str(test_noaug_result_last['acc']),
str(test_noaug_result['spec']),
str(test_noaug_result_last['spec']),
str(test_noaug_result['sens']),
str(test_noaug_result_last['sens']),
str(test_noaug_result['avp']),
str(test_noaug_result_last['avp']),
)) + '\n')
return (test_noaug_result['auc'],
test_result['auc'],
)
