def add_cutout(self, thetadeg, pt, d, drill_offset_deg=0.,
clearance_factor=0.75):
r"""Add a cutout
Parameters
----------
thetadeg : float
Circumferential position of the dimple.
pt : float
Normalized meridional position.
d : float
Diameter of the drilling machine.
drill_offset_deg : float
Angular offset when the drilling is not normal to the shell
surface. A positive offset means a positive rotation about the
`\theta` axis, along the meridional plane.
clearance_factor : float
Fraction of the diameter to apply as clearance around the cutout.
This clearance is partitoned and meshed separately from the rest of
the cone / cylinder.
Returns
-------
cutout : :class:`.Cutout` object.
"""
cutout = Cutout(thetadeg, pt, d, drill_offset_deg, clearance_factor)
cutout.impconf = self
self.cutouts.append(cutout)
return cutout
def add_cutout(self,
thetadeg,
pt,
d,
drill_offset_deg=0.,
clearance_factor=0.75):
r"""Add a cutout
Parameters
----------
thetadeg : float
Circumferential position of the dimple.
pt : float
Normalized meridional position.
d : float
Diameter of the drilling machine.
drill_offset_deg : float
Angular offset when the drilling is not normal to the shell
surface. A positive offset means a positive rotation about the
`\theta` axis, along the meridional plane.
clearance_factor : float
Fraction of the diameter to apply as clearance around the cutout.
This clearance is partitoned and meshed separately from the rest of
the cone / cylinder.
Returns
-------
cutout : :class:`.Cutout` object.
"""
cutout = Cutout(thetadeg, pt, d, drill_offset_deg, clearance_factor)
cutout.impconf = self
self.cutouts.append(cutout)
return cutout
def add_cutout(self, thetadeg, pt, d, drill_offset_deg=0.,
clearance_factor=0.75, numel_radial_edge=4,
prop_around_hole=None):
r"""Add a cutout
Parameters
----------
thetadeg : float
Circumferential position of the dimple.
pt : float
Normalized meridional position.
d : float
Diameter of the drilling machine.
drill_offset_deg : float, optional
Angular offset when the drilling is not normal to the shell
surface. A positive offset means a positive rotation about the
`\theta` axis, along the meridional plane.
clearance_factor : float, optional
Fraction of the diameter to apply as clearance around the cutout.
This clearance is partitoned and meshed separately from the rest of
the cone / cylinder.
numel_radial_edge : int, optional
Number of elements along the radial edges about the cutout center.
This parameter affects the aspect ratio of the elements inside the
cutout area.
prop_around_hole : dict, optional
Dictionary with keys:
- radius : float
- 'stack': list of floats
- 'plyts': list of floats
- 'mat_names': list of strings
Example::
prop_around_holes = {
'radius': 10.,
'stack': [0, 90, 0],
'plyts': [0.125, 0.125, 0.125],
'mat_names': ['Alum', 'Alum', 'Alum'],
}
.. note:: `mat_names` must be a list of materials already created in
the current model in Abaqus
Returns
-------
cutout : :class:`.Cutout` object.
"""
cutout = Cutout(thetadeg, pt, d, drill_offset_deg, clearance_factor,
numel_radial_edge, prop_around_hole)
cutout.impconf = self
self.cutouts.append(cutout)
return cutout
def __init__(self, args):
self.images = list()
self.targets = list()
self.args = args
# for path, _, image_set in os.walk(os.path.join(args.data_dir, 'train')):
# if os.path.isdir(path):
# for image in image_set:
lines = open(args.train_list).readlines()
for line in lines:
path, label = line.strip().split(' ')
self.images.append(os.path.join(args.data_dir, path))
self.targets.append(int(label))
self.mean = [0.485, 0.456, 0.406]
self.dev = [0.229, 0.224, 0.225]
self.transform = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=self.mean, std=self.dev),
])
if args.cutout:
self.transform.transforms.append(Cutout(n_holes=args.n_holes, length=args.length))
def __getitem__(self, i):
image = cv2.imread(self.images_dir + self.images[i], cv2.IMREAD_COLOR)
image = cv2.resize(image,
self.base_size,
interpolation=cv2.INTER_LINEAR)
if self.applyAutoAug:
image = Image.fromarray(image.astype('uint8'))
#policy = ImageNetPolicy()
policy = CIFAR10Policy()
#policy = SVHNPolicy()
image = policy(image)
image = np.array(image)
#img = np.asarray(image)
if self.applyCutout:
image = Cutout(image) ##这么写是错的
#size = image.shape
##normalize and change it to a tensor
#image = self.input_transform(image)
#image = image.transpose((2, 0, 1))
label = cv2.imread(self.labels_dir + self.labels[i],
cv2.IMREAD_GRAYSCALE)
label = cv2.resize(label,
self.base_size,
interpolation=cv2.INTER_NEAREST)
#some operations needed here
## depends on the range of label values
#label = self.convert_label(label)
image, label = self.gen_sample(image, label, self.multi_scale,
self.flip)
label = np.expand_dims(label, axis=0)
return image.copy(), label.copy()
def do_test(flag_augmetation = False,
flag_cutout = False,
n_holes = 1,
length = 16,
depth = 18,
epochs = 100,
lr = 0.1,
mixup_enbale = True,
alpha = 0.1
):
model_checkpoint = "resnet" + str(depth)
if flag_augmetation:
model_checkpoint += '+'
if flag_cutout:
model_checkpoint += "cutout"
model_checkpoint += ".pt"
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]])
train_transform = transforms.Compose([])
if flag_augmetation:
train_transform.transforms.append(transforms.RandomCrop(32, padding=4))
train_transform.transforms.append(transforms.RandomHorizontalFlip())
train_transform.transforms.append(transforms.ToTensor())
train_transform.transforms.append(normalize)
if flag_cutout:
train_transform.transforms.append(Cutout(n_holes = n_holes, length = length))
train_set=torchvision.datasets.CIFAR10(
root='./data/cifar10',
train=True,
download=True,
transform=train_transform)
test_set=torchvision.datasets.CIFAR10(
root='./data/cifar10',
train=False,
download=True,
transform=transforms.Compose([transforms.ToTensor(), normalize]))
acc_train,acc_test = train_(train_set,test_set,lr, depth,mixup_enbale,alpha, model_checkpoint, epochs = epochs)
return (acc_train,acc_test)
def my_transform(train=True,
resize=224,
use_cutout=False,
n_holes=1,
length=8,
auto_aug=False,
rand_aug=False):
transforms = []
interpolations = [
PIL.Image.NEAREST, PIL.Image.BILINEAR, PIL.Image.HAMMING,
PIL.Image.BICUBIC, PIL.Image.LANCZOS
]
if train:
# transforms.append(T.RandomRotation(90))
transforms.append(
T.RandomResizedCrop(resize + 5,
scale=(0.2, 2.0),
interpolation=PIL.Image.BICUBIC))
transforms.append(T.RandomHorizontalFlip())
# transforms.append(T.RandomVerticalFlip())
transforms.append(T.ColorJitter(0.2, 0.2, 0.3, 0.))
transforms.append(T.CenterCrop(resize))
if auto_aug:
transforms.append(AutoAugment())
if rand_aug:
transforms.append(Rand_Augment())
else:
transforms.append(T.Resize(resize, interpolation=PIL.Image.BICUBIC))
transforms.append(T.CenterCrop(resize))
transforms.append(T.ToTensor())
transforms.append(
# T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
# T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]))
T.Normalize(mean=[0.507, 0.522, 0.500], std=[0.213, 0.207, 0.212]))
if train and use_cutout:
transforms.append(Cutout())
return T.Compose(transforms)
def __init__(self, dataset, label, cutout=False, i=1, j=18):
self.dataset = []
self.label = []
self.cutout = cutout
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if self.cutout:
self.transform = transforms.Compose(
[transforms.ToTensor(), normalize,
Cutout(i, j)])
else:
self.transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
for data in dataset:
self.dataset.append(data)
for lab in label:
self.label.append(lab)
def my_transform(train=True,
resize=224,
use_cutout=False,
n_holes=1,
length=8,
auto_aug=False,
raug=False,
N=0,
M=0):
transforms = []
if train:
transforms.append(T.RandomRotation(90))
transforms.append(
T.RandomResizedCrop(resize + 20,
scale=(0.2, 1.0),
interpolation=PIL.Image.BICUBIC))
transforms.append(T.RandomHorizontalFlip())
# transforms.append(T.RandomVerticalFlip())
transforms.append(T.ColorJitter(0.3, 0.2, 0.2, 0.2))
transforms.append(T.CenterCrop(resize))
if auto_aug:
transforms.append(AutoAugment())
if raug:
transforms.append(Randaugment(N, M))
else:
transforms.append(T.Resize(resize, interpolation=PIL.Image.BICUBIC))
transforms.append(T.CenterCrop(resize))
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
if train and use_cutout:
transforms.append(Cutout())
return T.Compose(transforms)
print(args)
# Image Preprocessing
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]])
train_transform = transforms.Compose([])
if args.data_augmentation:
train_transform.transforms.append(transforms.RandomCrop(32, padding=4))
train_transform.transforms.append(transforms.RandomHorizontalFlip())
train_transform.transforms.append(transforms.ToTensor())
train_transform.transforms.append(normalize)
if args.cutout:
train_transform.transforms.append(
Cutout(n_holes=args.n_holes, length=args.length))
test_transform = transforms.Compose([transforms.ToTensor(), normalize])
if args.dataset == 'cifar10':
num_classes = 10
train_dataset = datasets.CIFAR10(root='data/',
train=True,
transform=train_transform,
download=True)
test_dataset = datasets.CIFAR10(root='data/',
train=False,
transform=test_transform,
download=True)
elif args.dataset == 'cifar100':
parser.add_argument('--teacher', default="resnet18", type=str)
parser.add_argument('--t',
default=3.0,
type=float,
help="temperature for logit distillation ")
args = parser.parse_args()
print(args)
BATCH_SIZE = 128
LR = 0.1
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4, fill=128),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
Cutout(n_holes=1, length=16),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
trainset, testset = None, None
if args.dataset == 'cifar100':
trainset = torchvision.datasets.CIFAR100(root='data',
train=True,
download=True,
transform=transform_train)
testset = torchvision.datasets.CIFAR100(root='data',
train=False,
def add_cutout(self,
thetadeg,
pt,
d,
drill_offset_deg=0.,
clearance_factor=0.75,
numel_radial_edge=4,
prop_around_cutout=None):
r"""Add a cutout
Parameters
----------
thetadeg : float
Circumferential position of the dimple.
pt : float
Normalized meridional position.
d : float
Diameter of the drilling machine.
drill_offset_deg : float, optional
Angular offset when the drilling is not normal to the shell
surface. A positive offset means a positive rotation about the
`\theta` axis, along the meridional plane.
clearance_factor : float, optional
Fraction of the diameter to apply as clearance around the cutout.
This clearance is partitoned and meshed separately from the rest of
the cone / cylinder.
numel_radial_edge : int, optional
Number of elements along the radial edges about the cutout center.
This parameter affects the aspect ratio of the elements inside the
cutout area.
prop_around_cutout : dict, optional
Dictionary with keys:
- 'mode' : str ('radius' or 'partition')
- 'radius' : float
- 'stack': list of floats
- 'plyts': list of floats
- 'mat_names': list of strings
.
Examples:
- Defining a property with ``'mode'='radius'``::
prop_around_cutout = {
'mode': 'radius',
'radius': 10.,
'stack': [0, 90, 0],
'plyts': [0.125, 0.125, 0.125],
'mat_names': ['Alum', 'Alum', 'Alum'],
}
- Defining a property with ``'mode'='partition'``::
prop_around_cutout = {
'mode': 'partition',
'stack': [0, 90, 0],
'plyts': [0.125, 0.125, 0.125],
'mat_names': ['Alum', 'Alum', 'Alum'],
}
.. note:: ``mat_names`` must be a list of materials already created in
the current model in Abaqus
Returns
-------
cutout : :class:`.Cutout` object.
"""
cutout = Cutout(thetadeg, pt, d, drill_offset_deg, clearance_factor,
numel_radial_edge, prop_around_cutout)
cutout.impconf = self
self.cutouts.append(cutout)
return cutout
test_id = dataset + '_' + model
# Image Preprocessing
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]])
train_transform = transforms.Compose([])
train_transform.transforms.append(transforms.Resize(256))
if data_augmentation:
train_transform.transforms.append(transforms.RandomCrop(256, padding=12))
train_transform.transforms.append(transforms.RandomHorizontalFlip())
train_transform.transforms.append(transforms.ToTensor())
train_transform.transforms.append(normalize)
if cutout:
train_transform.transforms.append(Cutout(n_holes=n_holes, length=length))
train_transform.transforms.append(transforms.Resize(32))
test_transform = transforms.Compose([transforms.ToTensor(), normalize])
if dataset == 'cifar10':
num_classes = 10
train_dataset = datasets.CIFAR10(root='data/',
train=True,
transform=train_transform,
download=True)
test_dataset = datasets.CIFAR10(root='data/',
train=False,
transform=test_transform,
download=True)
else torch.device('cuda:{}'.format(options.device))
normalize = transforms.Normalize(
mean=[x / 255.0 for x in [123.675, 116.28, 103.53]],
std=[x / 255.0 for x in [58.395, 57.12, 57.375]])
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize
]) if not options.cutout else \
transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
Cutout(n_holes=1, length=options.length)
])
test_transform = transforms.Compose([transforms.ToTensor(), normalize])
if options.dataset == 'cifar10':
train_set = torchvision.datasets.CIFAR10(root=root,
train=True,
download=True,
transform=train_transform)
test_set = torchvision.datasets.CIFAR10(root=root,
train=False,
download=True,
transform=test_transform)
num_classes = 10
elif options.dataset == 'svhn':
normalize = transforms.Normalize(
def main_worker(args):
global best_acc
global logger
start_epoch = args.start_epoch
if not os.path.exists(args.checkpoint) and not args.resume:
mkdir_p(args.checkpoint)
if args.gpu is not None:
print("Use GPU: {} for experiments".format(args.gpu))
model = models.__dict__[args.arch](args.num_classes)
if args.pretrained:
print("==> Load pretrained model")
model_dict = model.state_dict()
pretrained_dict = model_zoo.load_url(model_urls[args.arch])
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
torch.cuda.set_device(args.gpu)
model = model.cuda()
print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0))
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
title = 'CIFAR100-' + args.arch
if args.resume:
if os.path.isfile(args.resume):
print('==> Resuming from checkpoint..')
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
args.checkpoint = os.path.dirname(args.resume)
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True)
else:
print("=> no checkpoint found at '{}'".format(args.resume))
exit(-1)
else:
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(['Learning Rate', 'Train Loss', 'Val Loss', 'Val Acc', 'Val Side1 Acc', 'Val Side2 Acc',
'Val Side3 Acc'])
normalize = transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
std=[0.2023, 0.1994, 0.2010])
tra_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
# CIFAR10Policy(),
transforms.ToTensor(),
Cutout(n_holes=1, length=16),
normalize,
])
tra_test = transforms.Compose([
transforms.ToTensor(),
normalize,
])
# Set download=True to download data
train_dataset = tv.datasets.CIFAR100(root=args.data, train=True, transform=tra_train, download=False)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers
)
val_dataset = tv.datasets.CIFAR100(root=args.data, train=False, transform=tra_test, download=False)
val_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers
)
if args.evaluate:
m, s1, s2, s3 = test(val_loader, model)
print(m)
print("\n")
print(s1)
print("\n")
print(s2)
print("\n")
print(s3)
return
writer = SummaryWriter(args.checkpoint)
for epoch in range(start_epoch, args.epochs):
total_loss = train(train_loader, model, criterion, epoch, optimizer, args)
writer.add_scalar('Train loss', total_loss, epoch + 1)
# evaluate on validation set
val_total_loss, val_main_acc, val_side1_acc, val_side2_acc, val_side3_acc = validate(
val_loader, model,
criterion, args)
lr = optimizer.param_groups[0]['lr']
logger.append(
[lr, total_loss, val_total_loss, val_main_acc, val_side1_acc, val_side2_acc, val_side3_acc])
writer.add_scalar('Learning rate', lr, epoch + 1)
writer.add_scalar('Val Loss', val_total_loss, epoch + 1)
writer.add_scalar('Main Acc', val_main_acc, epoch + 1)
writer.add_scalar('Side1 Acc', val_side1_acc, epoch + 1)
writer.add_scalar('Side2 Acc', val_side2_acc, epoch + 1)
writer.add_scalar('Side3 Acc', val_side3_acc, epoch + 1)
is_best = best_acc < val_main_acc
best_acc = max(best_acc, val_main_acc)
if args.save:
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
}, is_best, checkpoint=args.checkpoint)
logger.close()
writer.close()
print('Best accuracy:')
print(best_acc)
torch.cuda.empty_cache()
# obviously flipping is a bad idea, and it makes some sense not to
# crop because there are a lot of distractor digits in the edges of the
# image
transform_train = transforms.ToTensor()
if args.autoaugment or args.cutout:
assert (args.dataset == 'cifar10')
transform_list = [
transforms.RandomCrop(32, padding=4, fill=128),
# fill parameter needs torchvision installed from source
transforms.RandomHorizontalFlip()]
if args.autoaugment:
transform_list.append(CIFAR10Policy())
transform_list.append(transforms.ToTensor())
if args.cutout:
transform_list.append(Cutout(n_holes=1, length=16))
transform_train = transforms.Compose(transform_list)
logger.info('Applying aggressive training augmentation: %s'
% transform_train)
transform_test = transforms.Compose([
transforms.ToTensor()])
# ------------------------------------------------------------------------------
# ----------------- DATASET WITH AUX PSEUDO-LABELED DATA -----------------------
trainset = SemiSupervisedDataset(base_dataset=args.dataset,
add_svhn_extra=args.svhn_extra,
root=args.data_dir, train=True,
download=True, transform=transform_train,
aux_data_filename=args.aux_data_filename,
],
p=1)
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transform = transforms.Compose([
#transforms.Resize(input_size, 3),
#transforms.RandomResizedCrop(input_size, scale=(0.8, 1.0), ratio=(0.8, 1.2), interpolation=3),
#transforms.RandomHorizontalFlip(),
#transforms.RandomVerticalFlip(),
#transforms.RandomRotation(90),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
if CUTOUT:
train_transform.transforms.append(Cutout(n_holes=1, length=160))
val_transform = transforms.Compose([
transforms.Resize(input_size, 3),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
tta_transform = transforms.Compose([
transforms.Resize(input_size, 3),
transforms.Lambda(lambda image: torch.stack([
transforms.ToTensor()(image),
transforms.ToTensor()(image.rotate(90, resample=0)),
transforms.ToTensor()(image.rotate(180, resample=0)),
transforms.ToTensor()(image.rotate(270, resample=0)),
transforms.ToTensor()(image.transpose(method=Image.FLIP_TOP_BOTTOM)),
transforms.ToTensor()
(image.transpose(method=Image.FLIP_TOP_BOTTOM).rotate(90, resample=0)),
def find_best_cutout_size(range_to_test, nb_evaluation_per_size, epochs):
result = dict()
seed = 12
for size in range_to_test:
print('\n', 'size : ', size, '\n')
n_holes = 1
hole_length = size
labels_text = [
"T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", "Sandal",
"Shirt", "Sneaker", "Bag", "Ankle boot"
]
transform_training = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.2867], std=[0.3205]),
Cutout(n_holes, hole_length)
])
transform_validation = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.2867], std=[0.3205]),
])
full_trainset = torchvision.datasets.FashionMNIST(
root='data',
train=True,
download=True,
transform=transform_training)
trainset, _ = torch.utils.data.random_split(
full_trainset, (10000, 50000),
generator=torch.Generator().manual_seed(seed))
full_validset = torchvision.datasets.FashionMNIST(
root='data',
train=False,
download=True,
transform=transform_training)
validset, _ = torch.utils.data.random_split(
full_validset, (1000, 9000),
generator=torch.Generator().manual_seed(seed))
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=64,
shuffle=True,
num_workers=2)
validloader = torch.utils.data.DataLoader(validset,
batch_size=64,
shuffle=False,
num_workers=2)
DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
train_stats = np.zeros((nb_evaluation_per_size, 4))
for i in range(nb_evaluation_per_size):
print(f"try : {i +1}")
train_stats[i] = iterate_on_model(epochs, DEVICE, trainloader,
validloader)
print('*')
avg_training_accuracy = np.mean(train_stats[:, 0])
avg_validation_accuracy = np.mean(train_stats[:, 1])
avg_training_loss = np.mean(train_stats[:, 2])
avg_validation_loss = np.mean(train_stats[:, 3])
std_training_accuracy = np.std(train_stats[:, 0])
std_validation_accuracy = np.std(train_stats[:, 1])
std_training_loss = np.std(train_stats[:, 2])
std_validation_loss = np.std(train_stats[:, 3])
result[size] = [
avg_training_accuracy, avg_validation_accuracy, avg_training_loss,
avg_validation_loss, std_training_accuracy,
std_validation_accuracy, std_training_loss, std_validation_loss
]
return result
test_id = 'cifar10' + '_' + model
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]])
train_transform = transforms.Compose([])
if data_augmentation:
train_transform.transforms.append(transforms.RandomCrop(32, padding=4))
train_transform.transforms.append(transforms.RandomHorizontalFlip())
train_transform.transforms.append(transforms.ToTensor())
train_transform.transforms.append(normalize)
# cutout augmentation
train_transform.transforms.append(Cutout(
n_holes=n_holes, length=length)) # cutout augemntation
test_transform = transforms.Compose([transforms.ToTensor(), normalize])
train_dataset = datasets.CIFAR10(root='data/',
train=True,
transform=train_transform,
download=True)
test_dataset = datasets.CIFAR10(root='data/',
train=False,
transform=test_transform,
download=True)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
transform_ori = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
#transforms.Normalize((0.49139968, 0.48215841, 0.44653091), (0.24703223, 0.24348513, 0.26158784)),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
transform_aug = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
CIFAR10Policy(),
transforms.ToTensor(),
#transforms.Normalize((0.49139968, 0.48215841, 0.44653091), (0.24703223, 0.24348513, 0.26158784)),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
Cutout(n_holes=args.n_holes, length=args.cutout_size),
])
#transform_aug = transform_ori
#transform_train_aug.transforms.append()
#if args.cutout:
# transform_aug.transforms.append(Cutout(n_holes=args.n_holes, length=args.cutout_size))
#if args.autoaugment:
# transform_aug.transforms.append(CIFAR10Policy())
transform_test = transforms.Compose([
transforms.ToTensor(),
#transforms.Normalize((0.49139968, 0.48215841, 0.44653091), (0.24703223, 0.24348513, 0.26158784)),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
print('==> Preparing data..')
if args.a: #TANNER: this was backwards before, switched in v2
transform_train = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)),
])
else:
transform_train = transforms.Compose([
# transforms.RandomRotation(15),
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)),
])
if args.c:
transform_train.transforms.append(Cutout(n_holes=1, length=8))
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.507, 0.487, 0.441), (0.267, 0.256, 0.276)),
])
# CIFAR10 normalization for reference
# transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
trainset = torchvision.datasets.CIFAR100(root='./data',
train=True,
download=True,
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=128,
shuffle=True,
num_workers=2)
def __init__(self,
p1,
operation1,
magnitude_idx1,
p2,
operation2,
magnitude_idx2,
fillcolor=(128, 128, 128)):
cutout_op = Cutout(1, fillcolor)
ranges = {
"shearX": np.linspace(0, 0.3, 10),
"shearY": np.linspace(0, 0.3, 10),
"translateX": np.linspace(0, 150 / 331, 10),
"translateY": np.linspace(0, 150 / 331, 10),
"rotate": np.linspace(0, 30, 10),
"color": np.linspace(0.0, 0.9, 10),
"posterize": np.round(np.linspace(8, 4, 10), 0).astype(np.int),
"solarize": np.linspace(256, 0, 10),
"contrast": np.linspace(0.0, 0.9, 10),
"sharpness": np.linspace(0.0, 0.9, 10),
"brightness": np.linspace(0.0, 0.9, 10),
"autocontrast": [0] * 10,
"equalize": [0] * 10,
"invert": [0] * 10,
"cutout": [i * 2 for i in range(1, 11)] # from 2 to 20 pixel
}
# from https://stackoverflow.com/questions/5252170/specify-image-filling-color-when-rotating-in-python-with-pil-and-setting-expand
def rotate_with_fill(img, magnitude):
rot = img.convert("RGBA").rotate(magnitude)
return Image.composite(rot, Image.new("RGBA", rot.size,
(128, ) * 4),
rot).convert(img.mode)
func = {
"shearX":
lambda img, magnitude: img.transform(img.size,
Image.AFFINE,
(1, magnitude * random.choice(
[-1, 1]), 0, 0, 1, 0),
Image.BICUBIC,
fillcolor=fillcolor),
"shearY":
lambda img, magnitude: img.transform(img.size,
Image.AFFINE,
(1, 0, 0, magnitude * random.
choice([-1, 1]), 1, 0),
Image.BICUBIC,
fillcolor=fillcolor),
"translateX":
lambda img, magnitude: img.transform(
img.size,
Image.AFFINE, (1, 0, magnitude * img.size[0] * random.choice(
[-1, 1]), 0, 1, 0),
fillcolor=fillcolor),
"translateY":
lambda img, magnitude: img.transform(
img.size,
Image.AFFINE, (1, 0, 0, 0, 1, magnitude * img.size[1] * random.
choice([-1, 1])),
fillcolor=fillcolor),
"rotate":
lambda img, magnitude: rotate_with_fill(img, magnitude),
"color":
lambda img, magnitude: ImageEnhance.Color(img).enhance(
1 + magnitude * random.choice([-1, 1])),
"posterize":
lambda img, magnitude: ImageOps.posterize(img, magnitude),
"solarize":
lambda img, magnitude: ImageOps.solarize(img, magnitude),
"contrast":
lambda img, magnitude: ImageEnhance.Contrast(img).enhance(
1 + magnitude * random.choice([-1, 1])),
"sharpness":
lambda img, magnitude: ImageEnhance.Sharpness(img).enhance(
1 + magnitude * random.choice([-1, 1])),
"brightness":
lambda img, magnitude: ImageEnhance.Brightness(img).enhance(
1 + magnitude * random.choice([-1, 1])),
"autocontrast":
lambda img, magnitude: ImageOps.autocontrast(img),
"equalize":
lambda img, magnitude: ImageOps.equalize(img),
"invert":
lambda img, magnitude: ImageOps.invert(img),
'cutout':
lambda img, magnitutude: cutout_op(img, magnitutude)
}
self.p1 = p1
self.operation1 = func[operation1]
self.magnitude1 = ranges[operation1][magnitude_idx1]
self.p2 = p2
self.operation2 = func[operation2]
self.magnitude2 = ranges[operation2][magnitude_idx2]
softmax_targets = F.softmax(targets/3.0, dim=1)
return -(log_softmax_outputs * softmax_targets).sum(dim=1).mean()
def clip_grads(params):
params = list(
filter(lambda p: p.requires_grad and p.grad is not None, params))
if len(params) > 0:
return torch.nn.utils.clip_grad_norm_(params, max_norm=args.clip_grad, norm_type=2)
BATCH_SIZE = 128
LR = 0.1
transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4, fill=128),
transforms.RandomHorizontalFlip(), CIFAR10Policy(),
transforms.ToTensor(), Cutout(n_holes=1, length=16),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
trainset, testset = None, None
if args.class_num == 100:
print("dataset: CIFAR100")
trainset = torchvision.datasets.CIFAR100(
root='/home/lthpc/datasets/data',
train=True,
download=False,
transform=transform_train
def main():
global best_prec1
best_prec1 = 0
global val_acc
val_acc = []
global class_num
class_num = args.dataset == 'cifar10' and 10 or 100
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]])
if args.augment:
if args.autoaugment:
print('Autoaugment')
transform_train = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: F.pad(x.unsqueeze(0), (4, 4, 4, 4),
mode='reflect').squeeze()),
transforms.ToPILImage(),
transforms.RandomCrop(32),
transforms.RandomHorizontalFlip(),
CIFAR10Policy(),
transforms.ToTensor(),
Cutout(n_holes=args.n_holes, length=args.length),
normalize,
])
elif args.cutout:
print('Cutout')
transform_train = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: F.pad(x.unsqueeze(0), (4, 4, 4, 4),
mode='reflect').squeeze()),
transforms.ToPILImage(),
transforms.RandomCrop(32),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
Cutout(n_holes=args.n_holes, length=args.length),
normalize,
])
else:
print('Standrad Augmentation!')
transform_train = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: F.pad(x.unsqueeze(0), (4, 4, 4, 4),
mode='reflect').squeeze()),
transforms.ToPILImage(),
transforms.RandomCrop(32),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
else:
transform_train = transforms.Compose([
transforms.ToTensor(),
normalize,
])
transform_test = transforms.Compose([transforms.ToTensor(), normalize])
kwargs = {'num_workers': 1, 'pin_memory': True}
assert (args.dataset == 'cifar10' or args.dataset == 'cifar100')
train_loader = torch.utils.data.DataLoader(
datasets.__dict__[args.dataset.upper()]('../data',
train=True,
download=True,
transform=transform_train),
batch_size=training_configurations[args.model]['batch_size'],
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(
datasets.__dict__[args.dataset.upper()]('../data',
train=False,
transform=transform_test),
batch_size=training_configurations[args.model]['batch_size'],
shuffle=True,
**kwargs)
# create model
if args.model == 'resnet':
model = eval('networks.resnet.resnet' + str(args.layers) +
'_cifar')(dropout_rate=args.droprate)
elif args.model == 'se_resnet':
model = eval('networks.se_resnet.resnet' + str(args.layers) +
'_cifar')(dropout_rate=args.droprate)
elif args.model == 'wideresnet':
model = networks.wideresnet.WideResNet(args.layers,
args.dataset == 'cifar10' and 10
or 100,
args.widen_factor,
dropRate=args.droprate)
elif args.model == 'se_wideresnet':
model = networks.se_wideresnet.WideResNet(
args.layers,
args.dataset == 'cifar10' and 10 or 100,
args.widen_factor,
dropRate=args.droprate)
elif args.model == 'densenet_bc':
model = networks.densenet_bc.DenseNet(
growth_rate=args.growth_rate,
block_config=(int((args.layers - 4) / 6), ) * 3,
compression=args.compression_rate,
num_init_features=24,
bn_size=args.bn_size,
drop_rate=args.droprate,
small_inputs=True,
efficient=False)
elif args.model == 'shake_pyramidnet':
model = networks.shake_pyramidnet.PyramidNet(dataset=args.dataset,
depth=args.layers,
alpha=args.alpha,
num_classes=class_num,
bottleneck=True)
elif args.model == 'resnext':
if args.cardinality == 8:
model = networks.resnext.resnext29_8_64(class_num)
if args.cardinality == 16:
model = networks.resnext.resnext29_16_64(class_num)
elif args.model == 'shake_shake':
if args.widen_factor == 112:
model = networks.shake_shake.shake_resnet26_2x112d(class_num)
if args.widen_factor == 32:
model = networks.shake_shake.shake_resnet26_2x32d(class_num)
if args.widen_factor == 96:
model = networks.shake_shake.shake_resnet26_2x32d(class_num)
elif args.model == 'shake_shake_x':
model = networks.shake_shake.shake_resnext29_2x4x64d(class_num)
if not os.path.isdir(check_point):
mkdir_p(check_point)
fc = Full_layer(int(model.feature_num), class_num)
print('Number of final features: {}'.format(int(model.feature_num)))
print('Number of model parameters: {}'.format(
sum([p.data.nelement() for p in model.parameters()]) +
sum([p.data.nelement() for p in fc.parameters()])))
cudnn.benchmark = True
# define loss function (criterion) and optimizer
isda_criterion = ISDALoss(int(model.feature_num), class_num).cuda()
ce_criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(
[{
'params': model.parameters()
}, {
'params': fc.parameters()
}],
lr=training_configurations[args.model]['initial_learning_rate'],
momentum=training_configurations[args.model]['momentum'],
nesterov=training_configurations[args.model]['nesterov'],
weight_decay=training_configurations[args.model]['weight_decay'])
model = torch.nn.DataParallel(model).cuda()
fc = nn.DataParallel(fc).cuda()
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(
args.resume), 'Error: no checkpoint directory found!'
args.checkpoint = os.path.dirname(args.resume)
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
fc.load_state_dict(checkpoint['fc'])
optimizer.load_state_dict(checkpoint['optimizer'])
isda_criterion = checkpoint['isda_criterion']
val_acc = checkpoint['val_acc']
best_prec1 = checkpoint['best_acc']
np.savetxt(accuracy_file, np.array(val_acc))
else:
start_epoch = 0
for epoch in range(start_epoch,
training_configurations[args.model]['epochs']):
adjust_learning_rate(optimizer, epoch + 1)
# train for one epoch
train(train_loader, model, fc, isda_criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, fc, ce_criterion, epoch)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'fc': fc.state_dict(),
'best_acc': best_prec1,
'optimizer': optimizer.state_dict(),
'isda_criterion': isda_criterion,
'val_acc': val_acc,
},
is_best,
checkpoint=check_point)
print('Best accuracy: ', best_prec1)
np.savetxt(accuracy_file, np.array(val_acc))
print('Best accuracy: ', best_prec1)
print('Average accuracy', sum(val_acc[len(val_acc) - 10:]) / 10)
# val_acc.append(sum(val_acc[len(val_acc) - 10:]) / 10)
# np.savetxt(val_acc, np.array(val_acc))
np.savetxt(accuracy_file, np.array(val_acc))
def prepare(args):
global trainloader
global testloader
global net
global criterion
global optimizer
global scheduler
# Data
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
CIFAR10Policy(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
Cutout(n_holes=args.n_holes, length=args.length)
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
trainset = torchvision.datasets.CIFAR10(root='./data',
train=True,
download=True,
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=512,
shuffle=True,
num_workers=4)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=True,
transform=transform_test)
testloader = torch.utils.data.DataLoader(testset,
batch_size=512,
shuffle=False,
num_workers=4)
#classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# Model
print('==> Building model..')
net = CXH() #CXH_Squeeze_Excitation() #CXH()
if device == 'cuda':
net = torch.nn.DataParallel(net)
cudnn.benchmark = True
criterion = nn.CrossEntropyLoss()
# criterion = CrossEntropyLabelSmooth(10)
# optimizer = optim.SGD(net.parameters(), lr=0.1,
# momentum=0.9, weight_decay=5e-4)
optimizer = SAM(net.parameters(), torch.optim.SGD, lr=0.1, momentum=0.9)
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
optimizer, 1, 2)
