def main():
global args, best_err1, best_err5
args = parser.parse_args()
if args.dataset.startswith('cifar'):
normalize = transforms.Normalize(mean=[x / 255.0 for x in [125.3, 123.0, 113.9]],
std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
transform_test = transforms.Compose([
transforms.ToTensor(),
normalize
])
if args.dataset == 'cifar100':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data', train=True, download=True, transform=transform_train),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data', train=False, transform=transform_test),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
numberofclass = 100
elif args.dataset == 'cifar10':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data', train=True, download=True, transform=transform_train),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data', train=False, transform=transform_test),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
numberofclass = 10
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
elif args.dataset == 'imagenet':
traindir = os.path.join('/home/data/ILSVRC/train')
valdir = os.path.join('/home/data/ILSVRC/val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
jittering = utils.ColorJitter(brightness=0.4, contrast=0.4,
saturation=0.4)
lighting = utils.Lighting(alphastd=0.1,
eigval=[0.2175, 0.0188, 0.0045],
eigvec=[[-0.5675, 0.7192, 0.4009],
[-0.5808, -0.0045, -0.8140],
[-0.5836, -0.6948, 0.4203]])
train_dataset = datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
jittering,
lighting,
normalize,
]))
train_sampler = None
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None),
num_workers=args.workers, pin_memory=True, sampler=train_sampler)
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)
numberofclass = 1000
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
print("=> creating model '{}'".format(args.net_type))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth, numberofclass, args.bottleneck) # for ResNet
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha, numberofclass,
args.bottleneck)
else:
raise Exception('unknown network architecture: {}'.format(args.net_type))
model = torch.nn.DataParallel(model).cuda()
print(model)
print('the number of model parameters: {}'.format(sum([p.data.nelement() for p in model.parameters()])))
# 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, nesterov=True)
cudnn.benchmark = True
for epoch in range(0, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train_loss = train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
err1, err5, val_loss = validate(val_loader, model, criterion, epoch)
# remember best prec@1 and save checkpoint
is_best = err1 <= best_err1
best_err1 = min(err1, best_err1)
if is_best:
best_err5 = err5
print('Current best accuracy (top-1 and 5 error):', best_err1, best_err5)
save_checkpoint({
'epoch': epoch,
'arch': args.net_type,
'state_dict': model.state_dict(),
'best_err1': best_err1,
'best_err5': best_err5,
'optimizer': optimizer.state_dict(),
}, is_best)
print('Best accuracy (top-1 and 5 error):', best_err1, best_err5)
def main():
global args, best_err1, best_err5, global_epoch_confusion, best_loss
args = parser.parse_args()
if args.dataset.startswith('cifar'):
normalize = transforms.Normalize(
mean=[x / 255.0 for x in [125.3, 123.0, 113.9]],
std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
transform_test = transforms.Compose([transforms.ToTensor(), normalize])
if args.dataset == 'cifar100':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data',
train=True,
download=True,
transform=transform_train),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data',
train=False,
transform=transform_test),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
numberofclass = 100
elif args.dataset == 'cifar10':
train_data = datasets.CIFAR10('../data',
train=True,
download=True,
transform=transform_train)
print(train_data.targets[:30])
print(train_data.targets[:30])
print(len(train_data))
class_counts = [9.0, 1.0]
num_samples = sum(class_counts)
labels = [0, 0, ..., 0, 1] #corresponding labels of samples
class_weights = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
class_weights[args.first] = args.weight
class_weights[args.second] = args.weight
print(class_weights)
weights = [
class_weights[train_data.targets[i]]
for i in range(len(train_data))
]
sampler = WeightedRandomSampler(torch.DoubleTensor(weights),
len(train_data))
train_loader = torch.utils.data.DataLoader(
train_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True,
sampler=sampler)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data',
train=False,
transform=transform_test),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
numberofclass = 10
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
print("=> creating model '{}'".format(args.net_type))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth, numberofclass,
args.bottleneck) # for ResNet
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha,
numberofclass, args.bottleneck)
else:
raise Exception('unknown network architecture: {}'.format(
args.net_type))
model = torch.nn.DataParallel(model).cuda()
if os.path.isfile(args.pretrained):
print("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained)
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'".format(args.pretrained))
# print(model)
print('the number of model parameters: {}'.format(
sum([p.data.nelement() for p in model.parameters()])))
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss(reduction='none').cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
cudnn.benchmark = True
#validate(val_loader, model, criterion, 0)
# for checking pre-trained model accuracy and confusion
if args.checkmodel:
global_epoch_confusion.append({})
get_confusion(val_loader, model, criterion)
# cat->dog confusion
log_print(str(args.first) + " -> " + str(args.second))
log_print(global_epoch_confusion[-1]["confusion"][(args.first,
args.second)])
# dog->cat confusion
log_print(str(args.second) + " -> " + str(args.first))
log_print(global_epoch_confusion[-1]["confusion"][(args.second,
args.first)])
exit()
for epoch in range(0, args.epochs):
global_epoch_confusion.append({})
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
err1, err5, val_loss = validate(val_loader, model, criterion, epoch)
# remember best prec@1 and save checkpoint
if epoch // (args.epochs * 0.75):
is_best = err1 <= best_err1
best_err1 = min(err1, best_err1)
if is_best:
best_err5 = err5
best_err1 = err1
print('Current best accuracy (top-1 and 5 error):', best_err1,
best_err5)
save_checkpoint(
{
'epoch': epoch,
'arch': args.net_type,
'state_dict': model.state_dict(),
'best_err1': best_err1,
'best_err5': best_err5,
'optimizer': optimizer.state_dict(),
}, is_best)
get_confusion(val_loader, model, criterion, epoch)
# cat->dog confusion
log_print(str(args.first) + " -> " + str(args.second))
log_print(global_epoch_confusion[-1]["confusion"][(args.first,
args.second)])
# dog->cat confusion
log_print(str(args.second) + " -> " + str(args.first))
log_print(global_epoch_confusion[-1]["confusion"][(args.second,
args.first)])
print('Best accuracy (top-1 and 5 error):', best_err1, best_err5)
directory = "runs/%s/" % (args.expname)
if not os.path.exists(directory):
os.makedirs(directory)
epoch_confusions = 'runs/%s/' % (args.expname) + \
'epoch_confusion_' + args.expid
np.save(epoch_confusions, global_epoch_confusion)
log_print("")
# output best model accuracy and confusion
repaired_model = 'runs/%s/' % (args.expname) + 'model_best.pth.tar'
if os.path.isfile(repaired_model):
print("=> loading checkpoint '{}'".format(repaired_model))
checkpoint = torch.load(repaired_model)
model.load_state_dict(checkpoint['state_dict'])
get_confusion(val_loader, model, criterion)
# dog->cat confusion
log_print(str(args.first) + " -> " + str(args.second))
log_print(global_epoch_confusion[-1]["confusion"][(args.first,
args.second)])
# cat->dog confusion
log_print(str(args.second) + " -> " + str(args.first))
log_print(global_epoch_confusion[-1]["confusion"][(args.second,
args.first)])
def main():
global args, best_err1, best_err5
args = parser.parse_args()
global directory
directory = "runs/%s/" % (args.expname)
if not os.path.exists(directory):
os.makedirs(directory)
log = open(os.path.join(directory, 'log.txt'), 'w')
train_loader, val_loader, numberofclass = load_data(args)
if args.pretrained:
num_class_output = 8142
print("=> creating model '{}'".format(args.net_type))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth, numberofclass,
args.bottleneck) # for ResNet
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha,
numberofclass, args.bottleneck)
else:
raise Exception('unknown network architecture: {}'.format(
args.net_type))
# model = torch.nn.DataParallel(model).cuda()
model = model.cuda()
if args.pretrained:
if os.path.isfile(args.checkpoint):
print_log("=> loading checkpoint '{}'".format(args.checkpoint),
log)
checkpoint = torch.load(args.checkpoint)
model.load_state_dict(checkpoint['state_dict'])
print_log("=> loaded checkpoint '{}'".format(args.checkpoint), log)
num_ftrs = model.module.fc.in_features
model.module.fc = nn.Linear(num_ftrs, numberofclass).cuda()
else:
raise Exception("=> no checkpoint found at '{}'".format(
args.checkpoint))
# num_ftrs = model.module.fc.in_features
# model.fc = nn.Linear(num_ftrs, numberofclass)
print_log("=> network :\n {}".format(model), log)
# print(num_ftrs)
print_log(
'the number of model parameters: {}'.format(
sum([p.data.nelement() for p in model.parameters()])), log)
# exit()
# define loss function (criterion) and optimizer
cifar_version = args.dataset[5:]
if args.reweight:
print_log(
'using re-weighting using beta value : {}'.format(
args.beta_reweight), log)
# img_num_per_cls = [int(line.strip()) for line in open(
# 'img_num_per_cls.txt', 'r')]
img_num_per_cls = get_img_num_per_cls(cifar_version, args.imb_factor)
effective_num = 1.0 - np.power(args.beta_reweight, img_num_per_cls)
weights = (1.0 - args.beta_reweight) / np.array(effective_num)
weights = weights / np.sum(weights) * int(numberofclass)
weights = torch.tensor(weights).float()
criterion = nn.CrossEntropyLoss(weight=weights).cuda()
else:
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
cudnn.benchmark = True
for epoch in range(0, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train_loss = train(train_loader, model, criterion, optimizer, epoch,
log)
# evaluate on validation set
err1, err5, val_loss = validate(val_loader, model, criterion, epoch,
log)
# remember best prec@1 and save checkpoint
is_best = err1 <= best_err1
best_err1 = min(err1, best_err1)
if is_best:
best_err5 = err5
print_log(
'Current best accuracy (top-1 and 5 error): {} {}'.format(
best_err1, best_err5), log)
save_checkpoint(
{
'epoch': epoch,
'arch': args.net_type,
'state_dict': model.state_dict(),
'best_err1': best_err1,
'best_err5': best_err5,
'optimizer': optimizer.state_dict(),
}, is_best)
print_log(
'Best accuracy (top-1 and 5 error): {} {}'.format(
best_err1, best_err5), log)
def main():
global args, best_err1, best_err5, global_epoch_confusion, best_loss
args = parser.parse_args()
if args.dataset.startswith('cifar'):
normalize = transforms.Normalize(mean=[x / 255.0 for x in [125.3, 123.0, 113.9]],
std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
transform_test = transforms.Compose([
transforms.ToTensor(),
normalize
])
if args.dataset == 'cifar100':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data', train=True,
download=True, transform=transform_train),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data', train=False,
transform=transform_test),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
numberofclass = 100
elif args.dataset == 'cifar10':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data', train=True,
download=True, transform=transform_train),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data', train=False,
transform=transform_test),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
numberofclass = 10
target_train_dataset = datasets.CIFAR10(
'../data', train=True, download=True, transform=transform_train)
target_train_dataset = get_dataset_from_specific_classes(
target_train_dataset, args.first, args.second, args.third)
target_test_dataset = datasets.CIFAR10(
'../data', train=False, download=True, transform=transform_test)
target_test_dataset = get_dataset_from_specific_classes(
target_test_dataset, args.first, args.second, args.third)
target_train_loader = torch.utils.data.DataLoader(target_train_dataset, batch_size=args.extra, shuffle=True,
num_workers=args.workers, pin_memory=True)
target_val_loader = torch.utils.data.DataLoader(target_test_dataset, batch_size=args.extra, shuffle=True,
num_workers=args.workers, pin_memory=True)
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
print("=> creating model '{}'".format(args.net_type))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth,
numberofclass, args.bottleneck) # for ResNet
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha, numberofclass,
args.bottleneck)
else:
raise Exception(
'unknown network architecture: {}'.format(args.net_type))
model = torch.nn.DataParallel(model).cuda()
if os.path.isfile(args.pretrained):
print("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained)
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'".format(args.pretrained))
# print(model)
print('the number of model parameters: {}'.format(
sum([p.data.nelement() for p in model.parameters()])))
# replace bn layer
if args.replace:
model.to('cpu')
global glob_bn_count
global glob_bn_total
glob_bn_total = 0
glob_bn_count = 0
count_bn_layer(model)
print("total bn layer: " + str(glob_bn_total))
glob_bn_count = 0
replace_bn(model)
print(model)
model = model.cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss(reduction='none').cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay, nesterov=True)
cudnn.benchmark = True
#validate(val_loader, model, criterion, 0)
# for checking pre-trained model accuracy and confusion
if args.checkmodel:
global_epoch_confusion.append({})
get_confusion(val_loader, model, criterion)
confusion_matrix = global_epoch_confusion[-1]["confusion"]
print(str((args.first, args.second, args.third)) + " triplet: " +
str(abs(confusion_matrix[(args.first, args.second)] - confusion_matrix[(args.first, args.third)])))
print(str((args.first, args.second)) + ": " + str(confusion_matrix[(args.first, args.second)]))
print(str((args.first, args.third)) + ": " + str(confusion_matrix[(args.first, args.third)]))
exit()
for epoch in range(0, args.epochs):
global_epoch_confusion.append({})
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, target_train_loader,
model, criterion, optimizer, epoch)
# evaluate on validation set
err1, err5, val_loss = validate(
val_loader, target_val_loader, model, criterion, epoch)
# remember best prec@1 and save checkpoint
if epoch // (args.epochs * 0.75):
is_best = err1 <= best_err1
best_err1 = min(err1, best_err1)
if is_best:
best_err5 = err5
best_err1 = err1
print('Current best accuracy (top-1 and 5 error):',
best_err1, best_err5)
save_checkpoint({
'epoch': epoch,
'arch': args.net_type,
'state_dict': model.state_dict(),
'best_err1': best_err1,
'best_err5': best_err5,
'optimizer': optimizer.state_dict(),
}, is_best)
get_confusion(val_loader, model, criterion, epoch)
confusion_matrix = global_epoch_confusion[-1]["confusion"]
#print("loss: " + str(global_epoch_confusion[-1]["loss"]))
first_second = compute_confusion(confusion_matrix, args.first, args.second)
first_third = compute_confusion(confusion_matrix, args.first, args.third)
print(str((args.first, args.second, args.third)) + " triplet: " +
str(compute_bias(confusion_matrix, args.first, args.second, args.third)))
print(str((args.first, args.second)) + ": " + str(first_second))
print(str((args.first, args.third)) + ": " + str(first_third))
print('Best accuracy (top-1 and 5 error):', best_err1, best_err5)
directory = "runs/%s/" % (args.expname)
if not os.path.exists(directory):
os.makedirs(directory)
epoch_confusions = 'runs/%s/' % (args.expname) + \
'epoch_confusion_' + args.expid
np.save(epoch_confusions, global_epoch_confusion)
log_print("")
# output best model accuracy and confusion
repaired_model = 'runs/%s/' % (args.expname) + 'model_best.pth.tar'
if os.path.isfile(repaired_model):
print("=> loading checkpoint '{}'".format(repaired_model))
checkpoint = torch.load(repaired_model)
model.load_state_dict(checkpoint['state_dict'])
get_confusion(val_loader, model, criterion)
confusion_matrix = global_epoch_confusion[-1]["confusion"]
#print("loss: " + str(global_epoch_confusion[-1]["loss"]))
first_second = compute_confusion(confusion_matrix, args.first, args.second)
first_third = compute_confusion(confusion_matrix, args.first, args.third)
print(str((args.first, args.second, args.third)) + " triplet: " +
str(compute_bias(confusion_matrix, args.first, args.second, args.third)))
print(str((args.first, args.second)) + ": " + str(first_second))
print(str((args.first, args.third)) + ": " + str(first_third))
def main():
global args, best_err1, best_err5
args = parser.parse_args()
img = Image.open(args.img_path).convert('RGB')
if args.dataset.startswith('cifar'):
size = (32, 32)
normalize = transforms.Normalize(
mean=[x / 255.0 for x in [125.3, 123.0, 113.9]],
std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
transform_inference = transforms.Compose(
[transforms.Resize(size),
transforms.ToTensor(), normalize])
img = transform_inference(img).unsqueeze(0)
if args.dataset == 'cifar100':
numberofclass = 100
elif args.dataset == 'cifar10':
numberofclass = 10
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
elif args.dataset == 'imagenet':
valdir = os.path.join('/home/data/ILSVRC/val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
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)
numberofclass = 1000
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
print("=> creating model '{}'".format(args.net_type))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth, numberofclass,
args.bottleneck) # for ResNet
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha,
numberofclass, args.bottleneck)
else:
raise Exception('unknown network architecture: {}'.format(
args.net_type))
model = torch.nn.DataParallel(model).cuda()
if os.path.isfile(args.pretrained):
print("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained)
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'".format(args.pretrained))
else:
raise Exception("=> no checkpoint found at '{}'".format(
args.pretrained))
model.module.fc = Identity()
cudnn.benchmark = True
print(model)
def main():
global args, best_err1, best_err5
args = parser.parse_args()
if args.dataset.startswith('cifar'):
normalize = transforms.Normalize(
mean=[x / 255.0 for x in [125.3, 123.0, 113.9]],
std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
transform_test = transforms.Compose([transforms.ToTensor(), normalize])
if args.dataset == 'cifar100':
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data',
download=True,
train=False,
transform=transform_test),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
numberofclass = 100
elif args.dataset == 'cifar10':
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data',
download=True,
train=False,
transform=transform_test),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
numberofclass = 10
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
elif args.dataset == 'imagenet':
valdir = os.path.join('/home/data/ILSVRC/val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
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)
numberofclass = 1000
else:
raise Exception('unknown dataset: {}'.format(args.dataset))
print("=> creating model '{}'".format(args.net_type))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth, numberofclass,
args.bottleneck) # for ResNet
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha,
numberofclass, args.bottleneck)
else:
raise Exception('unknown network architecture: {}'.format(
args.net_type))
model = torch.nn.DataParallel(model).cuda()
if os.path.isfile(args.pretrained):
print("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained)
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'".format(args.pretrained))
else:
raise Exception("=> no checkpoint found at '{}'".format(
args.pretrained))
print(model)
print('the number of model parameters: {}'.format(
sum([p.data.nelement() for p in model.parameters()])))
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
cudnn.benchmark = True
# evaluate on validation set
err1, err5, val_loss = validate(val_loader, model, criterion)
print('Accuracy (top-1 and 5 error):', err1, err5)
def main():
global args, best_err1, best_err5
args = parser.parse_args()
if args.dataset.startswith('cifar'):
normalize = transforms.Normalize(mean=[x / 255.0 for x in [125.3, 123.0, 113.9]],
std=[x / 255.0 for x in [63.0, 62.1, 66.7]])
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
transform_test = transforms.Compose([
transforms.ToTensor(),
normalize,
])
if args.dataset == 'cifar100':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data', train=True, download=True, transform=transform_train),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR100('../data', train=False, transform=transform_test),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
numberofclass = 100
elif args.dataset == 'cifar10':
train_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data',train=True, download=True, transform=transform_train),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
datasets.CIFAR10('../data', train=False, transform=transform_test),
batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)
numberofclass = 10
else:
raise Exception('unknown dataset : {}'.format(args.dataset))
if args.net_type == 'resnet':
model = RN.ResNet(args.dataset, args.depth, numberofclass, args.bottleneck)
elif args.net_type == 'pyramidnet':
model = PYRM.PyramidNet(args.dataset, args.depth, args.alpha, numberofclass, args.bottleneck)
else:
raise Exception('unknown network architecture: {}'.format(args.net_type))
model = torch.nn.DataParallel(model).cuda()
#print(model)
#print('the number of model parameters: {}'.format(sum([p.data.nelement() for p in model.parameters()])))
criterion = nn.CrossEntropyLoss().cuda()
optimizer = optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True)
cudnn.benchmark = True
for epoch in range(0, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train_loss = train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
err1, err5, val_loss = validate(val_loader, model, criterion, epoch)
# remember best prec@1 and save checkpoint
is_best = err1 <= best_err1
best_err1 = min(err1, best_err1)
if is_best:
best_err5 = err5
print('Current best accuracy (top-1 and 5 error):', best_err1, best_err5)
save_checkpoint({
'epoch': epoch,
'arch': args.net_type,
'state_dict': model.state_dict(),
'best_err1': best_err1,
'best_err5': best_err5,
'optimizer': optimizer.state_dict(),
}, is_best)
print('Best accuracy (top-1 and 5 error):', best_err1, best_err5)