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)