def __init__(self,
img_size: int,
original_size: int,
mean: float = 0,
std: float = 1,
brightness: float = 0.3,
contrast: float = 0.5,
saturation: float = 0.5,
hue: float = 0.3,
rotation_degree: int = 10,
hflip: float = 0.5,
debug: bool = False):
self.original_size = original_size
self.target_size = img_size
self.to_pil = transforms.ToPILImage()
self.color_jitter = transforms.ColorJitter(brightness=brightness,
contrast=contrast,
saturation=saturation,
hue=hue)
self.resize = transforms.Resize(img_size)
self.to_tensor = transforms.ToTensor()
self.normalize = transforms.Normalize(mean, std)
self.r_horizontal_flip = RandomHorizontalFlip(p=hflip)
self.r_rotation = RandomRotation(rotation_degree)
self.debug = debug
def get_transform(train=True, low=0.5, high=0.5):
transforms = []
transforms.append(T.ToTensor())
if train:
# transforms.append(T.Occlude((0, 1.0)))
pass
else:
# transforms.append(T.Occlude(low=low, high=high, color="black"))
transforms.append(T.ToPILImage())
return T.Compose(transforms)
def __init__(self, masked_paths: list, unmasked_paths: list,
tgt_size: tuple):
self.masked_paths = masked_paths
self.unmasked_paths = unmasked_paths
self.transform = T.Compose([
T.ToPILImage(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
T.Resize(tgt_size)
])
def get_transform(train=True):
transforms = []
transforms.append(T.ToTensor())
if train:
# transforms.append(T.Occlude((0, 1.0)))
pass
else:
# transforms.append(T.Occlude((0.4, 0.8)))
transforms.append(T.ToPILImage())
return T.Compose(transforms)
def save_mix_images(self, x_batch, epoch, batch_idx, end_epoch = 0, end_batch_idx = 5):
if epoch == end_epoch and batch_idx <= end_batch_idx:
for i in range(len(x_batch)):
unloader = transforms.ToPILImage()
image = x_batch[i].cpu().clone()
image = image.squeeze(0)
image = unloader(image)
out_dir = 'mix_results'
if not os.path.exists(out_dir):
os.makedirs(out_dir)
image.save('mix_results/results_{}_{}.jpg'.format(batch_idx, i))
def __init__(self, data_path, split, augment=True, load_everything=True, filename='cifar-10.npz'):
self.count = 0
file_path = os.path.join(data_path, filename)
full_data = np.load(file_path)
self.normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = [
# transforms.Scale(256),
# transforms.RandomCrop(224),
# transforms.RandomResizedCrop(224)
]
self.split = split
self.dataset = full_data['arr_0']
self.labels = full_data['arr_1']
if split == 'train':
if filename == 'cifar-10.npz':
self.dataset = self.dataset[:50000]
self.labels = self.labels[:50000]
self.dataset = self.dataset.reshape((50000, 3, 32, 32))
else:
if filename == 'cifar-10.npz':
self.dataset = full_data[50000:]
self.labels = self.labels[50000:]
self.dataset = self.dataset.reshape((10000, 3, 32, 32))
self.dataset = np.transpose(self.dataset, (0, 2, 3, 1))
print(self.dataset.shape)
# if augment:
# transform.extend([
# transforms.ColorJitter(brightness=0.1, contrast=0.0, saturation=0.3, hue=0.05),
# transforms.RandomHorizontalFlip(),
# # transforms.RandomVerticalFlip(),
# ])
transform += [transforms.ToTensor()]
# if augment:
# transform.append(
# affine_transforms.Affine(rotation_range=5.0, zoom_range=(0.85, 1.0), fill_mode='constant')
# )
# if augment:
# transform.append(
# affine_transforms.Affine(rotation_range=10.0, translation_range=0.1, zoom_range=(0.5, 1.0), fill_mode='constant')
# )
transform += [
self.normalize]
self.preprocess = transforms.Compose(transform)
self.to_image = transforms.ToPILImage()
def recover_img_to_PIL(image, mean, std):
"""
Inverse step of the [normalize, toTensor] step
Args:
image: tensor c * h * w
mean: list c
std: list c
return:
image: PILImage
"""
import transforms
for t, m, s in zip(image, mean, std):
t.mul_(s).add_(m)
return transforms.ToPILImage()(image)
batch_size=128,
shuffle=True,
num_workers=0)
PublicTestset = FER2013(split='PublicTest', transform=transform_test)
PublicTestloader = torch.utils.data.DataLoader(PublicTestset,
batch_size=128,
shuffle=False,
num_workers=0)
PrivateTestset = FER2013(split='PrivateTest', transform=transform_test)
PrivateTestloader = torch.utils.data.DataLoader(PrivateTestset,
batch_size=128,
shuffle=False,
num_workers=0)
dataiter = iter(trainloader)
imgs, labels = next(dataiter)
unloader = transforms.ToPILImage()
print(np.shape(imgs))
print(np.shape(labels))
image = unloader(imgs[0])
plt.imshow(image)
plt.pause(0.3)
Modell = VGG('VGG19')
Modell.load_state_dict(
torch.load('./FER2013_VGG19/PublicTest_model.t7',
map_location='cpu')['net'])
Returnnn = perturb(imgs, labels, 0.2, Modell=Modell)
Returnnn = torch.Tensor(Returnnn)
image = unloader(Returnnn[0])
def main(**kwargs):
test_path = kwargs.get('test_data_path')
submission_file_path = kwargs.get('submission_file_path')
idlookup_file_path = kwargs.get('idlookup_file_path')
checkpoint_path = kwargs.get('checkpoint_path')
backbone_name = kwargs.get('backbone')
num_classes = kwargs.get('num_classes')
device = kwargs.get('device')
batch_size = kwargs.get('batch_size')
# TODO give trained mean and std
mean = 0
std = 1
original_img_size = 96
submission_df = pd.read_csv(submission_file_path)
idlookup_df = pd.read_csv(idlookup_file_path)
backbone = get_backbone(backbone_name)
model = FacialKeypointsDetector(backbone,
device=device,
num_classes=num_classes)
transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(model.get_input_size()),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
dataset = get_test_dataset(root_path=test_path, transform=transform)
dl = torch.utils.data.DataLoader(dataset,
num_workers=4,
batch_size=batch_size,
pin_memory=True,
collate_fn=custom_collate_fn)
load_model(model, checkpoint_path)
predictions = {}
for imgs, img_ids in tqdm(dl, total=len(dl.dataset) // batch_size):
# {img_id:{'loc1':pred}}
preds = model.predict(imgs) * original_img_size
preds = torch.clamp(preds, min=0, max=original_img_size)
for img_idx, pred in zip(img_ids, preds.cpu().numpy().tolist()):
predictions[img_idx] = {}
for label, location in zip(labels, pred):
predictions[img_idx][label] = location
locations = []
row_ids = []
for s, lookup in zip(submission_df.iterrows(), idlookup_df.iterrows()):
s = s[1]
lookup = lookup[1]
# RowId,Location
s = json.loads(s.to_json())
# RowId,ImageId,FeatureName,Location
lookup = json.loads(lookup.to_json())
img_idx = lookup['ImageId']
feature = lookup['FeatureName']
row_id = s['RowId']
location = predictions[img_idx][feature]
locations.append(location)
row_ids.append(row_id)
new_submission_df = pd.DataFrame(data={
'RowId': row_ids,
'Location': locations
})
submissin_dir_path = os.path.dirname(submission_file_path)
new_submission_file_path = os.path.join(submissin_dir_path,
'submission.csv')
print(new_submission_df.head())
new_submission_df.to_csv(new_submission_file_path, index=False, header=1)
def main():
global args, best_prec1
args = parser.parse_args()
# torch.cuda.set_device(args.gpu)
if args.tensorboard:
print("Using TensorBoard")
configure("exp/%s" % (args.name))
# Data loading code
if args.augment:
transform_train = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: F.pad(
Variable(x.unsqueeze(0), requires_grad=False, volatile=True),
(4, 4, 4, 4),
mode='replicate').data.squeeze()),
transforms.ToPILImage(),
transforms.RandomCrop(32),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
])
else:
transform_train = transforms.Compose([
transforms.ToTensor(),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
])
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=args.batch_size,
shuffle=True,
**kwargs)
val_loader = torch.utils.data.DataLoader(
datasets.__dict__[args.dataset.upper()]('../data',
train=False,
transform=transform_test),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
# create model
model = WideResNetMulti(args.layers,
args.dataset == 'cifar10' and 10 or 100,
args.num_rotate_classes,
args.widen_factor,
dropRate=args.droprate)
# get the number of model parameters
print('Number of model parameters: {}'.format(
sum([p.data.nelement() for p in model.parameters()])))
# for training on multiple GPUs.
# Use CUDA_VISIBLE_DEVICES=0,1 to specify which GPUs to use
# model = torch.nn.DataParallel(model).cuda()
model = model.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
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
nesterov=args.nesterov,
weight_decay=args.weight_decay)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch + 1)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, 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(),
'best_prec1': best_prec1,
}, is_best)
print 'Best accuracy: ', best_prec1
def from_image(cls, img, sr_factor):
pil = transforms.ToPILImage()(transforms.ToTensor()(img))
return ZSSRDataset(pil, sr_factor)
def main(**kwargs):
training_path = kwargs.get('training_data_path')
checkpoint_path = kwargs.get('checkpoint_path')
tensorboard_log_dir = kwargs.get('tensorboard_log_dir')
if not os.path.isdir(checkpoint_path):
os.mkdir(checkpoint_path)
backbone_name = kwargs.get('backbone')
criterion_name = kwargs.get('criterion').upper()
optimizer_name = kwargs.get('optimizer').upper()
scheduler = kwargs.get('scheduler',None)
pretrained = kwargs.get('pretrained')
num_classes = kwargs.get('num_classes')
device = kwargs.get('device')
batch_size = kwargs.get('batch_size')
epochs = kwargs.get('epochs')
hyperparameters = kwargs.get('hyperparameters',{})
augmentations = kwargs.get('augmentations',{})
verbose = kwargs.get('verbose')
train_split = kwargs.get('train_split')
nfolds = kwargs.get('nfolds')
val_splits = [(1-train_split) / nfolds] * nfolds
resume = kwargs.get('resume')
only_weights = kwargs.get('only_weights')
seed = hyperparameters.get('seed')
random_jitter = augmentations.get('jitter',{})
random_horizontal_flip = augmentations.get('horizontal_flip', 0.5)
random_rotation = augmentations.get('rotation', 20)
writer = SummaryWriter(log_dir=tensorboard_log_dir, flush_secs=20)
if seed: seed_everything(seed)
# TODO calculate mean and std
mean = hyperparameters.get('mean',0)
std = hyperparameters.get('std',1)
splits = [train_split]+val_splits
assert sum(splits) <= 1,"given splits must be lower or equal than 1"
original_img_size = 96
criterion = get_criterion(criterion_name)
backbone = get_backbone(backbone_name, pretrained=pretrained)
model = FacialKeypointsDetector(backbone, criterion=criterion,
device=device, num_classes=num_classes)
optimizer = get_optimizer(optimizer_name, model.parameters(),
kwargs=hyperparameters.get('optimizer',{}))
scaler = GradScaler()
val_transforms = None
val_target_transform = TargetTransform(original_img_size)
train_transform = train_target_transform = None
train_transforms = transforms.TrainTransforms(model.get_input_size(), original_img_size,
mean=mean, std=std, brightness=random_jitter.get('brightness'),
contrast=random_jitter.get('contrast'), saturation=random_jitter.get('saturation'),
hue=random_jitter.get('hue'), rotation_degree=random_rotation,
hflip=random_horizontal_flip)
val_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(model.get_input_size()),
transforms.ToTensor(),
transforms.Normalize(mean,std)])
train_dataset,*val_datasets = get_training_datasets(root_path=training_path,
train_transforms=(train_transforms,train_transform,train_target_transform),
val_transforms=(val_transforms,val_transform,val_target_transform),
split_ratios=splits)
val_dls = []
train_dl = torch.utils.data.DataLoader(train_dataset,
num_workers=4, batch_size=batch_size,
pin_memory=True, collate_fn=custom_collate_fn, shuffle=True)
for val_ds in val_datasets:
val_dls.append( torch.utils.data.DataLoader(
val_ds, batch_size=batch_size, num_workers=2) )
current_epoch = 0
best_loss = math.inf
if resume:
print(Fore.CYAN, f"loading checkpoint from {checkpoint_path}",Style.RESET_ALL)
best_loss,current_epoch = load_checkpoint(model, optimizer, scheduler=scheduler,
save_path=checkpoint_path, suffix='last', only_weights=only_weights)
try:
for epoch in range(current_epoch,epochs):
training_loop(train_dl, model, epoch, epochs, optimizer, writer,scaler,
scheduler=scheduler, verbose=verbose)
val_losses = []
for i,val_dl in enumerate(val_dls):
val_loss = validation_loop(val_dl, model)
val_losses.append(val_loss)
print(Fore.LIGHTBLUE_EX, f"validation [{i+1}] loss: {val_loss:.07f}",Style.RESET_ALL)
writer.add_scalar(f'Loss/val_{i+1}', val_loss, epoch)
mean_val_loss = sum(val_losses) / len(val_losses)
print(Fore.LIGHTBLUE_EX, f"validation [mean] loss: {mean_val_loss:.07f}",Style.RESET_ALL)
writer.add_scalar(f'Loss/val_mean', mean_val_loss, epoch)
writer.flush()
if mean_val_loss < best_loss:
best_loss = mean_val_loss
print(Fore.CYAN, "saving best checkpoint...",Style.RESET_ALL)
save_checkpoint(model,optimizer,epoch,best_loss,
scheduler=scheduler, suffix='best', save_path=checkpoint_path)
print(Fore.CYAN, "saving last checkpoint...",Style.RESET_ALL)
save_checkpoint(model,optimizer,epoch,best_loss,
scheduler=scheduler, suffix='last', save_path=checkpoint_path)
except KeyboardInterrupt:
print(Fore.RED, "training interrupted with ctrl+c saving current state of the model",Style.RESET_ALL)
save_checkpoint(model,optimizer,epoch,best_loss,
scheduler=scheduler, suffix='last', save_path=checkpoint_path)
writer.close()
def train_each_teacher(num_epoch, train_data, train_label, test_data,
test_label, save_path):
torch.manual_seed(config.seed)
print('len of train_data in network', len(train_data))
os.environ['CUDA_VISIBLE_DEVICES'] = config.gpu_devices
print('it is training now')
use_gpu = torch.cuda.is_available()
if config.use_cpu: use_gpu = False
print('whether evaluate', config.evaluate)
if use_gpu:
print("Currently using GPU {}".format(config.gpu_devices))
cudnn.benchmark = True
torch.cuda.manual_seed_all(config.seed)
else:
print("Currently using CPU (GPU is highly recommended)")
if config.dataset == 'mnist':
transform_train = T.Compose([
T.Random2DTranslation(config.height, config.width),
#T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.1307], std=[0.3081]),
])
transform_test = T.Compose([
T.Resize((config.height, config.width)),
T.ToTensor(),
T.Normalize(mean=[0.1307], std=[0.3081]),
])
else:
transform_train = T.Compose([
#T.Random2DTranslation(config.height, config.width),
T.ToPILImage(),
T.RandomCrop(32, padding=4),
T.RandomHorizontalFlip(),
T.ToTensor(),
#T.Resize(32),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
transform_test = T.Compose([
T.ToPILImage(),
#T.Resize(32),
#T.Resize((config.height, config.width,3)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
pin_memory = True if use_gpu else False
print('train_data', len(train_data), 'train_label', len(train_label))
trainloader = DataLoader(
ImageDataset(train_data, label=train_label, transform=transform_train),
batch_size=config.train_batch,
shuffle=True,
num_workers=config.workers,
pin_memory=pin_memory,
drop_last=True,
)
testloader = DataLoader(
ImageDataset(test_data, label=test_label, transform=transform_test),
batch_size=config.test_batch,
shuffle=False,
num_workers=config.workers,
pin_memory=pin_memory,
drop_last=False,
)
model = models.init_model(name=config.arch,
num_classes=config.nb_labels,
loss={'xent'},
use_gpu=use_gpu)
if use_gpu:
model = nn.DataParallel(model).cuda()
criterion = torch.nn.CrossEntropyLoss()
#optimizer = init_optim(config.optim, model.parameters(), config.lr, config.weight_decay)
#if config.stepsize > 0:
# scheduler = lr_scheduler.StepLR(optimizer, step_size=config.stepsize, gamma=config.gamma)
print("==> Start training")
start_time = time.time()
for epoch in range(num_epoch):
optimizer = optim.SGD(model.parameters(),
lr=learning_rate(config.lr, epoch),
momentum=0.9,
weight_decay=0.0005)
print('\n=> Training Epoch #%d, LR=%.4f' %
(epoch, learning_rate(config.lr, epoch)))
train(epoch, model, criterion, optimizer, trainloader, use_gpu)
#if config.stepsize > 0: scheduler.step()
rank1 = test(model, testloader, use_gpu)
rank1 = test(model, testloader, use_gpu)
if use_gpu:
state_dict = model.module.state_dict()
else:
state_dict = model.state_dict()
print('save model', save_path)
torch.save(state_dict, save_path)
#print("==> Hamming Score {:.3%}".format(rank1))
elapsed = round(time.time() - start_time)
print("Finished. Training time (h:m:s): {}.".format(elapsed))
def pred(data, save_path, return_feature=False):
torch.manual_seed(config.seed)
os.environ['CUDA_VISIBLE_DEVICES'] = config.gpu_devices
use_gpu = torch.cuda.is_available()
if config.use_cpu: use_gpu = False
if use_gpu:
print("Currently using GPU {}".format(config.gpu_devices))
cudnn.benchmark = True
torch.cuda.manual_seed_all(config.seed)
else:
print("Currently using CPU (GPU is highly recommended)")
if config.dataset == 'mnist':
transform_test = T.Compose([
T.Resize((config.height, config.width)),
T.ToTensor(),
T.Normalize(mean=[0.1307], std=[0.3081]),
])
else:
transform_test = T.Compose([
T.ToPILImage(),
T.Resize((config.height, config.width)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
pin_memory = True if use_gpu else False
testloader = DataLoader(
ImageDataset(data, transform=transform_test),
batch_size=512,
shuffle=False,
num_workers=config.workers,
pin_memory=pin_memory,
drop_last=False,
)
model = models.init_model(name=config.arch,
num_classes=config.nb_labels,
loss={'xent'},
use_gpu=use_gpu)
checkpoint = torch.load(save_path)
model.load_state_dict(checkpoint)
if use_gpu:
model = nn.DataParallel(model).cuda()
model.eval()
with torch.no_grad():
hamming_score, pred_list, feature_list = [], [], []
float_logit_list = []
for batch_idx, (imgs) in enumerate(testloader):
if use_gpu:
imgs = imgs.cuda()
if batch_idx % 50 == 0:
print('batch {}/{}', batch_idx, len(testloader))
end = time.time()
features, predA = model(imgs)
predA = predA.cpu()
#print('features shape {} predA shape'.format(features.shape, predA.shape))
float_logit_list.append(torch.sigmoid(predA))
if return_feature is True:
feature_list.append(features.cpu())
_, predicted = torch.max(predA.data, 1)
#print('predAs', predicted)
pred_list.append(predicted)
predA_t = (((torch.cat(pred_list, 0)).float()).numpy()).tolist()
predA_t = np.array(predA_t)
#float_logit_list = (((torch.cat(float_logit_list, 0)).float()).numpy()).tolist()
#float_logit_list = np.array(float_logit_list)
if return_feature == True:
feature_list = (((torch.cat(feature_list,
0)).float()).numpy()).tolist()
feature_list = np.array(feature_list)
return feature_list
return predA_t
else:
return predA_t
def detect_mask(self):
# detect whether the face is wearing a mask
box = self.box.astype(np.int)
people_size = abs(box[2] - box[0]) * abs(box[3] - box[1])
# model_mask.eval()
# prepare face slice data
global_face_loc = (self.face_loc).astype(np.int)
box = global_face_loc
face_size = abs(box[2] - box[0]) * abs(box[3] - box[1])
# if (face_size/people_size > 1):
# model_mask = self.model_mask[1]
# use_soft = True
# else:
# model_mask = self.model_mask[0]
# use_soft = False
# print(global_face_loc)
img = self.frame_orig
face_slice = img[global_face_loc[1]:global_face_loc[3],
global_face_loc[0]:global_face_loc[2], :]
# face_slice = np.floor(face_slice * 255).astype(np.uint8)
face_slice = face_slice.astype(np.uint8)
size_grads = [14, 28, 56, 112, 224]
def argmin_dist(img_size) -> int:
H, W = img_size
min_dist = 2**32
out_size = None
for size_cand in size_grads:
cur_dist = abs(H - size_cand) + abs(W - size_cand)
if min_dist > cur_dist:
out_size = size_cand
min_dist = cur_dist
return out_size
if min(face_slice.shape[:2]) < 40:
out_size = 4 * argmin_dist(face_slice.shape[:2])
model_mask = self.model_mask[1] # use small face model
else:
out_size = argmin_dist(face_slice.shape[:2])
model_mask = self.model_mask[0] # use big face model
# out_size = argmin_dist(face_slice.shape[:2])
# if out_size==14 or out_size==28:
# # model_mask = self.model_mask[1] # use small face model
# out_size = 4*out_size
# else:
# # model_mask = self.model_mask[0] # use large face model
# out_size = out_size
# model_mask = self.model_mask[0] # use large face model only
transformations = T.Compose([
T.ToPILImage(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
T.Resize((out_size, out_size))
])
# transformations = Compose([
# ToPILImage(),
# Resize(256),
# CenterCrop(224),
# ToTensor(),
# Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225]),
# ])
# soft = Softmax()
# if use_soft:
# prob_mask = soft(model_mask(transformations(face_slice).unsqueeze(0).to(device)))[0,1] # probability of wearing a mask
#else:
soft = nn.Softmax(dim=1)
prob_mask = soft(
model_mask(transformations(face_slice).unsqueeze(0).to(device)))[0,
1]
prob_mask = prob_mask.data.cpu().numpy()
#print(prob_mask)
return prob_mask
transforms.Lambda(lambda x: x[torch.LongTensor([2, 1, 0])]), # turn to BGR
transforms.Normalize(
mean=[0.40760392, 0.45795686, 0.48501961],
# subtract imagenet mean
std=[1, 1, 1]),
transforms.Lambda(lambda x: x.mul_(255)),
])
postpa = transforms.Compose([
transforms.Lambda(lambda x: x.mul_(1. / 255)),
transforms.Normalize(
mean=[-0.40760392, -0.45795686, -0.48501961], # add imagenet mean
std=[1, 1, 1]),
transforms.Lambda(lambda x: x[torch.LongTensor([2, 1, 0])]), # turn to RGB
])
mask_tf = transforms.Compose([ToUnNormalizedTensor()])
postpb = transforms.Compose([transforms.ToPILImage()])
def postp(tensor): # to clip results in the range [0,1]
t = post_tensor(tensor)
img = postpb(t)
return img
# return t
def post_tensor(tensor):
t = postpa(tensor)
t[t > 1] = 1
t[t < 0] = 0
return t
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 get_transform_eval():
transforms = []
transforms.append(T.ToTensor())
transforms.append(T.ToPILImage())
return T.Compose(transforms)
