def __init__(self,
dataset_dir,
images_path,
list=[],
numpatches=900,
numneg=3,
pos_thr=50.0,
reject=True,
mode='train',
rejection_radius=3000,
dist_type='3D',
patch_radius=None,
use_depth=False,
use_normals=False,
use_silhouettes=False,
color_jitter=False,
greyscale=False,
maxres=4096,
scale_jitter=False,
photo_jitter=False,
uniform_negatives=False,
needles=0,
render_only=False):
"""Loads the patches dataset.
@param dataset_dir String directory where the dataset of sampled
points is located
@param images_path path to the images to sample patches from
@param list List of subdirectory names to be loaded with this
loader. Use this to specify train/test/val splits.
@param numneg Int number of generated negatives per positive pair.
@param pos_thr Float threshold in meters used to define negatives.
If the distance of two 3D points exceeds this threshold, the
correspondence is considered negative. The lower the threshold, the
harder the negatives are.
@param reject [bool] True turns on rejetion sampling - for each
patch we calculate density of 3D reprojected point cloud within 1km
radius. Then the probability of rejection is calculated as
num_points_1km_radius/max_num_points, where max_num_points is
maximum taken across all queried samples until the current one.
@param mode options: train|eval, default: train. If train is used,
then the additional metadata per patch (which are used for some
plots during validation are not generated and therefore the training
shall be faster.
@type string
@param dist_type type of the distance used to generate positives and
negatives. Can be `2D` or `3D`. Default: 3D.
@type int
@param patch_radius when set to None, the patch radius will be
loaded from the patches dataset. Otherwise the defined patch radius
will be used. Please note that if you use larger patch_radius than
the one defined within the patches dataset, the source image will be
padded automatically and so the patch may contain black edges.
@param needles If number greater than zero is used, then instead of
a single patch a whole needle of patches will be extracted. Our
network then takes several patches in a form of a needle encoded to
channels of the input. This approach is described here:
Lotan and Irani: Needle-Match: Reliable Patch Matching under
High Uncertainty, CVPR 2016.
"""
self.item_idx = -1
self.dataset_dir = dataset_dir
self.images_path = images_path
self.numneg = numneg
self.pos_thr = pos_thr
self.loaded_imgs_pts = []
self.all_coords3d = []
self.max_num_points = 0
self.reject = reject
self.query_radius = rejection_radius
self.dist_type = dist_type
self.use_depth = use_depth
self.use_normals = use_normals
self.use_silhouettes = use_silhouettes
self.color_jitter = color_jitter
self.greyscale = greyscale
self.left_maxres = maxres
self.right_maxres = maxres
self.scale_jitter = scale_jitter
self.photo_jitter = photo_jitter
self.uniform_negatives = uniform_negatives
self.needles = needles
self.render_only = render_only
scene_info_file = os.path.join(os.path.dirname(images_path),
"scene_info.txt")
self.scene_center = MultimodalPatchesDataset.getSceneCenter(
scene_info_file)
self.numch_1 = 3
self.numch_2 = 3
if self.greyscale:
self.numch_1 = 1
self.numch_2 = 1
if self.use_depth:
self.numch_2 += 1
if self.use_normals:
self.numch_2 += 3
if self.use_silhouettes:
self.numch_2 += 1
self.transform = transforms.Compose([
transforms.ToPILImage(),
transforms.ColorJitter(0.5, 0.5, 1.0, 0.5),
transforms.ToTensor()
])
print("Rejection radius: ", self.query_radius, "mode", mode)
self.mode = mode
if len(list) == 0:
self.dataset_items = [
d for d in os.listdir(self.dataset_dir)
if os.path.isdir(os.path.join(self.dataset_dir, d))
]
else:
self.dataset_items = []
if self.mode == 'eval':
# choose only pairs where left view does not repeat
print("Choosing non-repeating photographs for validation...")
keyset = set()
for item in tqdm(list):
item_path = os.path.join(self.dataset_dir, item)
info_path = os.path.join(item_path, "info.npy")
info = np.load(info_path,
encoding='latin1',
allow_pickle=True).flatten()[0]
img1_base = os.path.basename(info['img1_name'])
key = os.path.splitext(img1_base)[0]
if key in keyset:
continue
keyset.add(key)
self.dataset_items.append(item)
else:
self.dataset_items = list
if (len(self.dataset_items) > 0):
item_path = os.path.join(self.dataset_dir, self.dataset_items[0])
info_path = os.path.join(item_path, "info.npy")
self.info = np.load(info_path,
encoding='latin1',
allow_pickle=True).flatten()[0]
self.numpatches = self.info['coords2d_1'].shape[0]
if patch_radius is not None:
self.patch_radius = patch_radius
else:
self.patch_radius = self.info['patch_radius']
if numpatches != self.numpatches:
raise RuntimeError("Wrong number of patches in the first \
item of the dataset. Expected: " + str(numpatches) +
", obtained: " + str(self.numpatches))
self.load3DPoints()
self.kdt = KDTree(self.all_coords3d[:, :3],
leaf_size=40,
metric='euclidean')
translation_frac = np.sqrt(5) / (self.patch_radius * 2
) # at most 5px
self.photo_transform = transforms.Compose([
transforms.ToPILImage(),
transforms.ColorJitter(0.2, (0.9, 1.001), 0.2, 0.2),
transforms.RandomAffine(22.5,
(translation_frac, translation_frac),
shear=5),
transforms.CenterCrop(self.patch_radius * 2),
transforms.ToTensor()
])
if self.photo_jitter:
self.prcoef = 1.25
else:
self.prcoef = 1
# FIXME: remove since this is unneeded for training and is slow. Just for research.
#self.saveDensityPointcloud()
else:
raise RuntimeError("No dataset items at specified location.")
learning_rate = 1e-4
batch_size = 64
num_epochs = 5
# Load pretrain model & modify it
model = CNN(in_channels=3, num_classes=10)
model.classifier = nn.Sequential(nn.Linear(512, 100), nn.ReLU(),
nn.Linear(100, 10))
model.to(device)
# Load Data
my_transforms = transforms.Compose(
[ #Compose makes it possible to have many transforms
transforms.Resize((36, 36)), # Resizes (32,32) to (36,36)
transforms.RandomCrop((32, 32)), # Takes a random (32,32) crop
transforms.ColorJitter(brightness=0.5), # Change brightness of image
transforms.RandomRotation(
degrees=45), # Perhaps a random rotation from -45 to 45 degrees
transforms.RandomHorizontalFlip(
p=0.5), # Flips the image horizontally with probability 0.5
transforms.RandomVerticalFlip(
p=0.05), # Flips image vertically with probability 0.05
transforms.RandomGrayscale(
p=0.2), # Converts to grayscale with probability 0.2
transforms.ToTensor(
), # Finally converts PIL image to tensor so we can train w. pytorch
transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5,
0.5]) # Note: these values aren't optimal
])
import torch
import torchvision
from torchvision import transforms
import matplotlib.pyplot as plt
train_data_path = './train'
transforms = transforms.Compose([
transforms.Resize([64, 64]),
transforms.ColorJitter(brightness=(0.2, 1),
contrast=(0, 1),
saturation=(0, 1),
hue=0.1),
transforms.ToTensor()
])
train_data = torchvision.datasets.ImageFolder(root=train_data_path,
transform=transforms)
if __name__ == "__main__":
train_data = iter(train_data)
img, _ = next(train_data)
plt.figure()
plt.imshow(img.permute(1, 2, 0))
plt.show()
def main():
args = get_args()
# Log
log_format = '[%(asctime)s] %(message)s'
logging.basicConfig(stream=sys.stdout,
level=logging.INFO,
format=log_format,
datefmt='%d %I:%M:%S')
t = time.time()
local_time = time.localtime(t)
if not os.path.exists('./log'):
os.mkdir('./log')
fh = logging.FileHandler(
os.path.join('log/train-{}{:02}{}'.format(local_time.tm_year % 2000,
local_time.tm_mon, t)))
fh.setFormatter(logging.Formatter(log_format))
logging.getLogger().addHandler(fh)
use_gpu = False
if torch.cuda.is_available():
use_gpu = True
assert os.path.exists(args.train_dir)
train_dataset = datasets.ImageFolder(
args.train_dir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ColorJitter(brightness=0.4,
contrast=0.4,
saturation=0.4),
transforms.RandomHorizontalFlip(0.5),
ToBGRTensor(),
]))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=1,
pin_memory=use_gpu)
train_dataprovider = DataIterator(train_loader)
assert os.path.exists(args.val_dir)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
args.val_dir,
transforms.Compose([
OpencvResize(256),
transforms.CenterCrop(224),
ToBGRTensor(),
])),
batch_size=200,
shuffle=False,
num_workers=1,
pin_memory=use_gpu)
val_dataprovider = DataIterator(val_loader)
print('load data successfully')
model = ShuffleNetV2_MetaACON(model_size=args.model_size)
optimizer = torch.optim.SGD(get_parameters(model),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1)
if use_gpu:
model = nn.DataParallel(model)
loss_function = criterion_smooth.cuda()
device = torch.device("cuda")
else:
loss_function = criterion_smooth
device = torch.device("cpu")
scheduler = torch.optim.lr_scheduler.LambdaLR(
optimizer,
lambda step: (1.0 - step / args.total_iters)
if step <= args.total_iters else 0,
last_epoch=-1)
model = model.to(device)
all_iters = 0
if args.auto_continue:
lastest_model, iters = get_lastest_model()
if lastest_model is not None:
all_iters = iters
checkpoint = torch.load(lastest_model,
map_location=None if use_gpu else 'cpu')
model.load_state_dict(checkpoint['state_dict'], strict=True)
print('load from checkpoint')
for i in range(iters):
scheduler.step()
args.optimizer = optimizer
args.loss_function = loss_function
args.scheduler = scheduler
args.train_dataprovider = train_dataprovider
args.val_dataprovider = val_dataprovider
if args.eval:
if args.eval_resume is not None:
checkpoint = torch.load(args.eval_resume,
map_location=None if use_gpu else 'cpu')
load_checkpoint(model, checkpoint)
validate(model, device, args, all_iters=all_iters)
exit(0)
while all_iters < args.total_iters:
all_iters = train(model,
device,
args,
val_interval=args.val_interval,
bn_process=False,
all_iters=all_iters)
validate(model, device, args, all_iters=all_iters)
validate(model, device, args, all_iters=all_iters)
save_checkpoint({
'state_dict': model.state_dict(),
},
args.total_iters,
tag='bnps-')
transform_val_list = [
transforms.Resize(size=(384, 192), interpolation=3), #Image.BICUBIC
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]
#如果使用随机擦除
if opt.erasing_p > 0:
transform_train_list = transform_train_list + [
RandomErasing(probability=opt.erasing_p, mean=[0.0, 0.0, 0.0])
]
#如果使用颜色抖动
if opt.color_jitter:
transform_train_list = [
transforms.ColorJitter(
brightness=0.1, contrast=0.1, saturation=0.1, hue=0)
] + transform_train_list
print(transform_train_list)
#相当于一个字典，‘train’映射到训练，‘val’映射到验证
data_transforms = {
'train': transforms.Compose(transform_train_list),
'val': transforms.Compose(transform_val_list),
}
train_all = ''
if opt.train_all:
train_all = '_all'
image_datasets = {}
def __init__(self, args, partition='train', pretrain=True, is_sample=False, k=4096,
transform=None):
super(Dataset, self).__init__()
self.data_root = args.data_root
self.partition = partition
self.data_aug = args.data_aug
self.mean = [0.5071, 0.4867, 0.4408]
self.std = [0.2675, 0.2565, 0.2761]
self.normalize = transforms.Normalize(mean=self.mean, std=self.std)
self.pretrain = pretrain
if transform is None:
if self.partition == 'train' and self.data_aug:
self.transform = transforms.Compose([
lambda x: Image.fromarray(x),
transforms.RandomCrop(32, padding=4),
transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
transforms.RandomHorizontalFlip(),
lambda x: np.asarray(x),
transforms.ToTensor(),
self.normalize
])
else:
self.transform = transforms.Compose([
lambda x: Image.fromarray(x),
transforms.ToTensor(),
self.normalize
])
else:
self.transform = transform
if self.pretrain:
self.file_pattern = '%s.pickle'
else:
self.file_pattern = '%s.pickle'
self.data = {}
with open(os.path.join(self.data_root, self.file_pattern % partition), 'rb') as f:
data = pickle.load(f, encoding='latin1')
self.imgs = data['data']
labels = data['labels']
# adjust sparse labels to labels from 0 to n.
cur_class = 0
label2label = {}
for idx, label in enumerate(labels):
if label not in label2label:
label2label[label] = cur_class
cur_class += 1
new_labels = []
for idx, label in enumerate(labels):
new_labels.append(label2label[label])
self.labels = new_labels
self.label_map = {y: x for x, y in label2label.items()}
# pre-process for contrastive sampling
self.k = k
self.is_sample = is_sample
if self.is_sample:
self.labels = np.asarray(self.labels)
self.labels = self.labels - np.min(self.labels)
num_classes = np.max(self.labels) + 1
self.cls_positive = [[] for _ in range(num_classes)]
for i in range(len(self.imgs)):
self.cls_positive[self.labels[i]].append(i)
self.cls_negative = [[] for _ in range(num_classes)]
for i in range(num_classes):
for j in range(num_classes):
if j == i:
continue
self.cls_negative[i].extend(self.cls_positive[j])
self.cls_positive = [np.asarray(self.cls_positive[i]) for i in range(num_classes)]
self.cls_negative = [np.asarray(self.cls_negative[i]) for i in range(num_classes)]
self.cls_positive = np.asarray(self.cls_positive)
self.cls_negative = np.asarray(self.cls_negative)
def dataloader(dataset, batch_size, train, workers, length=None):
# Dataset
if dataset == 'mnist':
mean, std = (0.1307, ), (0.3081, )
transform = get_transform(size=28,
padding=0,
mean=mean,
std=std,
preprocess=False)
dataset = datasets.MNIST('Data',
train=train,
download=True,
transform=transform)
if dataset == 'cifar10':
mean, std = (0.491, 0.482, 0.447), (0.247, 0.243, 0.262)
transform = get_transform(size=32,
padding=4,
mean=mean,
std=std,
preprocess=train)
dataset = datasets.CIFAR10('Data',
train=train,
download=True,
transform=transform)
if dataset == 'cifar100':
mean, std = (0.507, 0.487, 0.441), (0.267, 0.256, 0.276)
transform = get_transform(size=32,
padding=4,
mean=mean,
std=std,
preprocess=train)
dataset = datasets.CIFAR100('Data',
train=train,
download=True,
transform=transform)
if dataset == 'tiny-imagenet':
mean, std = (0.480, 0.448, 0.397), (0.276, 0.269, 0.282)
transform = get_transform(size=64,
padding=4,
mean=mean,
std=std,
preprocess=train)
dataset = custom_datasets.TINYIMAGENET('Data',
train=train,
download=True,
transform=transform)
if dataset == 'imagenet':
mean, std = (0.485, 0.456, 0.406), (0.229, 0.224, 0.225)
if train:
transform = transforms.Compose([
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomGrayscale(p=0.2),
transforms.ColorJitter(0.4, 0.4, 0.4, 0.4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
else:
transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
folder = 'Data/imagenet_raw/{}'.format('train' if train else 'val')
dataset = datasets.ImageFolder(folder, transform=transform)
# Dataloader
use_cuda = torch.cuda.is_available()
kwargs = {'num_workers': workers, 'pin_memory': True} if use_cuda else {}
shuffle = train is True
if length is not None:
indices = torch.randperm(len(dataset))[:length]
dataset = torch.utils.data.Subset(dataset, indices)
dataloader = torch.utils.data.DataLoader(dataset=dataset,
batch_size=batch_size,
shuffle=shuffle,
**kwargs)
return dataloader
import torch
import torchvision.transforms as tfms
from torchvision.utils import save_image
from image_dataset import CatsAndDogsDataset
import matplotlib.pyplot as plt
transforms = tfms.Compose([
tfms.ToPILImage(),
tfms.Resize((256, 256)),
tfms.RandomCrop((224, 224)),
tfms.ColorJitter(),
tfms.RandomRotation(degrees=45),
tfms.RandomGrayscale(p=0.2),
tfms.RandomHorizontalFlip(p=0.5), #flip image horizontal
tfms.RandomVerticalFlip(p=0.05),
tfms.ToTensor(),
tfms.Normalize(mean=[0.0, 0.0, 0.0], std=[1.0, 1.0,
1.0]), # (pixel - mean) / std
#for each channel we need to
#find mean and std across all pixel values
])
dataset = CatsAndDogsDataset(csv_path='./input/image_aug/cats_dogs.csv',
root_dir='./input/image_aug',
transform=transforms)
for i, (img, label) in enumerate(dataset):
print(img.shape)
save_image(img, f"./input/image_aug/my_aug/img_{i}.png")
plt.imshow(img.permute([1, 2, 0]))
plt.show()
def main():
"""main."""
args = parse_args()
device = torch.device(
('cuda:0' if torch.cuda.is_available and args.num_gpus > 0 else 'cpu'))
logging.info(f'Running with device: {device}')
# Initialize models
netG = model.Generator().to(device)
netD = model.Discriminator().to(device)
if device.type == 'cuda' and args.num_gpus > 1:
netG = nn.DataParallel(netG, list(range(args.num_gpus)))
netD = nn.DataParallel(netD, list(range(args.num_gpus)))
# Apply DCGAN paper weight-reinitialization
# See more: https://arxiv.org/pdf/1511.06434.pdf
netG.apply(utils.dcgan_weights_reinit)
netD.apply(utils.dcgan_weights_reinit)
# Load dataset and resize
dataset = utils.data_synthesis(
os.path.abspath(args.dataroot),
image_size=(args.image_size, args.image_size, NUM_CHANNELS),
custom_transforms=[
transforms.ColorJitter(
brightness=0.05,
contrast=0.05,
saturation=0.05,
hue=0.03,
),
transforms.RandomCrop(size=args.image_size),
transforms.RandomHorizontalFlip(p=0.9),
transforms.RandomVerticalFlip(p=0.9),
transforms.Lambda(lambd=lambda img: img) # Identity transform
])
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
)
config = {
'netG': netG,
'netG_checkpoint': args.netG_checkpoint,
'netD': netD,
'netD_checkpoint': args.netD_checkpoint,
'dataloader': dataloader,
'device': device,
'learning_rate': args.learning_rate,
'num_epochs': args.num_epochs,
'beta1': args.beta1,
'beta2': args.beta2,
}
logging.info('Beginning training loop...')
G_losses, D_losses, img_list = train(config)
utils.plot_results(
device=device,
dataloader=dataloader,
G_losses=G_losses,
D_losses=D_losses,
img_list=img_list,
name=args.name,
outdir=FIGURES_DIR,
)
def demo(data_root,
train_list,
test_list,
save,
n_epochs=1,
batch_size=64,
lr=0.01,
wd=0.0005,
momentum=0.9,
lemta1=0.1,
lemta2=0.004,
seed=None):
#def demo(data_root, train_list, validation_list, test_list, save, n_epochs=1,
# batch_size=64, lr=0.001, wd=0.0005, seed=None):
"""
A demo to show off training and testing of :
"Deep facial age estimation using conditional multitask learning with weak label esxpansion."
Trains and evaluates a mean-variance loss on MOPPH Album2 dataset.
Args:
data_root (str) - path to directory where data exist
train_list (str) - path to directory where train_data_list exist
validation_list (str) - path to directory where validation_data_list exist
test_list (str) - path to directory where test_data_list exist
save (str) - path to save the model and results to
n_epochs (int) - number of epochs for training (default 3)
batch_size (int) - size of minibatch (default 64)
lr (float) - base lerning rate (default 0.001)
wd (float) -weight deday (default 0.0001)
momentum (float) momentum (default 0.9)
seed (int) - manually set the random seed (default None)
"""
# Mean and std value from Imagenet
mean = [0.485, 0.456, 0.406]
stdv = [0.229, 0.224, 0.225]
# mean=[0.5, 0.5, 0.5]
# stdv=[0.5, 0.5, 0.5]
train_transforms = transforms.Compose([
# transforms.Resize(146),
# transforms.RandomCrop(128),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(5),
transforms.ColorJitter(0.05, 0.05, 0.05, 0.05),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
test_transforms = transforms.Compose([
# transforms.Resize(146),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
# Datasets
train_set = data_prepare(data_root=data_root,
data_list=train_list,
transform=train_transforms)
test_set = data_prepare(data_root=data_root,
data_list=test_list,
transform=test_transforms)
pretrained_dict = model_zoo.load_url(model_urls['vgg16'])
# print(pretrained_dict.keys())
model = conditional_VGG16()
# print(model)
model_dict = model.state_dict()
# print(model_dict.keys())
# os._exit(0)
# del model_dict[]
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k in model_dict
}
# print(pretrained_dict.keys())
# os._exit(0)
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
# Make save directory
if not os.path.exists(save):
os.makedirs(save)
if not os.path.isdir(save):
raise Exception('%s is not a dir' % save)
# Model on cuda
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# prepare data
if seed is not None:
torch.manual_seed(seed)
if use_cuda:
torch.cuda.manual_seed_all(seed)
train_loader = torch.utils.data.DataLoader(
train_set,
batch_size=batch_size,
shuffle=True,
pin_memory=(torch.cuda.is_available()),
num_workers=4)
test_loader = torch.utils.data.DataLoader(
test_set,
batch_size=batch_size,
shuffle=False,
pin_memory=(torch.cuda.is_available()),
num_workers=4)
# Wrap model for multi-GPUs, if necessary
if torch.cuda.is_available() and torch.cuda.device_count() > 1:
model.features = torch.nn.DataParallel(model.features)
model_wrapper = model.to(device)
# Optimizer
optimizer = torch.optim.SGD(model_wrapper.parameters(),
lr=lr,
momentum=momentum,
nesterov=True,
weight_decay=wd)
# scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[0.5 * n_epochs, 0.75 * n_epochs],
# gamma=0.1)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[50, 70, 90],
gamma=0.1)
# optimizer = torch.optim.Adam(model_wrapper.parameters(), lr=lr, weight_decay=wd, amsgrad=True)
# Start log
if os.path.exists(
os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv')):
os.remove(
os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv'))
with open(os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv'),
'w') as f:
f.write(
'epoch, '
'train_softmax_loss_male_black, train_mean_loss_male_black, train_deviation_loss_male_black, '
'train_softmax_loss_male_white, train_mean_loss_male_white, train_deviation_loss_male_white, '
'train_softmax_loss_female_black, train_mean_loss_female_black, train_deviation_loss_female_black, '
'train_softmax_loss_female_white, train_mean_loss_female_white, train_deviation_loss_female_white, '
'train_age_loss, train_race_loss, train_gender_loss, train_total_loss, train_race_accuracy, train_gender_accuracy, train_MAE\n'
)
# Train and validate model
best_MAE = 100
model_state_dir = os.path.join(save,
'conditional_VGG16_nesterov_model_2.dat')
for epoch in range(n_epochs):
scheduler.step()
_, tra_slmb, tra_mlmb, tra_dlmb, tra_slmw, tra_mlmw, tra_dlmw, tra_slfb, tra_mlfb, tra_dlvb, tra_slfw, tra_mlfw, tra_dlfw, tra_al, tra_rl, tra_gl, tra_tl, tra_ra, tra_ga, train_MAE = train(
model=model_wrapper,
loader=train_loader,
optimizer=optimizer,
epoch=epoch,
n_epochs=n_epochs,
device=device,
lemta1=lemta1,
lemta2=lemta2)
print('*********************************')
# Determine if model is the best
if train_MAE < best_MAE:
best_MAE = train_MAE
print('New best MAE: %.4f' % best_MAE)
if os.path.exists(model_state_dir):
os.remove(model_state_dir)
torch.save(model_wrapper.state_dict(), model_state_dir)
with open(
os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv'),
'a') as f:
f.write('%03d, '
'%0.3f, %0.3f, %0.3f, '
'%0.3f, %0.3f, %0.3f, '
'%0.3f, %0.3f, %0.3f, '
'%0.3f, %0.3f, %0.3f, '
'%0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f\n' %
((epoch + 1), tra_slmb, tra_mlmb, tra_dlmb, tra_slmw,
tra_mlmw, tra_dlmw, tra_slfb, tra_mlfb, tra_dlvb,
tra_slfw, tra_mlfw, tra_dlfw, tra_al, tra_rl, tra_gl,
tra_tl, tra_ra, tra_ga, train_MAE))
# Test model
_, tes_ra, tes_ga, test_MAE, AE_list, predict_age_list, real_age_list = test(
model=model_wrapper,
loader=test_loader,
device=device,
model_state_dir=model_state_dir,
lemta1=lemta1,
lemta2=lemta2)
CS_1_numerator = CS_2_numerator = CS_3_numerator = CS_4_numerator = CS_5_numerator = CS_6_numerator = CS_7_numerator = CS_8_numerator = CS_9_numerator = CS_10_numerator = 0
for i in range(len(AE_list)):
if AE_list[i] <= 1:
CS_1_numerator += 1
if AE_list[i] <= 2:
CS_2_numerator += 1
if AE_list[i] <= 3:
CS_3_numerator += 1
if AE_list[i] <= 4:
CS_4_numerator += 1
if AE_list[i] <= 5:
CS_5_numerator += 1
if AE_list[i] <= 6:
CS_6_numerator += 1
if AE_list[i] <= 7:
CS_7_numerator += 1
if AE_list[i] <= 8:
CS_8_numerator += 1
if AE_list[i] <= 9:
CS_9_numerator += 1
if AE_list[i] <= 10:
CS_10_numerator += 1
CS_1 = CS_1_numerator / len(AE_list)
CS_2 = CS_2_numerator / len(AE_list)
CS_3 = CS_3_numerator / len(AE_list)
CS_4 = CS_4_numerator / len(AE_list)
CS_5 = CS_5_numerator / len(AE_list)
CS_6 = CS_6_numerator / len(AE_list)
CS_7 = CS_7_numerator / len(AE_list)
CS_8 = CS_8_numerator / len(AE_list)
CS_9 = CS_9_numerator / len(AE_list)
CS_10 = CS_10_numerator / len(AE_list)
with open(test_list) as f:
test_lines = f.readlines()
index = 0
with open(os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv'),
'a') as f:
f.write('******************************\n')
f.write('\n')
f.write('******************************\n')
f.write('test_img_name, real_age, predict_age, absolute_error(AE):\n')
for test_line in test_lines:
img_name = test_line.split()[0]
img_predict_age = predict_age_list[index].item()
img_real_age = real_age_list[index].item()
img_AE = AE_list[index].item()
record_line = img_name + ' ' + str(round(
img_real_age, 2)) + ' ' + str(round(
img_predict_age, 2)) + ' ' + str(round(img_AE, 2)) + '\n'
index += 1
with open(
os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv'),
'a') as f:
f.write(record_line)
with open(os.path.join(save, 'conditional_VGG16_nesterov_results_2.csv'),
'a') as f:
f.write('******************************\n')
f.write('test_race_accuracy, test_gender_accuracy, test_MAE\n')
f.write('%0.3f, %0.3f, %0.3f\n' % (tes_ra, tes_ga, test_MAE))
f.write(
'CS_1, CS_2, CS_3, CS_4, CS_5, CS_6, CS_7, CS_8, CS_9, CS_10:\n')
f.write(
'%0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f\n'
% (CS_1, CS_2, CS_3, CS_4, CS_5, CS_6, CS_7, CS_8, CS_9, CS_10))
def __getitem__(self, index):
img_path = self.img_paths[index]
gt_path = self.gt_paths[index]
img = get_img(img_path)
bboxes, tags = get_bboxes(img, gt_path)
if self.is_transform:
img = random_scale(img, self.img_size[0])
gt_text = np.zeros(img.shape[0:2], dtype='uint8')
training_mask = np.ones(img.shape[0:2], dtype='uint8')
if len(bboxes) > 0:
for i, box in enumerate(bboxes):
#bboxes[i] = box*[img.shape[1],img.shape[0]]*(len(box)//2).reshape(len(box)//2, 2)
bboxes[i] = np.array(box * ([img.shape[1], img.shape[0]] *
(len(box) // 2))).reshape(
len(box) // 2,
2).astype('int32')
for i, box in enumerate(bboxes):
cv2.drawContours(gt_text, [box], -1, i + 1, -1)
if not tags[i]:
cv2.drawContours(training_mask, [box], -1, 0, -1)
gt_kernals = []
for i in range(1, self.kernel_num):
rate = 1.0 - (1.0 - self.min_scale) / (self.kernel_num - 1) * i
gt_kernal = np.zeros(img.shape[0:2], dtype='uint8')
kernal_bboxes = shrink(bboxes, rate)
for i in range(len(bboxes)):
cv2.drawContours(gt_kernal, [kernal_bboxes[i]], -1, 1, -1)
gt_kernals.append(gt_kernal)
if self.is_transform:
gts = [gt_text, training_mask]
gts.extend(gt_kernals)
imgs = [img]
imgs.append(gts)
'''
imgs = [img, gt_text, training_mask]
imgs.extend(gt_kernals)
'''
imgs = self.aug(imgs)
'''
imgs = random_horizontal_flip(imgs)
imgs = random_rotate(imgs)
imgs = random_crop(imgs, self.img_size)
'''
#img, gt_text, training_mask, gt_kernals = imgs[0], imgs[1], imgs[2], imgs[3:]
img, gt_text, training_mask, gt_kernals = imgs[0], imgs[1][
0], imgs[1][1], imgs[1][2:]
gt_text[gt_text > 0] = 1
gt_kernals = np.array(gt_kernals)
# '''
if self.is_transform:
img = Image.fromarray(img)
img = img.convert('RGB')
img = transforms.ColorJitter(brightness=32.0 / 255,
saturation=0.5)(img)
else:
img = Image.fromarray(img)
img = img.convert('RGB')
img = transforms.ToTensor()(img)
img = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])(img)
gt_text = torch.from_numpy(gt_text).float()
gt_kernals = torch.from_numpy(gt_kernals).float()
training_mask = torch.from_numpy(training_mask).float()
# '''
return img, [gt_text, gt_kernals, training_mask]
y = int(random.choice(points))
background.paste(img, (x, y), img)
return background
else:
return img
if __name__ == "__main__":
trans2 = transforms.Compose([
transforms.Resize((256, 256)),
GauBlur(0.2),
transforms.RandomRotation(180),
transforms.RandomHorizontalFlip(),
transforms.RandomPerspective(p=0.5),
transforms.ColorJitter(brightness=0.3),
BackGround(1,
"../../../SwimData/SwimCodes/classification/train/False"),
GauBlur(0.2),
transforms.Resize((25, 25)),
transforms.Resize((256, 256)),
])
trans3 = transforms.Compose([transforms.Resize((256, 256)), HoriBlur(1)])
billed = PIL.Image.open(
"../../../SwimData/GeoCodes/classification2/art/A/A.png")
plt.imshow(billed)
plt.show()
nytbild = trans2(billed)
plt.imshow(nytbild)
def main():
global best_loss
loss_history_train = []
loss_history_val = []
data_dir = "data_dir"
img_dir_train = os.path.join("img/train")
img_dir_val = os.path.join("img/test")
txt_file_train = os.path.join(data_dir, "annot_train.txt")
txt_file_val = os.path.join(data_dir, "annot_test.txt")
# load pretrained resnet50 with a modified last fully connected layer
model = modified_resnet50()
# we need three different criterion for training
criterion_protest = nn.BCELoss()
criterion_violence = nn.MSELoss()
criterion_visattr = nn.BCELoss()
criterions = [criterion_protest, criterion_violence, criterion_visattr]
if args.cuda and not torch.cuda.is_available():
raise Exception("No GPU Found")
if args.cuda:
model = model.cuda()
criterions = [criterion.cuda() for criterion in criterions]
# we are not training the frozen layers
parameters = ifilter(lambda p: p.requires_grad, model.parameters())
optimizer = torch.optim.SGD(parameters,
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
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_loss = checkpoint['best_loss']
args.start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
loss_history_train = checkpoint['loss_history_train']
loss_history_val = checkpoint['loss_history_val']
if args.change_lr:
for param_group in optimizer.param_groups:
param_group['lr'] = args.lr
else:
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
eigval = torch.Tensor([0.2175, 0.0188, 0.0045])
eigvec = torch.Tensor([[-0.5675, 0.7192, 0.4009],
[-0.5808, -0.0045, -0.8140],
[-0.5836, -0.6948, 0.4203]])
train_dataset = ProtestDataset(txt_file=txt_file_train,
img_dir=img_dir_train,
transform=transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomRotation(30),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(
brightness=0.4,
contrast=0.4,
saturation=0.4,
),
transforms.ToTensor(),
Lighting(0.1, eigval, eigvec),
normalize,
]))
val_dataset = ProtestDataset(txt_file=txt_file_val,
img_dir=img_dir_val,
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
]))
train_loader = DataLoader(train_dataset,
num_workers=args.workers,
batch_size=args.batch_size,
shuffle=True)
val_loader = DataLoader(val_dataset,
num_workers=args.workers,
batch_size=args.batch_size)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
loss_history_train_this = train(train_loader, model, criterions,
optimizer, epoch)
break
loss_val, loss_history_val_this = validate(val_loader, model,
criterions, epoch)
loss_history_train.append(loss_history_train_this)
loss_history_val.append(loss_history_val_this)
# loss = loss_val.avg
is_best = loss_val < best_loss
if is_best:
print('best model!!')
best_loss = min(loss_val, best_loss)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_loss': best_loss,
'optimizer': optimizer.state_dict(),
'loss_history_train': loss_history_train,
'loss_history_val': loss_history_val
}, is_best)
def demo(data_root,
train_list,
test_list,
save,
n_epochs=1,
batch_size=64,
lr=0.01,
wd=0.0005,
momentum=0.9,
seed=None):
"""
A demo to show off training and testing of :
"Deep facial age estimation using conditional multitask learning with weak label esxpansion."
Trains and evaluates a mean-variance loss on MOPPH Album2 dataset.
Args:
data_root (str) - path to directory where data exist
train_list (str) - path to directory where train_data_list exist
validation_list (str) - path to directory where validation_data_list exist
test_list (str) - path to directory where test_data_list exist
save (str) - path to save the model and results to
n_epochs (int) - number of epochs for training (default 3)
batch_size (int) - size of minibatch (default 64)
lr (float) - base lerning rate (default 0.001)
wd (float) -weight deday (default 0.0001)
momentum (float) momentum (default 0.9)
seed (int) - manually set the random seed (default None)
"""
# Mean and std value from Imagenet
mean = [0.485, 0.456, 0.406]
stdv = [0.229, 0.224, 0.225]
train_transforms = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(5),
transforms.ColorJitter(0.05, 0.05, 0.05, 0.05),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
test_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=stdv),
])
if os.path.exists(
os.path.join(save, 'el_resnet101_2groups_nesterov_results_1.csv')):
os.remove(
os.path.join(save, 'el_resnet101_2groups_nesterov_results_1.csv'))
with open(
os.path.join(save, 'el_resnet101_2groups_nesterov_results_1.csv'),
'w') as f:
f.write(
'******************************************************************\n'
)
f.write('records on MORPH2 dataset under ' 'S1-S2-S3' ' protocol\n')
f.write(
'******************************************************************\n'
)
f.write('\n')
f.write('\n')
train_set = data_prepare(data_root=data_root,
data_list=train_list,
transform=train_transforms)
test_set = data_prepare(data_root=data_root,
data_list=test_list,
transform=test_transforms)
ensemble_learning_model = el_resnet101(num_classes=2)
pretrained_dict = model_zoo.load_url(model_urls['resnet101'])
model_dict = ensemble_learning_model.state_dict()
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k in model_dict
}
model_dict.update(pretrained_dict)
ensemble_learning_model.load_state_dict(model_dict)
model = ensemble_learning_model
# Make save directory
if not os.path.exists(save):
os.makedirs(save)
if not os.path.isdir(save):
raise Exception('%s is not a dir' % save)
# Model on cuda
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# prepare data
if seed is not None:
torch.manual_seed(seed)
if use_cuda:
torch.cuda.manual_seed_all(seed)
train_loader = torch.utils.data.DataLoader(
train_set,
batch_size=batch_size,
shuffle=True,
pin_memory=(torch.cuda.is_available()),
num_workers=4)
test_loader = torch.utils.data.DataLoader(
test_set,
batch_size=batch_size,
shuffle=False,
pin_memory=(torch.cuda.is_available()),
num_workers=4)
# Wrap model for multi-GPUs, if necessary
if torch.cuda.is_available() and torch.cuda.device_count() > 1:
model = torch.nn.DataParallel(model)
model_wrapper = model.to(device)
# Optimizer
optimizer = torch.optim.SGD(model_wrapper.parameters(),
lr=lr,
momentum=momentum,
nesterov=True,
weight_decay=wd)
# scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[0.5 * n_epochs, 0.75 * n_epochs],
# gamma=0.1)
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
milestones=[30, 50, 60],
gamma=0.1)
# Train and validate model
best_argmax_MAE = 100
model_state_name_1 = 'el_resnet101_nesterov_2groups_model_1.dat'
model_state_dir_1 = os.path.join(save, model_state_name_1)
with open(
os.path.join(save, 'el_resnet101_2groups_nesterov_results_1.csv'),
'a') as f:
f.write('epoch, train_total_loss, train_argmax_MAE, train_accuracy\n')
for epoch in range(n_epochs):
scheduler.step()
_, train_total_loss, train_argmax_MAE, train_accuracy = train(
model=model_wrapper,
loader=train_loader,
optimizer=optimizer,
epoch=epoch,
n_epochs=n_epochs,
device=device)
# Determine if model is the best
if train_argmax_MAE < best_argmax_MAE:
best_argmax_MAE = train_argmax_MAE
if os.path.exists(model_state_dir_1):
os.remove(model_state_dir_1)
torch.save(model_wrapper.state_dict(), model_state_dir_1)
with open(
os.path.join(save,
'el_resnet101_2groups_nesterov_results_1.csv'),
'a') as f:
f.write('%03d, %0.4f, %0.4f, %0.4f\n' %
((epoch + 1), train_total_loss, train_argmax_MAE,
train_accuracy))
if math.isnan(float(train_argmax_MAE)):
break
# Test model
if os.path.exists(model_state_dir_1):
_, test_total_loss, test_argmax_MAE, test_accuracy, AE_list, predict_age_list, real_age_list = test(
model=model_wrapper,
loader=test_loader,
device=device,
model_state_dir=model_state_dir_1,
)
# os.remove(model_state_dir_1)
with open(
os.path.join(save,
'el_resnet101_2groups_nesterov_results_1.csv'),
'a') as f:
f.write('test_total_loss, test_argmax_MAE, test_accuracy:\n')
f.write('%0.4f, %0.4f, %0.4f\n' %
(test_total_loss, test_argmax_MAE, test_accuracy))
# f.write('\n')
CS_1_numerator = CS_2_numerator = CS_3_numerator = CS_4_numerator = CS_5_numerator = CS_6_numerator = CS_7_numerator = CS_8_numerator = CS_9_numerator = CS_10_numerator = 0
for i in range(len(AE_list)):
if AE_list[i] <= 1:
CS_1_numerator += 1
if AE_list[i] <= 2:
CS_2_numerator += 1
if AE_list[i] <= 3:
CS_3_numerator += 1
if AE_list[i] <= 4:
CS_4_numerator += 1
if AE_list[i] <= 5:
CS_5_numerator += 1
if AE_list[i] <= 6:
CS_6_numerator += 1
if AE_list[i] <= 7:
CS_7_numerator += 1
if AE_list[i] <= 8:
CS_8_numerator += 1
if AE_list[i] <= 9:
CS_9_numerator += 1
if AE_list[i] <= 10:
CS_10_numerator += 1
CS_1 = CS_1_numerator / len(AE_list)
CS_2 = CS_2_numerator / len(AE_list)
CS_3 = CS_3_numerator / len(AE_list)
CS_4 = CS_4_numerator / len(AE_list)
CS_5 = CS_5_numerator / len(AE_list)
CS_6 = CS_6_numerator / len(AE_list)
CS_7 = CS_7_numerator / len(AE_list)
CS_8 = CS_8_numerator / len(AE_list)
CS_9 = CS_9_numerator / len(AE_list)
CS_10 = CS_10_numerator / len(AE_list)
with open(
os.path.join(save,
'el_resnet101_2groups_nesterov_results_1.csv'),
'a') as f:
f.write(
'CS_1, CS_2, CS_3, CS_4, CS_5, CS_6, CS_7, CS_8, CS_9, CS_10:\n'
)
f.write(
'%0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f, %0.3f\n'
%
(CS_1, CS_2, CS_3, CS_4, CS_5, CS_6, CS_7, CS_8, CS_9, CS_10))
f.write('\n')
def saturation(img, delta):
if random.random() < 0.5:
img = transforms.ColorJitter(saturation=delta)(img)
return img
import torchvision.transforms as transforms
from dataset import ImageClassificationDataset
camera = Camera.instance()
TASK = 'thumbs'
#task = 'emotions'
#task = 'fingers'
#task = 'diy'
CATEGORIES = ['thumbs_up', 'thumbs_down']
# categories = ['none', 'happy', 'sad', 'angry']
# categories = ['1', '2', '3', '4', '5']
# categories = [ 'diy_1', 'diy_2', 'diy_3']
DATASETS = ['A', 'B']
#datasets =['A', 'B', 'C']
TRANSFORMS = transforms.Compose([
transforms.ColorJitter(0.2, 0.2, 0.2, 0.2),
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
datasets = {}
for name in DATASETS:
datasets[name] = ImageClassificationDataset(TASK + '_' + name, CATEGORIES,
TRANSFORMS)
print("{} task with {} categories defined".format(TASK, CATEGORIES))
def hue(img, delta):
if random.random() < 0.5:
img = transforms.ColorJitter(hue=delta)(img)
return img
return mysoftplus(D/80)
svhn_path = '~/Downloads/Datasets/SVHN'
if __name__ == '__main__':
run = '9'
labeledfrac = '0.100'
unlabeledfrac = '0.000'
normalize = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
)
augcolor = [transforms.ColorJitter(brightness=0.5,contrast=0.5,saturation=0.5,hue=0.5)]
augaffine = [transforms.RandomAffine(20, scale=(0.9,1.1),shear=20,
resample=PIL.Image.BICUBIC, fillcolor=(100,100,100))]
augtrans = transforms.Compose(
[
transforms.RandomApply(augcolor, p=0.8),
transforms.RandomApply(augaffine, p=0.8),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
head = Net_Head()
bulk = Net_Bulk()
curltrainer = curl.CURL(datasets.SVHN,
10,
import cv2 as cv
import numpy as np
import torch
from torch.utils.data import Dataset
from torchvision import transforms
from config import im_size, unknown_code, fg_path, bg_path, a_path, num_valid
from utils import safe_crop
# Data augmentation and normalization for training
# Just normalization for validation
data_transforms = {
'train':
transforms.Compose([
transforms.ColorJitter(brightness=0.125,
contrast=0.125,
saturation=0.125),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
]),
'valid':
transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
with open('Combined_Dataset/Training_set/training_fg_names.txt') as f:
fg_files = f.read().splitlines()
with open('Combined_Dataset/Training_set/training_bg_names.txt') as f:
def main():
global args, best_prec
args = parser.parse_args()
print("Build model ...")
model = build_model()
if not os.path.exists(args.resume):
os.makedirs(args.resume)
print("Saving everything to directory %s." % (args.resume))
# define loss function (criterion) and optimizer
# criterion = nn.CrossEntropyLoss().cuda()
criterion = nn.L1Loss().cuda()
optimizer = torch.optim.SGD(model.module.fc.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.resumepath:
if os.path.isfile(args.resumepath):
print("=> loading checkpoint '{}'".format(args.resumepath))
checkpoint = torch.load(args.resumepath)
args.start_epoch = checkpoint['epoch']
best_prec = checkpoint['best_prec']
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {}, best_prec {})".format(
args.evaluate, checkpoint['epoch'], best_prec))
else:
print("=> no checkpoint found at '{}'".format(args.resumepath))
return
cudnn.benchmark = True
# data transform
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ColorJitter(),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std)
])
val_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std)])
train_data = MyDataset(
os.path.join(args.dir_path, 'annotation_training.json'),
os.path.join(args.dir_path, 'train-jpglist.txt'),
os.path.join(args.dir_path, 'train-images-face'), args.new_width,
args.new_length, train_transform)
val_data = MyDataset(
os.path.join(args.dir_path, 'annotation_validation.json'),
os.path.join(args.dir_path, 'val-jpglist.txt'),
os.path.join(args.dir_path, 'val-images-face'), args.new_width,
args.new_length, val_transform)
train_loader = DataLoader(dataset=train_data,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = DataLoader(dataset=val_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
print('epoch: ' + str(epoch + 1))
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec = validate(val_loader, model, criterion)
# remember best prec and save checkpoint
is_best = prec > best_prec
best_prec = max(prec, best_prec)
if is_best:
torch.save(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec': best_prec,
'optimizer': optimizer.state_dict(),
}, "best_checkpoint.pth.tar")
def main_worker(gpu, ngpus_per_node, args):
print(ngpus_per_node)
args.gpu = gpu
# suppress printing if not master
if args.multiprocessing_distributed and args.gpu != 0:
def print_pass(*args):
pass
builtins.print = print_pass
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank)
# create model
print("=> creating model '{}'".format(args.arch))
model = moco.builder.MoCo(model_names[args.arch], args.moco_dim,
args.moco_k, args.moco_m, args.moco_t, args.mlp)
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int(
(args.workers + ngpus_per_node - 1) / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu])
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
# comment out the following line for debugging
# raise NotImplementedError("Only DistributedDataParallel is supported.")
else:
pass
# AllGather implementation (batch shuffle, queue update, etc.) in
# this code only supports DistributedDataParallel.
# raise NotImplementedError("Only DistributedDataParallel is supported.")
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
if args.gpu is None:
checkpoint = torch.load(args.resume)
else:
# Map model to be loaded to specified single gpu.
loc = 'cuda:{}'.format(args.gpu)
checkpoint = torch.load(args.resume, map_location=loc)
args.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']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = args.data #os.path.join(args.data, 'train')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if args.aug_plus:
# MoCo v2's aug: similar to SimCLR https://arxiv.org/abs/2002.05709
augmentation = [
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomApply(
[
transforms.ColorJitter(0.4, 0.4, 0.4,
0.1) # not strengthened
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomApply([moco.loader.GaussianBlur([.1, 2.])],
p=0.5),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize
]
else:
# MoCo v1's aug: the same as InstDisc https://arxiv.org/abs/1805.01978
augmentation = [
transforms.RandomResizedCrop(224, scale=(0.2, 1.)),
transforms.RandomGrayscale(p=0.2),
transforms.ColorJitter(0.4, 0.4, 0.4, 0.4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
]
train_dataset = datasets.ImageFolder(
traindir,
moco.loader.TwoCropsTransform(transforms.Compose(augmentation)))
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
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,
drop_last=True)
if os.path.exists(args.save_path) == False:
os.mkdir(args.save_path)
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
# try:
# for i, images in enumerate(train_loader):
# print(i)
# except:
# print('wrong', i)
train(train_loader, model, criterion, optimizer, epoch, args)
if epoch != 0 and epoch % args.save_epoch == 0:
filename = os.path.join(args.save_path,
'checkpoint_{:04d}.pth.tar'.format(epoch))
if not args.multiprocessing_distributed or (
args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
},
is_best=False,
filename=filename)
print("Model Saved")
class TwoCropsTransformClean:
"""Take two random crops of one image as the query and key."""
def __init__(self, base_transform):
self.base_transform = base_transform
def __call__(self, x):
k = self.base_transform(x)
q_clean = transforms.ToTensor()(x)
return [q_clean, k]
augs = transforms.Compose([
transforms.RandomApply(
[
transforms.ColorJitter(0.4, 0.4, 0.4, 0.1) # not strengthened
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
if opt.dataset == 'svhn':
train_loader = torch.utils.data.DataLoader(datasets.SVHN(
root=opt.dataroot,
split='extra',
download=True,
transform=transforms.Compose([transforms.ToTensor()])),
batch_size=batch_size,
shuffle=True,
from torchvision import transforms as tfs
# 增强
im_aug = tfs.Compose([
tfs.RandomHorizontalFlip(),
tfs.RandomCrop(96),
tfs.ColorJitter(brightness=0.5, contrast=0.5, hue=0.5),
tfs.ToTensor(),
tfs.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
def random_crop(data, label, crop_size):
height, width = crop_size
data, rect = tfs.RandomCrop((height, width))(data)
label = tfs.FixedCrop(*rect)(label)
return data, label
#Dalam revtesis ada 2 folder: train dan test
#Dataset dalam folder train akan dibagi 2 secara acak untuk training dan validasi
#perbandingan data set training validasi dan testing : 80% 10% 10%
root_dir = '/floyd/input/revtesis/'
home_dir = '/floyd/home/'
print("The data lies here =>", root_dir)
#transform image untuk membuat variasi gambar yang bertujuan mengurangi overfitting
#Ada 5 transform untuk training : Randomcrop, RandomRotation, Random HorizontalFlip, ColorJitter, Random VerticalFlip.
#Ada 1 transform untuk testing : Resize
image_transforms = {
"train": transforms.Compose([
transforms.RandomCrop((224, 224)),
transforms.RandomRotation(degrees=15),
transforms.RandomHorizontalFlip(p=0.5),
transforms.ColorJitter(hue=.05, saturation=.05),
transforms.RandomVerticalFlip(p=0.5),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5],
[0.5, 0.5, 0.5])
]),
"test": transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5],
[0.5, 0.5, 0.5])
])
}
#Load dataset training dari folder /floyd/input/revtesis/Train
rps_dataset = datasets.ImageFolder(root = root_dir + "Train",
def data_settings(opt):
#---------------------------------------# Transform data
# 用于对于图片数据的加载和预处理。
transform_train_list = [
] # List used to store the different class instances for training.
transform_train_list = transform_train_list + [
transforms.Resize((opt.h, opt.w), interpolation=3)
] # 图像要插值成为256×128大小的图像。
transform_train_list = transform_train_list + [
transforms.Pad(opt.pad)
] if opt.pad > 0 else transform_train_list # opt.pad=0,所以不进行图像填充。
transform_train_list = transform_train_list + [
transforms.RandomCrop((opt.h, opt.w))
] if opt.pad > 0 else transform_train_list # 控制随机裁剪图片。
# 这里因为opt.pad=0，所以并不进行设置。
transform_train_list = transform_train_list + [
transforms.RandomHorizontalFlip()
] if opt.flip else transform_train_list
# 控制随机水平翻转
transform_train_list = transform_train_list + [
transforms.ToTensor()
] # 将数据转换为tensor，并归一化至【0,1】范围内。
transform_train_list = transform_train_list + [
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]
transform_val_list = [
] # List used to store the different class instances for evaluation.
transform_val_list = transform_val_list + [
transforms.Resize(size=(opt.h, opt.w), interpolation=3)
] # calling __init__ of each class.
transform_val_list = transform_val_list + [transforms.ToTensor()]
transform_val_list = transform_val_list + [
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]
if opt.all_erasing_p > 0: # false
transform_train_list = transform_train_list + [
RandomErasing(probability=opt.all_erasing_p, mean=[0.0, 0.0, 0.0])
]
if opt.color_jitter: # false
transform_train_list = [
transforms.ColorJitter(
brightness=0.1, contrast=0.1, saturation=0.1, hue=0)
] + transform_train_list
# 将'train_all', 'gallery', 'query'三类数据集合的 transform属性存储在一个字典数据结构data_transforms 中。
data_transforms = {} # Initial dict.
for x in opt.phase_data: # 'train_all', 'gallery', 'query'
if x == opt.phase_train: # if x == 'train_all'
data_transforms[x] = transforms.Compose(
transform_train_list
) # initial the class transforms.Compose and form instance.
else:
data_transforms[x] = transforms.Compose(
transform_val_list) # initial transforms.Compose class.
print('===> [Transform data] ' + str(transform_train_list))
data_info = {} # Initial dict.
# if opt.test_tsne and opt.test_on:
image_datasets_train_tsne = datasets.ImageFolder(
os.path.join(opt.data_dir, opt.data_name, opt.phase_train),
data_transforms['query'])
# 利用datasets.ImageFolder进行初始化。 imagefolder类的实例初始化。 提供图片的root目录，以及Compose类型的数据变换方法。
# Root location: ./data/RegDB_01/train_all 4120个target.
cnt = 0
for i in range(len(image_datasets_train_tsne.targets)): # 4120表示所有的图像个数。
if image_datasets_train_tsne.targets[
i] < opt.test_tsne_num: # opt.test_tsne_num = 15.
cnt += 1 # 记录train_all文件夹中前15个子文件夹的图像数量。 共计300个。
sampler = DummySampler(
image_datasets_train_tsne) # dummy 仿制品，假的。 dummysampler模拟采样器。
sampler.num_samples = cnt # 设置采样数量。
# sampler.num_samples = len(image_datasets_train_tsne.targets)
# 产生dataloader对象
dataloaders_train_tsne = torch.utils.data.DataLoader(
image_datasets_train_tsne,
batch_size=opt.set_batchsize['query'],
shuffle=opt.set_shuffle['query'],
num_workers=opt.set_workers['query'],
sampler=sampler,
pin_memory=opt.pin_memory,
drop_last=opt.set_droplast['query'])
data_info['train_tsne_cam'], data_info['train_tsne_label'], data_info[
'train_tsne_modal'] = get_attribute(opt.data_flag,
image_datasets_train_tsne.imgs,
flag=opt.type_domain_label)
# 使用字典存储data_info.
# opt.data_flag= 5 ,
# image_datasets_train_tsne.imgs: 图片的目录和类型。
# opt.type_domain_label = 0
train_label_all = data_info[
'train_tsne_label'] # all labels for trained images.
train_modal_all = data_info[
'train_tsne_modal'] # all model for trained images.
train_cam_all = data_info['train_tsne_cam'] # all cam for trained images.
# 对data_info进行裁剪，只保留前300个图像对应的数据。 cnt=300.
data_info['train_tsne_cam'] = data_info['train_tsne_cam'][:cnt]
data_info['train_tsne_label'] = data_info['train_tsne_label'][:cnt]
data_info['train_tsne_modal'] = data_info['train_tsne_modal'][:cnt]
# else:
# dataloaders_train_tsne = []
#---------------------------------------# Load data
since = time.time()
image_datasets = {
x: datasets.ImageFolder(os.path.join(opt.data_dir, opt.data_name, x),
data_transforms[x])
for x in opt.phase_data
}
dataloaders = {
x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=opt.set_batchsize[x],
shuffle=opt.set_shuffle[x],
num_workers=opt.set_workers[x],
pin_memory=opt.pin_memory,
drop_last=opt.set_droplast[x])
for x in opt.phase_data
}
if opt.test_on:
data_info['gallery_cam'], data_info['gallery_label'], data_info[
'gallery_modal'] = get_attribute(opt.data_flag,
image_datasets['gallery'].imgs,
flag=opt.type_domain_label)
data_info['query_cam'], data_info['query_label'], data_info[
'query_modal'] = get_attribute(opt.data_flag,
image_datasets['query'].imgs,
flag=opt.type_domain_label)
if opt.test_multi:
data_info['mquery_cam'], data_info['mquery_label'], data_info[
'mquery_modal'] = get_attribute(
opt.data_flag,
image_datasets['multi-query'].imgs,
flag=opt.type_domain_label)
if opt.phase_train in opt.phase_exp:
opt.dataset_sizes = {x: len(image_datasets[x]) for x in opt.phase_data}
class_names = image_datasets[opt.phase_train].classes
opt.nclasses = len(class_names)
# inputs, classes = next(iter(dataloaders[opt.phase_train]))
opt.use_gpu = torch.cuda.is_available()
print(' ------------------------------')
print(' Dataset {} statistics:'.format(opt.data_name))
print(' ------------------------------')
print(' subset | # ids | # images')
print(' ------------------------------')
if opt.phase_train in opt.phase_exp:
if opt.cross_reid:
train_cam, train_label, train_modal = get_attribute(
opt.data_flag,
image_datasets[opt.phase_train].imgs,
flag=opt.type_domain_label)
cross_flag = {}
cross_flag['thermal'] = int(0)
cross_flag['visual'] = int(1)
cross_idx = {}
cross_modal = {}
cross_cam = {}
cross_label = {}
cross_idx['thermal'] = [
i for i, x in enumerate(train_modal)
if x == cross_flag['thermal']
]
cross_idx['visual'] = [
i for i, x in enumerate(train_modal)
if x == cross_flag['visual']
]
cross_modal['thermal'] = [
train_modal[x] for x in cross_idx['thermal']
]
cross_modal['visual'] = [
train_modal[x] for x in cross_idx['visual']
]
cross_cam['thermal'] = [train_cam[x] for x in cross_idx['thermal']]
cross_cam['visual'] = [train_cam[x] for x in cross_idx['visual']]
cross_label['thermal'] = [
train_label[x] for x in cross_idx['thermal']
]
cross_label['visual'] = [
train_label[x] for x in cross_idx['visual']
]
print(' Visible | {:5d} | {:8d}'.format(
len(np.unique(cross_label['visual'])),
train_modal.count(cross_flag['visual'])))
print(' Thermal | {:5d} | {:8d}'.format(
len(np.unique(cross_label['thermal'])),
train_modal.count(cross_flag['thermal'])))
else:
print(' Training | {:5d} | {:8d}'.format(
opt.nclasses, len(image_datasets[opt.phase_train])))
print(' ------------------------------')
if 'test' in opt.phase_exp:
print(' Query | {:5d} | {:8d}'.format(
len(np.unique(data_info['query_label'])),
len(data_info['query_label'])))
print(' Gallery | {:5d} | {:8d}'.format(
len(np.unique(data_info['gallery_label'])),
len(data_info['gallery_label'])))
print(' ------------------------------')
print(' Data Loading Time:\t {:.3f}'.format(
round(time.time() - since, 3)))
print(' ------------------------------')
# if (opt.samp_pos + opt.samp_neg) > 0:
if not opt.test_only:
old_train_dataloader = dataloaders[opt.phase_train]
else:
old_train_dataloader = []
for x in opt.phase_data:
if not x in ['query', 'gallery']:
image_datasets[x] = PosNegSampler(os.path.join(
opt.data_dir, opt.data_name, x),
data_transforms[x],
data_flag=opt.data_flag,
name_samping=opt.name_samping,
num_pos=opt.samp_pos,
num_neg=opt.samp_neg,
opt=opt)
dataloaders[x] = torch.utils.data.DataLoader(
image_datasets[x],
batch_size=opt.set_batchsize[x],
shuffle=opt.set_shuffle[x],
num_workers=opt.set_workers[x],
pin_memory=opt.pin_memory,
drop_last=opt.set_droplast[x])
train_v_idx_first = []
train_t_idx_first = []
train_v_idx_last = []
train_t_idx_last = []
train_modal_all = np.asarray(train_modal_all)
train_cam_all = np.asarray(train_cam_all)
if opt.test_IR2_flag: # IR2
if opt.type_domain_label == 1: # 0:RGB, 1:IR, 2:IR2
cam_idx = 2
elif opt.type_domain_label == 2: # 0,1:RGB, 2:IR, 3:IR2
cam_idx = 3
elif opt.type_domain_label == 3: # 0,1,3,4:RGB, 2:IR, 5:IR2
cam_idx = 5
else: # IR
if opt.type_domain_label == 1: # 0:RGB, 1:IR, 2:IR2
cam_idx = 1
elif opt.type_domain_label == 2: # 0,1:RGB, 2:IR, 3:IR2
cam_idx = 2
elif opt.type_domain_label == 3: # 0,1,3,4:RGB, 2:IR, 5:IR2
cam_idx = 2
for i in range(len(np.unique(train_label_all))):
idx = np.where(train_label_all == np.unique(train_label_all)[i])[0]
train_v_idx_first.append(
idx[np.where(train_modal_all[idx] == 1)[0][0]])
train_v_idx_last.append(idx[np.where(
train_modal_all[idx] == 1)[0][-1 - opt.visual_last_idx]])
if opt.data_name == 'SYSU' and opt.type_domain_label > 0:
common_idx = idx[[train_modal_all[idx] == 0][0] *
[train_cam_all[idx] == cam_idx][0]]
if len(common_idx) > 0:
train_t_idx_first.append(common_idx[0])
train_t_idx_last.append(common_idx[-1 - opt.visual_last_idx])
else:
train_t_idx_first.append(
idx[np.where(train_modal_all[idx] == 0)[0][0]])
train_t_idx_last.append(idx[np.where(
train_modal_all[idx] == 0)[0][-1 - opt.visual_last_idx]])
opt.num_draw_samples_idx_train_a = opt.num_draw_samples_idx_train_a.split(
',')
opt.num_draw_samples_idx_train_a = [
int(train_v_idx_first[int(opt.num_draw_samples_idx_train_a[i])])
for i in range(len(opt.num_draw_samples_idx_train_a))
]
opt.num_draw_samples_idx_train_b = opt.num_draw_samples_idx_train_b.split(
',')
opt.num_draw_samples_idx_train_b = [
int(train_t_idx_first[int(opt.num_draw_samples_idx_train_b[i])])
for i in range(len(opt.num_draw_samples_idx_train_b))
]
# opt.num_draw_samples_train = min(opt.num_draw_samples_train, len(train_v_idx_first), len(train_t_idx_first))
train_display_images_a = torch.stack([
dataloaders_train_tsne.dataset[opt.num_draw_samples_idx_train_a[i]][0]
for i in range(len(opt.num_draw_samples_idx_train_a))
])
train_display_images_b = torch.stack([
dataloaders_train_tsne.dataset[opt.num_draw_samples_idx_train_b[i]][0]
for i in range(len(opt.num_draw_samples_idx_train_b))
])
train_display_images_a_pos = dataloaders_train_tsne.dataset[
train_v_idx_last[opt.visual_pos_idx]][0]
train_display_images_b_pos = dataloaders_train_tsne.dataset[
train_t_idx_last[opt.visual_pos_idx]][0]
train_display_images_a_neg = dataloaders_train_tsne.dataset[
train_v_idx_last[opt.visual_neg_idx]][0]
train_display_images_b_neg = dataloaders_train_tsne.dataset[
train_t_idx_last[opt.visual_neg_idx]][0]
gallery_lables = np.array(data_info['gallery_label'])
gallery_modals = np.array(data_info['gallery_modal'])
query_labels = np.array(data_info['query_label'])
query_modals = np.array(data_info['query_modal'])
gallery_cams = np.array(data_info['gallery_cam'])
query_cams = np.array(data_info['query_cam'])
test_v_idx = np.where(gallery_modals == 1)[0]
if len(test_v_idx) > 0:
gallery_is_v = True
else:
gallery_is_v = False
train_v_idx_first = []
train_t_idx_first = []
train_v_idx_last = []
train_t_idx_last = []
for i in range(len(np.unique(gallery_lables))):
idx = np.where(gallery_lables == np.unique(gallery_lables)[i])[0]
# gallery
if gallery_is_v:
train_v_idx_first.append(
idx[np.where(gallery_modals[idx] == 1)[0][0]])
train_v_idx_last.append(idx[np.where(
gallery_modals[idx] == 1)[0][-1 - opt.visual_last_idx]])
else: # thermal
if opt.data_name == 'SYSU' and opt.type_domain_label > 0:
common_idx = idx[[gallery_modals[idx] == 0][0] *
[gallery_cams[idx] == cam_idx][0]]
if len(common_idx) > 0:
train_t_idx_first.append(common_idx[0])
train_t_idx_last.append(common_idx[-1 -
opt.visual_last_idx])
else:
train_t_idx_first.append(
idx[np.where(gallery_modals[idx] == 0)[0][0]])
train_t_idx_last.append(idx[np.where(
gallery_modals[idx] == 0)[0][-1 - opt.visual_last_idx]])
for i in range(len(np.unique(query_labels))):
idx = np.where(query_labels == np.unique(query_labels)[i])[0]
# query
if gallery_is_v: # thermal
if opt.data_name == 'SYSU' and opt.type_domain_label > 0:
common_idx = idx[[query_modals[idx] == 0][0] *
[query_cams[idx] == cam_idx][0]]
if len(common_idx) > 0:
train_t_idx_first.append(common_idx[0])
train_t_idx_last.append(common_idx[-1 -
opt.visual_last_idx])
else:
train_t_idx_first.append(
idx[np.where(query_modals[idx] == 0)[0][0]])
train_t_idx_last.append(idx[np.where(
query_modals[idx] == 0)[0][-1 - opt.visual_last_idx]])
else:
train_v_idx_first.append(
idx[np.where(query_modals[idx] == 1)[0][0]])
train_v_idx_last.append(idx[np.where(
query_modals[idx] == 1)[0][-1 - opt.visual_last_idx]])
opt.num_draw_samples_idx_test_a = opt.num_draw_samples_idx_test_a.split(
',')
opt.num_draw_samples_idx_test_a = [
int(train_v_idx_first[int(opt.num_draw_samples_idx_test_a[i])])
for i in range(len(opt.num_draw_samples_idx_test_a))
]
opt.num_draw_samples_idx_test_b = opt.num_draw_samples_idx_test_b.split(
',')
opt.num_draw_samples_idx_test_b = [
int(train_t_idx_first[int(opt.num_draw_samples_idx_test_b[i])])
for i in range(len(opt.num_draw_samples_idx_test_b))
]
if gallery_is_v:
test_display_images_a = torch.stack([
dataloaders['gallery'].dataset[opt.num_draw_samples_idx_test_a[i]]
[0] for i in range(len(opt.num_draw_samples_idx_test_a))
])
test_display_images_b = torch.stack([
dataloaders['query'].dataset[opt.num_draw_samples_idx_test_b[i]][0]
for i in range(len(opt.num_draw_samples_idx_test_b))
])
test_display_images_a_pos = dataloaders['gallery'].dataset[
train_v_idx_last[opt.visual_pos_idx]][0]
test_display_images_b_pos = dataloaders['query'].dataset[
train_t_idx_last[opt.visual_pos_idx]][0]
test_display_images_a_neg = dataloaders['gallery'].dataset[
train_v_idx_last[opt.visual_neg_idx]][0]
test_display_images_b_neg = dataloaders['query'].dataset[
train_t_idx_last[opt.visual_neg_idx]][0]
else:
test_display_images_a = torch.stack([
dataloaders['query'].dataset[opt.num_draw_samples_idx_test_a[i]][0]
for i in range(len(opt.num_draw_samples_idx_test_a))
])
test_display_images_b = torch.stack([
dataloaders['gallery'].dataset[opt.num_draw_samples_idx_test_b[i]]
[0] for i in range(len(opt.num_draw_samples_idx_test_b))
])
test_display_images_a_pos = dataloaders['query'].dataset[
train_v_idx_last[opt.visual_pos_idx]][0]
test_display_images_b_pos = dataloaders['gallery'].dataset[
train_t_idx_last[opt.visual_pos_idx]][0]
test_display_images_a_neg = dataloaders['query'].dataset[
train_v_idx_last[opt.visual_neg_idx]][0]
test_display_images_b_neg = dataloaders['gallery'].dataset[
train_t_idx_last[opt.visual_neg_idx]][0]
data_sample = {'train_a':train_display_images_a, 'train_b':train_display_images_b, \
'test_a' : test_display_images_a, 'test_b' : test_display_images_b, \
'train_a_pos':train_display_images_a_pos, 'train_b_pos':train_display_images_b_pos,\
'test_a_pos':test_display_images_a_pos, 'test_b_pos':test_display_images_b_pos, \
'train_a_neg':train_display_images_a_neg, 'train_b_neg':train_display_images_b_neg,\
'test_a_neg':test_display_images_a_neg, 'test_b_neg':test_display_images_b_neg}
if not opt.test_only:
new_epoch = opt.num_cnt / (math.floor(
len(dataloaders[opt.phase_train].dataset.imgs) /
opt.train_batchsize))
opt.num_epoch = 100
if new_epoch < opt.num_epoch:
print('num_epoch is changed from {} to {}'.format(
opt.num_epoch, math.ceil(new_epoch)))
opt.num_epoch = math.ceil(new_epoch)
opt.total_cnt = math.ceil(new_epoch) * math.floor(
len(dataloaders[opt.phase_train].dataset.imgs) /
opt.train_batchsize)
# 返回加载的数据。
return dataloaders, dataloaders_train_tsne, old_train_dataloader, data_info, data_sample, opt
def brightness(img, delta):
if random.random() < 0.5:
img = transforms.ColorJitter(brightness=delta)(img)
return img
transforms.Resize((384, 192), interpolation=3),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]
transform_val_list = [
transforms.Resize(size=(384, 192), interpolation=3), # Image.BICUBIC
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]
if opt.erasing_p > 0: # 随机擦除概率
transform_train_list = transform_train_list + [RandomErasing(probability=opt.erasing_p, mean=[0.0, 0.0, 0.0])]
if opt.color_jitter: # 如果 在训练中使用颜色抖动
transform_train_list = [transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1,
hue=0)] + transform_train_list
print("opt:", opt)
print("transform_train_list:", transform_train_list)
data_transforms = {
'train': transforms.Compose(transform_train_list),
'val': transforms.Compose(transform_val_list),
}
train_all = ''
if opt.train_all: # 传入train_all，使用Market-1501-v15.09.15/pytorch/train_all/目录
train_all = '_all'
# data_dir=Market-1501-v15.09.15/pytorch/,
# 训练数据集：Market-1501-v15.09.15/pytorch/train_all/
# 测试数据集：Market-1501-v15.09.15/pytorch/val/
image_datasets = {}
def contrast(img, delta):
if random.random() < 0.5:
img = transforms.ColorJitter(contrast=delta)(img)
return img
def main():
global args, best_prec1, seed
args = parser.parse_args()
#os.environ['CUDA_VISIBLE_DEVICES']=', '.join(str(x) for x in args.gpu)
model=models.ResNet(depth=args.depth, pretrained=args.pretrained, cut_at_pooling=False, num_features=0, norm=False, dropout=0, num_classes=2)
# # create model
# if args.pretrained: # from system models
# print("=> using pre-trained model '{}'".format(args.arch))
# model = models.__dict__[args.arch](pretrained=True) #from pytorch system
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
if use_cuda:
model=model.cuda() ############################# important, it means model operation is conducted on cuda
else:
model=model()
print ('Loading data from '+ args.root_path+args.trainFile)
if args.da==0:
train_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.trainFile,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(), # The order seriously matters: RandomHorizontalFlip, ToTensor, Normalize
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5 ], std = [ 0.5, 0.5, 0.5 ]),
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
elif args.da==1:
train_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.trainFile,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(), # The order seriously matters: RandomHorizontalFlip, ToTensor, Normalize
transforms.ColorJitter(),
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5 ], std = [ 0.5, 0.5, 0.5 ]),
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
elif args.da==2:
deg=random.random()*10
train_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.trainFile,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(), # The order seriously matters: RandomHorizontalFlip, ToTensor, Normalize
transforms.ColorJitter(),
transforms.RandomRotation(deg),
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5], std = [ 0.5, 0.5, 0.5 ]),
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
elif args.da==3:
deg=random.random()*10
train_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.trainFile,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(), # The order seriously matters: RandomHorizontalFlip, ToTensor, Normalize
transforms.RandomRotation(deg),
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5], std = [ 0.5, 0.5, 0.5 ]),
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
elif args.da==4:
deg=random.random()*20
train_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.trainFile,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(), # The order seriously matters: RandomHorizontalFlip, ToTensor, Normalize
transforms.ColorJitter(),
transforms.RandomRotation(deg),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
elif args.da==5:
deg=random.random()*10
train_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.trainFile,
transform=transforms.Compose([
transforms.RandomCrop(114),
transforms.RandomHorizontalFlip(), # The order seriously matters: RandomHorizontalFlip, ToTensor, Normalize
transforms.RandomRotation(deg),
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5], std = [ 0.5, 0.5, 0.5 ]),
])),
batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
else:
pass
print ('Loading data from ' + args.root_path + args.testFile)
if args.da==5:
val_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.testFile,
transform=transforms.Compose([
transforms.CenterCrop(114),
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5], std = [0.5, 0.5, 0.5 ])
])),
batch_size=args.test_batch_size, shuffle=False, #### Shuffle should be switched off for face recognition of LFW
num_workers=args.workers, pin_memory=True)
else:
val_loader = torch.utils.data.DataLoader(
ImageList(root=args.root_path, fileList=args.root_path+args.testFile,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean = [0.5, 0.5, 0.5], std = [0.5, 0.5, 0.5 ])
])),
batch_size=args.test_batch_size, shuffle=False, #### Shuffle should be switched off for face recognition of LFW
num_workers=args.workers, pin_memory=True)
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# 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'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True # This flag allows you to enable the inbuilt cudnn auto-tuner to find the best algorithm to use for your hardware.
if args.evaluate:
validate(val_loader, model, criterion)
return
fp = open(args.root_path + 'results_ResNet' + str(args.depth) + '_DA' + str(args.da) + '_LR_' + str(args.lr) + '.txt', "a")
fp.write(str(seed)+'\n')
fp.close()
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch) # every epoch=10, the learning rate is divided by 10
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
fp = open(args.root_path + 'results_ResNet' + str(args.depth) + '_DA' + str(args.da) + '_LR_' + str(args.lr) + '.txt', "a")
fp.write('{0:.3f} \n'.format(prec1))
if epoch==args.epochs-1:
fp.write('\n \n \n')
fp.close()
# remember best prec@1 and save checkpoint
is_best = prec1 >best_prec1
best_prec1 = max(prec1, best_prec1)
parser.add_argument('data', metavar='DIR', help='path to dataset')
parser.add_argument('--workers', default=16, type=int, help='number of data loading workers')
parser.add_argument('--batch-size', default=1024, type=int, help='mini-batch size')
parser.add_argument('--gpu', default=None, type=int, help='GPU id to use.')
if __name__ == '__main__':
args = parser.parse_args()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
dataset = IndexedImageFolder(
args.data,
transforms.Compose([transforms.RandomApply([transforms.ColorJitter(0.8, 0.8, 0.8, 0.2)], p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.ToTensor(),
normalize])
)
data_loader = torch.utils.data.DataLoader(
dataset, batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True, sampler=None
)
print('Data loader size:', len(data_loader))
print('Image folder size:', len(data_loader.dataset))
iif_len = len(data_loader.dataset)
