def create_nnabla_net(resnext=False):
# Create nnabla graph
from models import senet
x = nn.Variable((1, 3, 224, 224), need_grad=False)
if resnext:
y = senet.se_resnext50(x, 1000, test=True)
else:
y = senet.se_resnet50(x, 1000, test=True)
params = nn.get_parameters(grad_only=False)
param_dims = 0
for k, v in params.items():
param_dims += np.prod(v.shape)
print(k, v.shape, param_dims)
print('total parameters: ', param_dims)
return (x, y), params, param_dims
def __init__(self, type, num_classes):
super().__init__()
if type == "seresnext50":
self.senet = se_resnext50_32x4d(pretrained="imagenet")
# layer0_modules = [
# ('conv1', self.senet.layer0.conv1),
# ('bn1', self.senet.layer0.bn1),
# ('relu1', self.senet.layer0.relu1),
# ]
# self.layer0 = nn.Sequential(OrderedDict(layer0_modules))
self.layer0 = self.senet.layer0
elif type == "seresnext101":
self.senet = se_resnext101_32x4d(pretrained="imagenet")
self.layer0 = self.senet.layer0
elif type == "seresnet50":
self.senet = se_resnet50(pretrained="imagenet")
self.layer0 = self.senet.layer0
elif type == "seresnet101":
self.senet = se_resnet101(pretrained="imagenet")
self.layer0 = self.senet.layer0
elif type == "seresnet152":
self.senet = se_resnet152(pretrained="imagenet")
self.layer0 = self.senet.layer0
elif type == "senet154":
self.senet = senet154(pretrained="imagenet")
self.layer0 = self.senet.layer0
else:
raise Exception("Unsupported senet model type: '{}".format(type))
self.expand_channels = ExpandChannels2d(3)
self.bn = nn.BatchNorm2d(3)
self.avg_pool = nn.AdaptiveAvgPool2d(output_size=1)
self.dropout = nn.Dropout(0.2)
self.last_linear = nn.Linear(2048, num_classes)
def generate_model(opt):
assert opt.model in [
'resnet', 'preresnet', 'wideresnet', 'resnext', 'densenet','senet'
]
if opt.model == 'resnet':
assert opt.model_depth in [10, 18, 34, 50, 101, 152, 200]
from models.resnet import get_fine_tuning_parameters
if opt.model_depth == 10:
model = resnet.resnet10(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 18:
model = resnet.resnet18(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 34:
model = resnet.resnet34(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 50:
model = resnet.resnet50(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 101:
model = resnet.resnet101(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 152:
model = resnet.resnet152(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 200:
model = resnet.resnet200(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model == 'wideresnet':
assert opt.model_depth in [50]
from models.wide_resnet import get_fine_tuning_parameters
if opt.model_depth == 50:
model = wide_resnet.resnet50(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
k=opt.wide_resnet_k,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model == 'resnext':
assert opt.model_depth in [50, 101, 152]
from models.resnext import get_fine_tuning_parameters
if opt.model_depth == 50:
model = resnext.resnet50(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
cardinality=opt.resnext_cardinality,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 101:
model = resnext.resnet101(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
cardinality=opt.resnext_cardinality,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 152:
model = resnext.resnet152(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
cardinality=opt.resnext_cardinality,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model == 'preresnet':
assert opt.model_depth in [18, 34, 50, 101, 152, 200]
from models.pre_act_resnet import get_fine_tuning_parameters
if opt.model_depth == 18:
model = pre_act_resnet.resnet18(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 34:
model = pre_act_resnet.resnet34(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 50:
model = pre_act_resnet.resnet50(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 101:
model = pre_act_resnet.resnet101(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 152:
model = pre_act_resnet.resnet152(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 200:
model = pre_act_resnet.resnet200(
num_classes=opt.n_classes,
shortcut_type=opt.resnet_shortcut,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model == 'densenet':
assert opt.model_depth in [121, 169, 201, 264]
from models.densenet import get_fine_tuning_parameters
if opt.model_depth == 121:
model = densenet.densenet121(
num_classes=opt.n_classes,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 169:
model = densenet.densenet169(
num_classes=opt.n_classes,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 201:
model = densenet.densenet201(
num_classes=opt.n_classes,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model_depth == 264:
model = densenet.densenet264(
num_classes=opt.n_classes,
sample_size=opt.sample_size,
sample_duration=opt.sample_duration)
elif opt.model == 'senet':
assert opt.model_depth in [50,101,152,154,5032,10132]
if opt.model_depth == 50:
model = senet.se_resnet50(num_classes = opt.n_classes, pretrained = None)
elif opt.model_depth == 101:
model = senet.se_resnet101(num_classes = opt.n_classes, pretrained = None)
elif opt.model_depth == 152:
model = senet.se_resnet152(num_classes = opt.n_classes, pretrained = None)
elif opt.model_depth == 154:
model = senet.senet154(num_classes = opt.n_classes, pretrained = None)
elif opt.model_depth == 5032:
model = senet.resnext50_32x4d(num_classes = opt.n_classes, pretrained = None)
elif opt.model_depth == 10132:
model = senet.se_resnext101_32x4d(num_classes = opt.n_classes, pretrained = None)
if not opt.no_cuda:
model = model.cuda()
model = nn.DataParallel(model, device_ids=None)
if opt.pretrain_path:
print('loading pretrained model {}'.format(opt.pretrain_path))
pretrain = torch.load(opt.pretrain_path)
#assert opt.arch == pretrain['arch']
#model.load_state_dict(pretrain['state_dict'])
pretrained_dict = pretrain['state_dict']
model_dict = model.state_dict()
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k.find("module.fc") == -1}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
#model.load_state_dict(model_dict,strict=False)
if opt.model == 'densenet':
model.module.classifier = nn.Linear(
model.module.classifier.in_features, opt.n_finetune_classes)
model.module.classifier = model.module.classifier.cuda()
elif opt.model == "senet":
model.module.last_linear = nn.Linear(model.module.last_linear.in_features, opt.n_finetune_classes)
model.module.last_linear = model.module.last_linear.cuda()
return model, model.parameters()
else:
model.module.fc = nn.Linear(model.module.fc.in_features,
opt.n_finetune_classes)
model.module.fc = model.module.fc.cuda()
parameters = get_fine_tuning_parameters(model, opt.ft_begin_index)
return model, parameters
else:
if opt.pretrain_path:
print('loading pretrained model {}'.format(opt.pretrain_path))
pretrain = torch.load(opt.pretrain_path)
assert opt.arch == pretrain['arch']
model.load_state_dict(pretrain['state_dict'])
if opt.model == 'densenet':
model.classifier = nn.Linear(
model.classifier.in_features, opt.n_finetune_classes)
else:
model.fc = nn.Linear(model.fc.in_features,
opt.n_finetune_classes)
parameters = get_fine_tuning_parameters(model, opt.ft_begin_index)
return model, parameters
return model, model.parameters()
def load_model(model_name='resnet50',resume='Best',start_epoch=0,cn=3,
save_dir='saved_models/',width=32,start=8,cls_number=10,avg_number=1,gpus=[0,1,2,3,4,5,6,7],kfold = 1,model_times=0,train=True):
load_dict = None
#load_dict = True if cn == 3 else None
if model_name == 'resnet50':
model = resnet50(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'resnet101':
model = resnet101(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'resnet152':
model = resnet152(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'densenet161':
model = densenet161(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'xception':
model = xception(num_classes=cls_number,pretrained=load_dict)
model.conv1 = nn.Conv2d(cn, 32, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'inception_v3':
model = inception_v3(num_classes=cls_number,pretrained=load_dict)
model.Conv2d_1a_3x3.conv = nn.Conv2d(cn, 32, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'seinception_v3':
model = se_inception_v3(num_classes=cls_number)
model.model.Conv2d_1a_3x3.conv = nn.Conv2d(cn, 32, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'inception_v4':
model = inceptionv4(num_classes=cls_number,pretrained=load_dict)
model.features[0].conv = nn.Conv2d(cn, 32, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'inceptionresnetv2':
model = inceptionresnetv2(num_classes=cls_number,pretrained=load_dict)
model.conv2d_1a.conv = nn.Conv2d(cn, 32, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'seresnet50':
model = se_resnet50(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'seresnet101':
model = se_resnet101(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'seresnet152':
model = se_resnet152(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'seresnext50':
model = se_resnext50_32x4d(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'seresnext101':
model = se_resnext101_32x4d(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'resnet50-101':
model = SimpleNet()
elif model_name == 'seresnet20':
model = se_resnet20(num_classes=cls_number)
elif model_name == 'seresnet32':
model = se_resnet32(num_classes=cls_number)
elif model_name == 'seresnet18':
model = se_resnet18(num_classes=cls_number)
elif model_name == 'seresnet34':
model = se_resnet34(num_classes=cls_number)
elif model_name == 'senet154':
model = senet154(num_classes=cls_number,pretrained=load_dict)
model.layer0.conv1 = nn.Conv2d(cn, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
elif model_name == 'nasnet':
model = nasnetalarge(num_classes=cls_number,pretrained=load_dict)
model.conv0.conv = nn.Conv2d(cn, 96, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'dpn98':
model = dpn98(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'dpn107':
model = dpn107(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'dpn92':
model = dpn92(num_classes=cls_number,pretrained=load_dict)
elif model_name == 'polynet':
model = polynet(num_classes=cls_number,pretrained=load_dict)
model.stem.conv1[0].conv = nn.Conv2d(cn, 32, kernel_size=(3, 3), stride=(2, 2), bias=False)
elif model_name == 'pnasnet':
model = pnasnet5large(num_classes=cls_number,pretrained=load_dict)
model.conv_0.conv = nn.Conv2d(cn, 96, kernel_size=(3, 3), stride=(2, 2), bias=False)
#print(model)
if '-' not in model_name and load_dict != True:
if model_name in ['dpn98',]:
model.features.conv1_1.conv = nn.Conv2d(cn, 96, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
elif model_name in ['dpn92',]:
model.features.conv1_1.conv = nn.Conv2d(cn, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
elif model_name in ['seresnet20','seresnet32']:
model.conv1 = nn.Conv2d(cn, 16, kernel_size=3, stride=1, padding=1, bias=False)
elif model_name in ['seresnet18','seresnet34']:
model.conv1 = nn.Conv2d(cn, 64, kernel_size=7, stride=2, padding=3, bias=False)
elif 'seresnext' in model_name:
model.layer0.conv1 = nn.Conv2d(cn, 64, kernel_size=7, stride=2, padding=3, bias=False)
elif 'seresnet' in model_name:
model.layer0.conv1 = nn.Conv2d(cn, 64, kernel_size=7, stride=2, padding=3, bias=False)
elif 'resnet' in model_name:
model.conv1 = nn.Conv2d(cn, 64, kernel_size=7, stride=2, padding=3, bias=False)
#model.fc = torch.nn.Linear(model.fc.in_features,cls_number)
elif 'densenet' in model_name:
model.features.conv0 = nn.Conv2d(cn, 96, kernel_size=7, stride=2, padding=3, bias=False)
model.avgpool = torch.nn.AdaptiveAvgPool2d(output_size=1)
else:
pass
#print(model)
load_model = False
#if model_name == 'resnet50':
if load_dict != True and model_name == 'resnet50' and 0:
base_model = resnet50(pretrained=True)
model_dict = model.state_dict()
new_state_dict = OrderedDict()
for k, v in base_model.state_dict().items()[1:-2]:
new_state_dict[k] = v
model_dict.update(new_state_dict)
model.load_state_dict(model_dict)
print 'load imagenet'
load_model = True
model_ = model_name + '_' + \
str(width) + '_' + str(start) + '_' + str(cn)
if kfold > 1:
model_prefix = save_dir + str(model_times) + '_' + model_
else:
model_prefix = save_dir + model_
if resume == 'Best' and avg_number >= 1:
weight_path = glob(model_prefix + '*pth')
cur_index = np.argsort(-np.array([float(cur_p.split('/')[-1].split('[')[-1].split(']')[0]) for cur_p in weight_path]))
new_state_dict = OrderedDict()
if len(weight_path) == 0:
resume = ''
elif avg_number == 1:
resume = weight_path[0]
else:
for cnt,index in zip(range(avg_number),cur_index[:avg_number]):
cur_resume = weight_path[index]
print cur_resume
model.load_state_dict(torch.load(cur_resume))
for k, v in model.state_dict().items():
if cnt == 0:
new_state_dict[k] = v
else:
new_state_dict[k] = new_state_dict[k] + v
if cnt == avg_number - 1:
new_state_dict[k] = new_state_dict[k] / float(avg_number)
model.load_state_dict(new_state_dict)
if train == False:
for index in cur_index[avg_number + 2:]:
cur_resume = weight_path[index]
print('remove resume %s ' %cur_resume)
os.remove(cur_resume)
if resume != '' and avg_number == 1:
start_epoch = int(resume.split('-')[-3])
#print('resuming finetune from %s'%resume)
logging.info('resuming finetune from %s'%resume)
model.load_state_dict(torch.load(resume))
print('start-epoch : ',start_epoch)
cuda_avail = torch.cuda.is_available()
if cuda_avail:
print 'cuda_avail: True'
if len(gpus) > 1:
model = torch.nn.DataParallel(model,device_ids=gpus).cuda()
else:
model = model.cuda()
return model,start_epoch
'ResNet101':
lambda: E_resnet(resnet101(pretrained=True)),
'ResNet152':
lambda: E_resnet(resnet152(pretrained=True)),
'DenseNet121':
lambda: E_densenet(densenet121(pretrained=True)),
'DenseNet161':
lambda: E_densenet(densenet161(pretrained=True)),
'DenseNet169':
lambda: E_densenet(densenet169(pretrained=True)),
'DenseNet201':
lambda: E_densenet(densenet201(pretrained=True)),
'SENet154':
lambda: E_senet(senet154(pretrained="imagenet")),
'SE_ResNet50':
lambda: E_senet(se_resnet50(pretrained="imagenet")),
'SE_ResNet101':
lambda: E_senet(se_resnet101(pretrained="imagenet")),
'SE_ResNet152':
lambda: E_senet(se_resnet152(pretrained="imagenet")),
'SE_ResNext50_32x4d':
lambda: E_senet(se_resnext50_32x4d(pretrained="imagenet")),
'SE_ResNext101_32x4d':
lambda: E_senet(se_resnext101_32x4d(pretrained="imagenet"))
}
def get_models(args):
backbone = args.backbone
if os.getenv('TORCH_MODEL_ZOO') != args.pretrained_dir: