def main():
global args, best_prec1, globaliter_train, globaliter_val
globaliter_train = 0
globaliter_val = 0
args = parser.parse_args()
print(args)
# create model
num_classes = args.num_classes
if args.transfer != "":
num_classes = 365
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
if args.arch.lower() == 'wideresnet50':
model = wideresnet.resnet50(num_classes=num_classes)
if args.arch.lower() == 'wideresnet18':
model = wideresnet.resnet18(num_classes=num_classes)
else:
model = models.__dict__[args.arch](num_classes=num_classes)
print(model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
if args.transfer != "":
if os.path.isfile(args.transfer):
print("=> loading checkpoint '{}'".format(args.transfer))
checkpoint = torch.load(args.transfer, map_location=lambda storage, loc: storage)
state_dict = {str.replace(k,'module.',''): v for k,v in checkpoint['state_dict'].items()}
model.load_state_dict(state_dict)
# print("=> loaded checkpoint '{}' (epoch {})"
# .format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.transfer))
for param in model.parameters():
param.requires_grad = False
if freze == 2:
for param in model.layer4.parameters():
param.requires_grad = True
args.arch.lower() == 'wideresnet50':
model.fc = nn.Linear(2040 , 2)
else:
model.fc = nn.Linear(512 , 2)
model.fc.reset_parameters()
def load_model(model_file):
if args.model == 'resnet18':
model = wideresnet.resnet18(num_classes=365)
if args.model == 'resnet50':
model = wideresnet.resnet50(num_classes=365)
checkpoint = torch.load(model_file,
map_location=lambda storage, loc: storage)
state_dict = {
str.replace(k, 'module.', ''): v
for k, v in checkpoint['state_dict'].items()
}
model.load_state_dict(state_dict)
model.eval()
return model
def load_model(path, model):
model_file = path
if model == 'resnet18':
model = wideresnet.resnet18(num_classes=365)
if model == 'resnet50':
model = wideresnet.resnet50(num_classes=365)
checkpoint = torch.load(model_file,
map_location=lambda storage, loc: storage)
state_dict = {
str.replace(k, 'module.', ''): v
for k, v in checkpoint['state_dict'].items()
}
#model.load_state_dict(checkpoint['state_dict'])
model.load_state_dict(state_dict)
for i, (name, module) in enumerate(model._modules.items()):
module = recursion_change_bn(model)
model.eval()
return model
def main():
global args, best_prec1
args = parser.parse_args()
print(args)
torch.cuda.set_device(ini_device)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
elif args.arch.lower().startswith('se'):
model = SENet.se_resnet(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
print('#parameters:', sum(param.numel() for param in model.parameters()))
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features, device_ids)
model.to(ini_device)
else:
model = torch.nn.DataParallel(model, device_ids).to(ini_device)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
del checkpoint
else:
print("=> no checkpoint found at '{}'".format(args.resume))
return
else:
print(model)
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().to(ini_device)
if args.evaluate:
#validate(val_loader, model, criterion)
trainMidOutputs = getMidOutputs(train_loader, model, 15)
valMidOutputs = getMidOutputs(val_loader, model, 15)
fcModel = SENet.simpleFcNet(365)
fcModel = torch.nn.DataParallel(fcModel, device_ids).cuda()
optimizer = torch.optim.SGD(fcModel.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
num_epochs = 180
print('init train acc')
validate(trainMidOutputs, fcModel, criterion)
print('init val acc')
validate(valMidOutputs, fcModel, criterion)
trainFc(trainMidOutputs, 1e-5, num_epochs, criterion, optimizer,
fcModel, valMidOutputs)
validate(trainMidOutputs, fcModel, criterion)
validate(valMidOutputs, fcModel, criterion)
return
else:
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
print args
# create model
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
print("=> creating model '{}'".format(args.arch))
model = wideresnet.resnet50(num_classes=args.num_classes)
elif args.evaluate:
print("resuming model for validation")
model = models.__dict__[args.arch](num_classes=args.num_classes)
model = torch.nn.DataParallel(model).cuda()
checkpoint = torch.load(args.validation_model)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint of validation'{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
elif args.evaluate:
print(" ")
else:
model = torch.nn.DataParallel(model).cuda()
print model
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
num_ftrs = model.module.fc.in_features
model.module.fc = torch.nn.Linear(num_ftrs, 4)
model.cuda()
print("final layer replaced with 4 neurons")
print model
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = GetDataset(
csv_file=
'/scratch/shubodh/places365/rapyuta4_classes/csv_data_labels/train_all.csv',
root_dir='/scratch/shubodh/places365/rapyuta4_classes/train_all',
transform=transform)
test_dataset = GetDataset(
csv_file=
'/scratch/satyajittourani/data_raputa/raputa_test/raputa_test.csv',
root_dir='/scratch/satyajittourani/data_raputa/raputa_test',
transform=transform)
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
if args.evaluate:
validate(val_loader, model, criterion)
return
optimizer = torch.optim.SGD([
{
"params": model.module.fc.parameters(),
"lr": 1.0
},
],
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
print args
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print model
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(traindir, transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
print(args)
## which model will be used (for WideResnet/AlexNet we need to modify something, else wt just use the name of the model)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
# model = resnet.resnet18(num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print(model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
## Some pytorch optimization tool to make training faster. (Yet, it works well only if all the input data is the same size)
cudnn.benchmark = True
# Data loading code
# data_dir = places_dir + '/places365_standard_home'
data_dir = places_dir # check if that works
## inside the data dir I have 2 folders - train & val
traindir = os.path.join(data_dir, 'train')
valdir = os.path.join(data_dir, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
## DataLoader provides an iterable over the given dataset
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
## define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# # check results with ADAM (plain, no changes)
# optimizer = torch.optim.Adam(model.parameters())
if args.evaluate:
validate(val_loader, model, criterion)
return
accuracies_list = []
for epoch in range(args.start_epoch, args.epochs):
## every 30 epochs the learning rate is divided by 10
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
accuracies_list.append("%.2f" % prec1.tolist())
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
print("The best accuracy obtained during training is = {}".format(
best_prec1))
def main():
global args
global best_prec1, best_epoch1
global best_prec5, best_epoch5
global best_prec1_10crop, best_epoch1_10crop
global best_prec5_10crop, best_epoch5_10crop
args = parser.parse_args()
print args
assert args.batch_size >= 2, 'Error: batch size must be greater than or equal to 2'
assert args.sub_division >= 1, 'Error: sub-division size must be greater than or equal to 2'
assert (args.batch_size % args.sub_division
) == 0, 'Error: batch size must divided by sub-division!'
assert (
args.batch_size / args.sub_division
) >= 2, 'Error: The quotient of the batch size divided by sub-division must be greater than or equal to 2,!'
# create model
print("=> creating model '{}'".format(args.arch))
if args.use_custom_model:
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
else:
model = custom_models.__dict__[args.arch](num_classes=args.num_classes,
pretrained=None)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# print model
if not os.path.isdir(args.save_path):
os.mkdir(args.save_path)
assert os.path.isdir(
args.save_path), 'Error: no save directory! %s' % (args.save_path)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optimizer = torch.optim.Adam(model.parameters(), lr=args.lr,
# weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
best_prec5 = checkpoint['best_prec5']
best_epoch1 = checkpoint['best_epoch1']
best_epoch5 = checkpoint['best_epoch5']
best_prec1_10crop = checkpoint['best_prec1_10crop']
best_prec5_10crop = checkpoint['best_prec5_10crop']
best_epoch1_10crop = checkpoint['best_epoch1_10crop']
best_epoch5_10crop = checkpoint['best_epoch5_10crop']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_data_transforms = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
val_data_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])
val_data_transforms_10crop = transforms.Compose([
transforms.Resize(256),
transforms.TenCrop(224),
transforms.Lambda(lambda crops: torch.stack(
[transforms.ToTensor()(crop) for crop in crops])),
transforms.Lambda(
lambda crops: torch.stack([normalize(crop) for crop in crops])),
])
if args.dataset_format == 'places365':
dataloader = places_dataset
traindir = os.path.join(args.data, 'data_large')
valdir = os.path.join(args.data, 'val_large')
filelist = os.path.join(args.data, 'filelist')
train_data_loader = places_dataset(traindir,
filelist,
train_data_transforms,
train=True)
val_data_loader = places_dataset(valdir,
filelist,
val_data_transforms,
train=False)
if not args.ten_crop_validation:
val_data_loader_10crop = places_dataset(valdir,
filelist,
val_data_transforms_10crop,
train=False)
elif args.dataset_format == 'imagenet':
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
train_data_loader = datasets.ImageFolder(traindir,
train_data_transforms)
val_data_loader = datasets.ImageFolder(valdir, val_data_transforms)
if not args.ten_crop_validation:
val_data_loader_10crop = datasets.ImageFolder(
valdir, val_data_transforms_10crop)
if not args.class_balanced_sampling:
sampler_weights = make_weights_for_balanced_classes(train_data_loader)
train_sampler = torch.utils.data.sampler.WeightedRandomSampler(
sampler_weights, len(sampler_weights))
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_data_loader,
batch_size=args.batch_size //
args.sub_division,
shuffle=(train_sampler is None),
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(val_data_loader,
batch_size=args.batch_size //
(args.sub_division * 2),
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if not args.ten_crop_validation:
val_loader_10crop = torch.utils.data.DataLoader(
val_data_loader_10crop,
batch_size=args.batch_size // (args.sub_division * 2 * 8),
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1, prec5 = validate(val_loader, model, criterion, tencrop=False)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
# best_prec1 = max(prec1, best_prec1)
if prec1 > best_prec1:
best_prec1 = prec1
best_epoch1 = epoch
if prec5 > best_prec5:
best_prec5 = prec5
best_epoch5 = epoch
if not args.class_balanced_sampling:
prec1_10crop, prec5_10crop = validate(val_loader_10crop,
model,
criterion,
tencrop=True)
# remember best prec@1 and save checkpoint
is_best_10crop = prec1_10crop > best_prec1_10crop
# best_prec1 = max(prec1, best_prec1)
if prec1_10crop > best_prec1_10crop:
best_prec1_10crop = prec1_10crop
best_epoch1_10crop = epoch
if prec5_10crop > best_prec5_10crop:
best_prec5_10crop = prec5_10crop
best_epoch5_10crop = epoch
state = {
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'best_prec5': best_prec5,
'best_epoch1': best_epoch1,
'best_epoch5': best_epoch5,
'best_prec1_10crop': best_prec1_10crop,
'best_prec5_10crop': best_prec5_10crop,
'best_epoch1_10crop': best_epoch1_10crop,
'best_epoch5_10crop': best_epoch5_10crop,
'optimizer_dict': optimizer.state_dict(),
}
save_checkpoint(state,
is_best_10crop,
args.arch.lower(),
tencrop=True)
if not args.class_balanced_sampling:
save_checkpoint(state, is_best, args.arch.lower(), tencrop=False)
else:
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'best_prec5': best_prec5,
'best_epoch1': best_epoch1,
'best_epoch5': best_epoch5,
'optimizer_dict': optimizer.state_dict(),
},
is_best,
args.arch.lower(),
tencrop=False)
print('The best test accuracy-top1: %f epoch: %d' %
(best_prec1, best_epoch1))
print('The best test accuracy-top5: %f epoch: %d' %
(best_prec5, best_epoch5))
print('The best test 10crop accuracy-top1: %f epoch: %d' %
(best_prec1_10crop, best_epoch1_10crop))
print('The best test 10crop accuracy-top5: %f epoch: %d' %
(best_prec5_10crop, best_epoch5_10crop))
def main():
global args, best_prec1
args = parser.parse_args()
print args
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
# model = models.__dict__[args.arch](num_classes=args.num_classes)
model = resnet.resnet18(num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print model
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
data_dir = places_dir + '/places365_standard_office'
traindir = os.path.join(data_dir, 'train')
valdir = os.path.join(data_dir, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
class ImageFolderWithPaths(datasets.ImageFolder):
"""Custom dataset that includes image file paths. Extends
torchvision.datasets.ImageFolder
"""
# override the __getitem__ method. this is the method dataloader calls
def __getitem__(self, index):
# this is what ImageFolder normally returns
original_tuple = super(ImageFolderWithPaths,
self).__getitem__(index)
# the image file path
path = self.imgs[index][0]
# make a new tuple that includes original and the path
tuple_with_path = (original_tuple + (path, ))
return tuple_with_path
train_dataset = ImageFolderWithPaths(
traindir,
transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
val_dataset = ImageFolderWithPaths(
valdir,
transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
]))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
print("The best accuracy obtained during training is = {}".format(
best_prec1))
def main():
global args, best_prec1
args = parser.parse_args()
# print (args)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet_freeze'):
model_file = 'wideresnet18_places365_1.pth.tar'
model = wideresnet.resnet18(num_classes=365)
checkpoint = torch.load(model_file, map_location=lambda storage, loc: storage)
state_dict = {str.replace(k,'module.',''): v for k,v in checkpoint['state_dict'].items()}
model.load_state_dict(state_dict)
model.eval()
for name,param in model.named_parameters():
# print(name)
if "fc" not in name:
param.requires_grad = False
else:
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# print (model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
print("DATA",args.data)
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(traindir, transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
print(args)
# create model
print(("=> creating model '{}'".format(args.arch)))
if args.arch.lower().startswith("wideresnet"):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
os.makedirs(os.path.join('models', args.arch.lower()), exist_ok=True)
if args.arch.lower().startswith("alexnet") or args.arch.lower().startswith(
"vgg"):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print(model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print(("=> loading checkpoint '{}'".format(args.resume)))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint["epoch"]
best_prec1 = checkpoint["best_prec1"]
model.load_state_dict(checkpoint["state_dict"])
print(("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint["epoch"])))
else:
print(("=> no checkpoint found at '{}'".format(args.resume)))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, "train")
valdir = os.path.join(args.data, "val")
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]),
),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True,
)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
]),
),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True,
)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(
model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
"epoch": epoch + 1,
"arch": args.arch,
"state_dict": model.state_dict(),
"best_prec1": best_prec1,
},
is_best,
os.path.join(models, args.arch.lower(), args.arch.lower()),
epoch=epoch)
def main():
global args, best_prec1
args = parser.parse_args()
print(args)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print(model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
dataset = datasets.ImageFolder(traindir)
class_to_idx = dataset.class_to_idx
with open('categories_places{}.txt'.format(len(class_to_idx)), 'w') as f:
for clazz, idx in class_to_idx.items():
f.write('/{}/{} {}\r\n'.format(clazz[0], clazz.replace('-', '/'),
idx))
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
print(args)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(pretrained=False,
num_channels=args.num_channels,
num_classes=args.num_classes)
'''
arch = 'resnet50'
model_file = 'whole_%s_places365.pth.tar' % arch
from functools import partial
import pickle
pickle.load = partial(pickle.load, encoding="latin1")
pickle.Unpickler = partial(pickle.Unpickler, encoding="latin1")
model = torch.load(model_file, map_location=lambda storage, loc: storage, pickle_module=pickle)
'''
print("this is resnet50")
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print("this is resnet50 with cuda")
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(
args.data, 'place_data_train/RGB/') #you may need to modify this path
valdir = os.path.join(
args.data, 'place_data_val/RGB/') #you may need to modify this path
if args.num_channels == 4:
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406, 0.29],
std=[0.229, 0.224, 0.225, 0.23])
#normalize = transforms.Normalize(mean=[0.485],
# std=[0.229])
if args.num_channels == 3:
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
ImageFolder(
traindir,
transform=transforms.Compose([
#transforms.RandomResizedCrop(224), # 2.7
transforms.RandomSizedCrop(224), #3.6
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]),
classifier_type=args.classifier_name,
num_channels=args.num_channels),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=False)
val_loader = torch.utils.data.DataLoader(
ImageFolder(
valdir,
transform=transforms.Compose([
#transforms.Resize(256), #2.7
transforms.Scale(256), # 3.6
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
]),
classifier_type=args.classifier_name,
num_channels=args.num_channels),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=False)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
torch.save(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1
},
args.arch.lower() + '_latest.pth.tar')
print("===Done with training===")
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best,
args.classifier_name.lower() + '_' + args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
print args
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(pretrained = True, num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
model.load_state_dict(torch.load('resnet50_places365.pth.tar'), strict=False)
model.fc= nn.Linear(in_features=model.fc.in_features, out_features=205)
#for para in list(model.parameters())[:-2]:
# para.requires_grad=False
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
print model
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
trainlist = args.train
vallist = args.val
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(
VideoNet(trainlist, transform = transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
VideoNet(vallist, transform = transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
# define loss function (criterion) and opptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint({
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
print('parsing args...')
args = parser.parse_args()
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
model = model.cuda()
print(model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
#train_loader = Provider(phase = 'train', batch_size=args.batch_size, workers=args.workers)
#val_loader = Provider(phase = 'test', batch_size=args.batch_size)
train_loader = torch.utils.data.DataLoader(Mydataset(phase='train'),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(Mydataset(phase='test'),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, './snapshot/' + args.arch.lower() + '_' + str(epoch))
def main():
global args, best_prec1
args = parser.parse_args()
print args
path = os.path.join(args.save_path, args.arch, args.pretrained_dataset)
if not os.path.isdir(path):
os.mkdir(path)
assert os.path.isdir(path), 'Error: no save directory! %s' % (path)
# create model
print("=> creating model '{}'".format(args.arch))
if args.pretrained_dataset == 'places365':
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
elif args.pretrained_dataset == 'imagenet':
model = models.__dict__[args.arch](pretrained=True)
# model = models.__dict__[args.arch](num_classes=1000, pretrained='imagenet')
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# model = model
print model
# optionally resume from a checkpoint
if args.resume and args.pretrained_dataset == 'places365':
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
#####################################################################################
# Extract Feature
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.classifier = model.classifier[:-1]
else:
new_classifier = nn.Sequential(*list(model.module.fc.children())[:-1])
model.module.fc = new_classifier
#####################################################################################
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
# optimizer = torch.optim.SGD(model.parameters(), args.lr,
# momentum=args.momentum,
# weight_decay=args.weight_decay)
optimizer = None
train(train_loader, model, criterion, optimizer, args.start_epoch)
prec1 = validate(val_loader, model, criterion)
def main():
global best_prec1
global start_epoch
# create model
print("=> creating model '{}'".format(arch))
if arch.lower().startswith('resnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(pretrained=True, num_classes=1000)
# print (model)
model.avgpool = nn.AdaptiveAvgPool2d(1)
model.fc = nn.Linear(2048, 256)
model.classifier = nn.Linear(256, num_classes)
# print (model.fc)
elif arch.lower().startswith('bcnn'):
model = BilinearCNN.BilinearCNN(num_classes)
elif arch.lower().startswith('inception'):
# model = inceptionv3.inception_v3(pretrained=True)
model = inceptionv3.inception_v3(pretrained=True)
model.fc = nn.Linear(2048, num_classes)
elif arch.lower().startswith('zrmodel'):
model = LeNet32(1)
else:
model = models.__dict__[arch](num_classes=365)
state_dict = torch.load('whole_alexnet_places365_python36.pth')
model.load_state_dict(state_dict)
model.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(256 * 6 * 6, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Linear(4096, num_classes),
)
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
# print (model)
model = model.cuda()
# model = nn.DataParallel(model, device_ids=[9])
# model = torch.nn.DataParallel(model).cuda()
print(model)
# optionally resume from a checkpoint
if resume:
if os.path.isfile(resume):
print("=> loading checkpoint '{}'".format(resume))
checkpoint = torch.load(resume)
start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(resume))
#
# cudnn.benchmark = True
# Data loading code
traindir = os.path.join(data_path, 'train')
valdir = os.path.join(data_path, 'val')
# normalize = transforms.Normalize(mean=[0.1680733,0.1680733,0.1680733],
# std=[0.15840427,0.15840427,0.15840427])
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
# train_loader = torch.utils.data.DataLoader(
# datasets.ImageFolder(traindir, transforms.Compose([
# # transforms.Lambda(lambda img:_cloud_crop(img)),
# # transforms.RandomResizedCrop(336, scale=(0.8, 1.0)),
# transforms.RandomResizedCrop(336),
# # transforms.CenterCrop(336),
# transforms.RandomHorizontalFlip(),
# # transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
# transforms.ToTensor(),
# normalize,
# ])),
# batch_size=batch_size, shuffle=True,
# num_workers=data_loader_workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(384),
transforms.CenterCrop(334),
transforms.ToTensor(),
normalize,
])),
batch_size=batch_size,
shuffle=True,
num_workers=data_loader_workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion_cel = nn.CrossEntropyLoss().cuda()
criterion_tml = nn.TripletMarginLoss(margin=1.0, p=2).cuda()
# optimizer = torch.optim.SGD(model.parameters(), lr,
# momentum=momentum,
# weight_decay=weight_decay)
optimizer = torch.optim.Adam(model.parameters(),
lr=lr,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=0,
amsgrad=False)
# optimizer = torch.optim.SGD([
# {'params': model.features.parameters()},
# {'params': model.classifier.parameters(), 'lr': lr}
# ], lr=lr, momentum=momentum,weight_decay =weight_decay)
if evaluate:
validate(val_loader, model, criterion_cel)
return
for epoch in range(start_epoch, epochs):
adjust_learning_rate(optimizer, epoch)
train_loader = DataLoader(
root_path=traindir,
batch_size=batch_size,
num_workers=data_loader_workers,
transforms=transforms.Compose([
# transforms.Lambda(lambda img:_cloud_crop(img)),
# transforms.RandomResizedCrop(336, scale=(0.8, 1.0)),
transforms.RandomResizedCrop(336),
# transforms.CenterCrop(336),
transforms.RandomHorizontalFlip(),
# transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
transforms.ToTensor(),
normalize,
]),
shuffle=True)
# train for one epoch
train(train_loader, model, criterion_tml, criterion_cel, optimizer,
epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion_cel)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, epoch, arch.lower())
def main():
print(args)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
else:
model = torch.nn.DataParallel(model)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
#cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.evaluate:
validate(val_loader, model, criterion, device)
return
for epoch in range(args.start_epoch, args.epochs):
#adjust_learning_rate(optimizer, epoch)
# train for one epoch
thisLoss = train(train_loader, model, criterion, optimizer, epoch,
device)
# evaluate on validation set
prec1, losstest, actual, predicted = validate(val_loader, model,
criterion, device)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'losses': losstest,
}, is_best, args.arch.lower())
def main():
global args, best_prec1
args = parser.parse_args()
#print (args)
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch.lower().startswith('wideresnet'):
# a customized resnet model with last feature map size as 14x14 for better class activation mapping
model = wideresnet.resnet50(num_classes=args.num_classes)
else:
model = models.__dict__[args.arch](num_classes=args.num_classes)
if args.arch.lower().startswith('alexnet') or args.arch.lower().startswith(
'vgg'):
model.features = torch.nn.DataParallel(model.features)
model
else:
model = torch.nn.DataParallel(model)
model = model.cuda()
device = torch.device('cuda')
# update the fully connected layer
nInF, nOutF = model.module.fc.in_features, args.num_outClasses # input size from original; 10 integer outputs
model.module.fc = torch.nn.Linear(nInF, nOutF, bias=True)
print(model)
#print (model)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume, map_location=device)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
for param in model.module.parameters():
param.requires_grad = False
for param in model.module.fc.parameters():
param.requires_grad = True
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
#scenicDF = pd.read_csv(args.data+'/newImagesWithJpg.tsv',sep='\t')
#scenicDF = scenicDF[['Images','Average']]
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
actualFull, predicFull = [], []
if args.evaluate:
validate(val_loader, model, criterion, device)
else:
lossesT, lossesV = [], []
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
losses, actual, predicted = train(train_loader, model, criterion,
optimizer, epoch, device)
lossesT.append(np.sqrt(float(losses.val)))
actualFull.append(act for act in actual)
predicFull.append(prd for prd in predicted)
# evaluate on validation set
prec1, losses, actual, predicted = validate(
val_loader, model, criterion, device)
lossesV.append(np.sqrt(float(losses.val)))
actualFull.append(act for act in actual)
predicFull.append(prd for prd in predicted)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
}, is_best, args.arch.lower())
# plot stuff
# loss vs epoch (only for training, not for validation-only processing)
epochs = range(args.start_epoch, args.epochs)
plt.plot(epochs, lossesT, 'b', label='Train')
plt.plot(epochs, lossesV, 'g', label='Test')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend(loc='best')
plt.savefig('errorVsEpoch.pdf')
plt.clf() # clear
# predicted vs actual scenery score
plt.plot(actualFull, predicFull)
plt.xlabel('Actual Scenery Score')
plt.ylabel('Predicted Scenery Score')
plt.savefig('predictedVsActual.pdf')
plt.clf()
# (predicted - actual) vs actual
plt.plot(actualFull, (predicFull - actualFull))
plt.xlabel('Actual Scenery Score')
plt.ylabel('(Predicted-Actual) Scenery Score')
plt.savefig('diffVsActual.pdf')
myOutPerfDF = pd.DataFrame(list(zip(actualFull, predicFull)),
columns=['Actual', 'Predicted'])
myOutPerfDF.to_csv('output_actualPredicted.csv')
myOutLossDF = pd.DataFrame(list(zip(epochs, lossesT, lossesV)),
columns=['Epoch', 'LossTrain', 'LossVal'])
myOutLossDF.to_csv('output_lossEpoch.csv')
