def _get_data_loader(self, config, names=None): trs = self.__transformations if names is None: train_names, val_names = self._split_data(self.__train_dir, config.train_percent) else: train_names, val_names = names train_folder = ImageFolder(self.__train_dir, train_names, transform=trs['train']) val_folder = ImageFolder(self.__train_dir, val_names, transform=trs['val']) if not len(train_folder) or not len(val_folder): raise ValueError('One of the image folders contains zero data, train: %s, val: %s' % \ (len(train_folder), len(val_folder))) sampler = None train_loader = torch.utils.data.DataLoader( train_folder, batch_size=config.batch_size, shuffle=True, sampler=sampler, num_workers=config.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(val_folder, batch_size=config.batch_size, shuffle=True, num_workers=config.workers, pin_memory=True) return train_loader, val_loader
def _get_data_loader(self, config, names=None): transformations = self.__transform_func() if names is None: train_names, val_names = self._split_data(self.__train_dir, config.train_percent) else: train_names, val_names = names loader = self.__get_loader(config) train_folder = ImageFolder(self.__label_file, self.__train_dir, train_names, transform=transformations['train'], loader=loader) val_folder = ImageFolder(self.__label_file, self.__train_dir, val_names, transform=transformations['val'], loader=loader) if not len(train_folder) or not len(val_folder): raise ValueError, 'One of the image folders contains zero data, train: %s, val: %s' % \ (len(train_folder), len(val_folder)) sampler = None if config.weigh_sample: sampler = WeightedRandomSampler(train_folder.weights, len(train_folder), replacement=True) train_loader = torch.utils.data.DataLoader(train_folder, batch_size=config.batch_size, shuffle=True, sampler=sampler, num_workers=config.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader(val_folder, batch_size=config.batch_size, shuffle=True, num_workers=config.workers, pin_memory=True) return train_loader, val_loader
def get_loader(root, split, batch_size, scale_size, num_workers=2, shuffle=True): dataset_name = os.path.basename(root) image_root = os.path.join(root, 'splits', split) if dataset_name in ['CelebA']: dataset = ImageFolder( root=image_root, transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(scale_size), transforms.ToTensor(), #transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) else: dataset = ImageFolder( root=image_root, transform=transforms.Compose([ transforms.Scale(scale_size), transforms.ToTensor(), #transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=shuffle, num_workers=int(num_workers)) data_loader.shape = [int(num) for num in dataset[0][0].size()] return data_loader
def __write_submission(self, res, thresholds, output_file=None, detailed_output_file=None): """Write final result into csv""" def sort_arg(filename): base, number = filename.split('_') number = int(number[:-4]) return base, number mapping = {i:k for i, k in enumerate(ImageFolder(self.__label_file, self.__train_dir).classes)} logger.info(str(mapping)) output_file = output_file or self.__output_file.format(self.__cur_fold) detailed_output_file = detailed_output_file or self.__detailed_output_file.format(self.__cur_fold) with open(output_file, 'w') as wf, open(detailed_output_file, 'w') as dwf: dwf.write(json.dumps({mapping[i]:v for i, v in enumerate(thresholds)}) + '\n') wf.write('image_name,tags\n') dwf.write('image_name,probs\n') for file_name, probs in sorted(res, key=lambda x: sort_arg(x[0])): name = file_name[:-4] labels, detailed_enc = [], [] for i, prob in enumerate(probs): if prob > thresholds[i]: labels.append(mapping[i]) detailed_enc.append('%s:%.5f' % (mapping[i], prob)) wf.write(','.join([name, ' '.join(labels)]) + '\n') dwf.write(','.join([name, ' '.join(detailed_enc)]) + '\n')
def test_model(args): # create model model = dla.__dict__[args.arch](pretrained=args.pretrained, pool_size=args.crop_size // 32) model = torch.nn.DataParallel(model) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {} prec {:.03f}) " .format(args.resume, checkpoint['epoch'], best_prec1)) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True data = dataset.get_data(args.data_name) if data is None: data = dataset.load_dataset_info(args.data, data_name=args.data_name) if data is None: raise ValueError('{} is not pre-defined in dataset.py and info.json ' 'does not exist in {}', args.data_name, args.data) # Data loading code valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=data.mean, std=data.std) if args.crop_10: t = transforms.Compose([ transforms.Resize(args.scale_size), transforms.ToTensor(), normalize]) else: t = transforms.Compose([ transforms.Resize(args.scale_size), transforms.CenterCrop(args.crop_size), transforms.ToTensor(), normalize]) val_loader = torch.utils.data.DataLoader( ImageFolder(valdir, t, out_name=args.crop_10), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) # define loss function (criterion) and pptimizer criterion = nn.CrossEntropyLoss() if args.cuda: model = model.cuda() criterion = criterion.cuda() if args.crop_10: validate_10(args, val_loader, model, '{}_i_{}_c_10.txt'.format(args.arch, args.start_epoch)) else: validate(args, val_loader, model, criterion)
def get_groundtruth(permitted): folder = ImageFolder(LABEL_FILE, TRAIN_FOLDER_TIF, set(permitted)) truth = map(lambda x: (x[0].split('.')[0], x[1].numpy()), folder.imgs) truth.sort() names, data = zip(*truth) data = np.array(data) return data
def init_data_loader(config, num_processes=4, path_feature=None): if os.path.exists(os.path.join(config["batches_dir"], "class_mapping.json")): import json with open(os.path.join(config["batches_dir"], "class_mapping.json"), "r") as f: obj = json.loads(f.read()) config["num_labels"] = len(obj) else: # The number of labels is the number of dirs in batches_dir label_dirs = [ p for p in os.listdir(config["batches_dir"]) if os.path.isdir(os.path.join(config["batches_dir"], p)) ] config["num_labels"] = len(label_dirs) # init dataset logging.info("Initializing data loader, this might take a while.....") all_transforms = _init_transforms(config["img_h"], config["img_w"], config["data_augmentation"]) if path_feature is not None: train_dataset = ImageFolderWithFeature(config["batches_dir"], path_feature, transform=all_transforms) else: train_dataset = ImageFolder(config["batches_dir"], transform=all_transforms) # init data loader # configure sampling strategy class_balanced_sampling = config["tri_loss_params"]["margin"] > 0 or \ config["batch_sampling_params"]["class_balanced"] if class_balanced_sampling: logging.info("Using class_balanced sampling strategy.") # construct data loader batch_size = config["batch_size"] if ( not class_balanced_sampling) else None shuffle = not class_balanced_sampling sampler = TripletSampler(config["batch_sampling_params"], train_dataset) \ if class_balanced_sampling else None data_loader = torch.utils.data.DataLoader(train_dataset, shuffle=shuffle, batch_size=batch_size, num_workers=num_processes, batch_sampler=sampler) # log training set info count = len(train_dataset) iterations_per_epoch = len(data_loader) logging.info( "[TRAINING SET INFO] number of example: %s, number of labels: %s, " "iterations_per_epoch: %s" % (count, config["num_labels"], iterations_per_epoch)) return data_loader
def store_delf_feature(cfg): # logging current_time = datetime.datetime.strftime(datetime.datetime.now(),'%Y-%m-%d %H:%M:%S') log_save_path = os.path.join(cfg.log_root, cfg.stage) os.makedirs(log_save_path, exist_ok=True) f = open(log_save_path+'/{}-train-{}.log'.format(current_time, cfg.stage), mode='w', encoding='utf-8') f.close() logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.INFO, filename=log_save_path+'/{}-train.log'.format(current_time)) print('loading dataset...') dataset = ImageFolder(root=cfg.index_img, transform=transforms.ToTensor()) dataloader = data.DataLoader(dataset=dataset, batch_size=1, shuffle=True, num_workers=2) print('dataset load done.') # model construct print('model construct...') model = get_delf_feature(cfg.kp_path) if torch.cuda.is_available(): model = model.cuda() model.eval() print('model load done.') # pca trained params h5file = h5py.File(os.path.join(cfg.pca_saved, 'pca.h5'), 'r') pca_mean = copy.deepcopy(h5file['.']['pca_mean'].value) pca_var = copy.deepcopy(h5file['.']['pca_vars'].value) pca_matrix = copy.deepcopy(h5file['.']['pca_matrix'].value) # delf_pca = DelfPCA(pca_n_components=cfg.pca_dims, whitening=True, pca_saved_path=cfg.pca_saved) delf_features = [] print('delf attention feature extracting...') pbar = tqdm(dataloader) for index, (inputs, _, filename) in enumerate(pbar): if torch.cuda.is_available(): inputs = inputs.cuda() try: delf_feature = getDelfFeatureFromMultiScale(stage='delf', inputs=inputs, model=model, filename=filename, \ pca_matrix=pca_matrix, pca_mean = pca_mean, pca_var=pca_var, pca_dims=cfg.pca_dims, rf=cfg.delf_rf, \ stride=cfg.delf_stride, padding=cfg.delf_padding,topk=cfg.topk, scales=cfg.scales, \ iou_thresh=cfg.iou_thres, attn_thres=cfg.atte_thres) except Exception as e: print(e) delf_feature = None if delf_feature != None: delf_features.append(delf_feature) msg = "image name: {}".format(filename[0]) pbar.set_description(desc=msg) logging.info(msg) print('delf features get done.') with open(os.path.join(cfg.delf_saved, 'index.delf'), 'wb') as delf_file: pickle.dump(delf_features, delf_file, protocol=2) print('saved DeLF feature at {}'.format(os.path.join(cfg.delf_saved, 'index.delf')))
def filter(): transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) dataset = ImageFolder(root=args.icdar_patches, transform=transform) loader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True) model = Extractor() for params in model.parameters(): params.requires_grad = False acc = clustering(loader=loader, model=model)
def get_loader(root, split, labels_per_class, batch_size, scale_size, num_workers=2, shuffle=True): image_root = os.path.join(root, 'splits', split) dataset = ImageFolder( root=image_root, transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(scale_size), transforms.ToTensor(), #transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) #transforms.Normalize((0.51, 0.42, 0.37), (0.27, 0.27, 0.27)) ])) ## TODO add target_transform=onehot(n_labels)?? if split == 'train': if labels_per_class != None: data_loader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=shuffle, num_workers=int(num_workers), sampler=get_sampler(dataset.train_labels.numpy(), labels_per_class)) else: data_loader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=shuffle, num_workers=int(num_workers)) else: data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=shuffle, num_workers=int(num_workers)) data_loader.shape = [int(num) for num in dataset[0][0].size()] return data_loader
def main_worker(args): args.device = torch.device( 'cuda:{}'.format(args.gpu) if torch.cuda.is_available() else 'cpu') if args.pretrained: print('=> using pre-trained model') model = init_encoder_model(args.embed_size, args.pretrained) else: print('=> Pretrained model not specified.') return model = model.to(args.device) e_weights = torch.FloatTensor(train_label_emb()) label_model = nn.Embedding.from_pretrained(e_weights) label_model = label_model.to(args.device) # Data loading code print("Initializing Datasets and Dataloaders...") transformer = transforms.Compose([ transforms.Resize(args.input_size), transforms.CenterCrop(args.input_size), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # Create training and validation datasets image_datasets = ImageFolder(os.path.join(args.data, 'test'), transformer) # Create training and validation dataloaders dataloaders = torch.utils.data.DataLoader(image_datasets, batch_size=args.batch_size, shuffle=True, num_workers=4) print('Evaluating') validate(dataloaders, model, label_model, args) print('Finished')
def train(loader, model, clf): print("============>training<============") test_dataset = ImageFolder(root="./data/icdar2015/test_patches", transform=transforms) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=20, shuffle=True) pbar = tqdm(total=len(loader)) for cnt, data in enumerate(loader): pbar.update(1) im, ann, im_fns = data[0], data[1], data[2] im = im.cuda() feat = model(im) x = feat.cpu().numpy() y = ann.numpy() try: clf.fit(x, y) except ValueError: continue pbar.close() print("\n") print("============>testing<============") test(test_loader, clf)
def train_pca(cfg): # logging current_time = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S') log_save_path = os.path.join(cfg.log_root, cfg.stage) os.makedirs(log_save_path, exist_ok=True) f = open(log_save_path + '/{}-train-pca.log'.format(current_time), mode='w', encoding='utf-8') f.close() logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.INFO, filename=log_save_path + '/{}-train.log'.format(current_time)) print('loading dataset...') dataset = ImageFolder(root=cfg.index_img, transform=transforms.ToTensor()) dataloader = data.DataLoader(dataset=dataset, batch_size=1, shuffle=True, num_workers=2) print('dataset load done.') # model construct print('model construct...') model = get_delf_feature(cfg.kp_path) if torch.cuda.is_available(): model = model.cuda() model.eval() print('model load done.') delf_pca = DelfPCA(pca_n_components=cfg.pca_dims, pca_saved_path=cfg.pca_saved) feature_maps = [] print('delf attention feature extracting...') features_num = 0 pbar = tqdm(dataloader) for (inputs, _, filename) in pbar: if torch.cuda.is_available(): inputs = inputs.cuda() try: output = getDelfFeatureFromMultiScale(stage='pca', inputs=inputs, model=model, filename=filename, \ pca_matrix=None, pca_var=None, pca_dims=cfg.pca_dims, rf=cfg.delf_rf, \ stride=cfg.delf_stride, padding=cfg.delf_padding,topk=cfg.topk, scales=cfg.scales, \ iou_thresh=cfg.iou_thres, attn_thres=cfg.atte_thres) except Exception as e: print(e) descriptor_np_list = output['descriptor_np_list'] pca_feature = [ descriptor_np_list[i, :] for i in range(descriptor_np_list.shape[0]) ] # 将ndarray变成列表 feature_maps.extend(pca_feature) curr_fea_nums = descriptor_np_list.shape[0] features_num += curr_fea_nums msg = "curr feature nums: {}".format(features_num) pbar.set_description(desc=msg) logging.info(filename[0] + "-feature nums: {}".format(curr_fea_nums)) print('features get done. Total feature nums: {}'.format(features_num)) print('start train pca...') delf_pca(feature_maps) print('pca trained done. saved at {}'.format(cfg.pca_saved + 'pca.h5'))
def extract(self, input_path, output_path): '''extract features from single image without batch process. ''' assert self.mode.lower() in ['pca', 'delf'] batch_timer = AverageMeter() data_timer = AverageMeter() since = time.time() # dataloader. dataset = ImageFolder( root = input_path, transform = transforms.ToTensor()) self.dataloader = torch.utils.data.DataLoader( dataset = dataset, batch_size = 1, shuffle = True, num_workers = 0) feature_maps = [] if self.mode.lower() in ['pca']: # bar = Bar('[{}]{}'.format(self.mode.upper(), self.title), max=len(self.dataloader)) for batch_idx, (inputs, _, filename) in enumerate(self.dataloader): # image size upper limit. if not (len(inputs.size()) == 4): if __DEBUG__: print('wrong input dimenstion! ({},{})'.format(filename, input.size())) continue; if not (inputs.size(2)*inputs.size(3) <= 1200*1200): if __DEBUG__: print('passed: image size too large! ({},{})'.format(filename, inputs.size())) continue; if not (inputs.size(2) >= 112 and inputs.size(3) >= 112): if __DEBUG__: print('passed: image size too small! ({},{})'.format(filename, inputs.size())) continue; data_timer.update(time.time() - since) # prepare inputs if __is_cuda__(): inputs = __cuda__(inputs) inputs = __to_var__(inputs) # get delf feature only for pca calculation. pca_feature = self.__extract_delf_feature__(inputs.data, filename, mode='pca') if pca_feature is not None: feature_maps.extend(pca_feature) batch_timer.update(time.time() - since) since = time.time() # progress log_msg = ('\n[Extract][Processing:({batch}/{size})] '+ \ 'eta: (data:{data:.3f}s),(batch:{bt:.3f}s),(total:{tt:})') \ .format( batch=batch_idx + 1, size=len(self.dataloader), data=data_timer.val, bt=batch_timer.val, tt=0)#bar.elapsed_td print(log_msg) # bar.next() print('\nnumber of selected features so far: {}'.format(len(feature_maps))) if len(feature_maps) >= 10000000: # UPPER LIMIT. break; # free GPU cache every. if batch_idx % 10 == 0: torch.cuda.empty_cache() if __DEBUG__: print('GPU Memory flushed !!!!!!!!!') # trian PCA. self.pca(feature_maps) else: # bar = Bar('[{}]{}'.format(self.mode.upper(), self.title), max=len(self.dataloader)) assert self.mode.lower() in ['delf'] feature_maps = [] for batch_idx, (inputs, labels, filename) in enumerate(self.dataloader): # image size upper limit. if not (len(inputs.size()) == 4): if __DEBUG__: print('wrong input dimenstion! ({},{})'.format(filename, input.size())) continue; if not (inputs.size(2)*inputs.size(3) <= 1200*1200): if __DEBUG__: print('passed: image size too large! ({},{})'.format(filename, inputs.size())) continue; if not (inputs.size(2) >= 112 and inputs.size(3) >= 112): if __DEBUG__: print('passed: image size too small! ({},{})'.format(filename, inputs.size())) continue; data_timer.update(time.time() - since) # prepare inputs source_input = inputs if __is_cuda__(): inputs = __cuda__(inputs) inputs = __to_var__(inputs) # get delf everything (score, feature, etc.) delf_feature = self.__extract_delf_feature__(inputs.data, filename, mode='delf') # if delf_feature is not None: # feature_maps.append(delf_feature) # log. batch_timer.update(time.time() - since) since = time.time() log_msg = ('\n[Extract][Processing:({batch}/{size})] '+ \ 'eta: (data:{data:.3f}s),(batch:{bt:.3f}s),(total:{tt:})') \ .format( batch=batch_idx + 1, size=len(self.dataloader), data=data_timer.val, bt=batch_timer.val, tt=0)#bar.elapsed_td print(log_msg) # bar.next() # free GPU cache every. if batch_idx % 10 == 0: torch.cuda.empty_cache() if __DEBUG__: print('GPU Memory flushed !!!!!!!!!') save_path = "/media/liesmars/SSD1/vearch/plugin/src/streetView/DeLF-pytorch/extract/output" img_path = "/media/liesmars/SSD1/vearch/plugin/src/streetView/DeLF-pytorch/extract/testdata/_9oMPkzl60LSzvxIlG2FZA(22.279587,114.167117)" if True: # for b in range(len(inputs)): imgname = delf_feature["filename"][0] # img = source_input.squeeze().numpy()*255 # img = img.astype(np.uint8) img=cv2.imread(os.path.join(img_path, imgname)) # print(img) # cv2.imshow('image', img) # cv2.waitKey(100) feature_loc = delf_feature["location_np_list"] for loc in feature_loc: # cv2.circle(img, ) img = cv2.circle(img,(int(loc[0]),int(loc[1])),2,(0,0,230),-1) cv2.imwrite(os.path.join(save_path, imgname), img) print("save")
def __init__(self, params): self.params = params # specify the gpu id if using only 1 gpu if params.ngpu == 1: os.environ['CUDA_VISIBLE_DEVICES'] = str(params.gpu_id) try: os.makedirs(params.outf) except OSError: pass if params.manualSeed is None: params.manualSeed = random.randint(1, 10000) print("Random Seed: ", params.manualSeed) random.seed(params.manualSeed) torch.manual_seed(params.manualSeed) if params.cuda: torch.cuda.manual_seed_all(params.manualSeed) cudnn.benchmark = True if torch.cuda.is_available() and not params.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) # datase t if params.dataset == 'imagenet': # folder dataset self.dataset = ImageFolder( root=params.dataroot, transform=transforms.Compose([ transforms.Scale(params.imageSize), transforms.CenterCrop(params.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]), classes_idx=(10, 20)) elif params.dataset == 'cifar10': self.dataset = dset.CIFAR10(root=params.dataroot, download=True, transform=transforms.Compose([ transforms.Scale(params.imageSize), transforms.ToTensor(), transforms.Normalize( (0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) else: raise NotImplementedError("No such dataset {}".format( params.dataset)) assert self.dataset self.dataloader = torch.utils.data.DataLoader( self.dataset, batch_size=params.batchSize, shuffle=True, num_workers=int(params.workers)) # some hyper parameters self.ngpu = int(params.ngpu) self.nz = int(params.nz) self.ngf = int(params.ngf) self.ndf = int(params.ndf) self.num_classes = int(params.num_classes) self.nc = 3 # Define the generator and initialize the weights if params.dataset == 'imagenet': self.netG = _netG(self.ngpu, self.nz) else: self.netG = _netG_CIFAR10(self.ngpu, self.nz) self.netG.apply(weights_init) if params.netG != '': self.netG.load_state_dict(torch.load(params.netG)) print(self.netG) # Define the discriminator and initialize the weights if params.dataset == 'imagenet': self.netD = _netD(self.ngpu, self.num_classes) else: self.netD = _netD_CIFAR10(self.ngpu, self.num_classes) self.netD.apply(weights_init) if params.netD != '': self.netD.load_state_dict(torch.load(params.netD)) print(self.netD) # loss functions self.dis_criterion = nn.BCELoss() self.aux_criterion = nn.NLLLoss() # tensor placeholders self.input = torch.FloatTensor(params.batchSize, 3, params.imageSize, params.imageSize) self.noise = torch.FloatTensor(params.batchSize, self.nz, 1, 1) self.eval_noise = torch.FloatTensor(params.batchSize, self.nz, 1, 1).normal_(0, 1) self.dis_label = torch.FloatTensor(params.batchSize) self.aux_label = torch.LongTensor(params.batchSize) self.real_label = 1 self.fake_label = 0 # if using cuda if params.cuda: self.netD.cuda() self.netG.cuda() self.dis_criterion.cuda() self.aux_criterion.cuda() self.input, self.dis_label, self.aux_label = self.input.cuda( ), self.dis_label.cuda(), self.aux_label.cuda() self.noise, self.eval_noise = self.noise.cuda( ), self.eval_noise.cuda() # define variables self.input = Variable(self.input) self.noise = Variable(self.noise) self.eval_noise = Variable(self.eval_noise) self.dis_label = Variable(self.dis_label) self.aux_label = Variable(self.aux_label) # noise for evaluation self.eval_noise_ = np.random.normal(0, 1, (params.batchSize, self.nz)) self.eval_label = np.random.randint(0, self.num_classes, params.batchSize) self.eval_onehot = np.zeros((params.batchSize, self.num_classes)) self.eval_onehot[np.arange(params.batchSize), self.eval_label] = 1 self.eval_noise_[np.arange(params.batchSize), :self. num_classes] = self.eval_onehot[np.arange( params.batchSize)] self.eval_noise_ = (torch.from_numpy(self.eval_noise_)) self.eval_noise.data.copy_( self.eval_noise_.view(params.batchSize, self.nz, 1, 1)) # setup optimizer self.optimizerD = optim.Adam(self.netD.parameters(), lr=params.lr, betas=(params.beta1, 0.999)) self.optimizerG = optim.Adam(self.netG.parameters(), lr=params.lr, betas=(params.beta1, 0.999))
def main_worker(args): global best_acc1 args.device = torch.device( 'cuda:{}'.format(args.gpu) if torch.cuda.is_available() else 'cpu') if args.pretrained: print('=> using pre-trained model') model = init_encoder_model(args.embed_size, args.pretrained) else: print('=> creating model') model = init_encoder_model(args.embed_size, args.pretrained) model = model.to(args.device) # print("Params to learn:") # model_params = [] # for name, param in dict(model.named_parameters()).items(): # if name.find("bias") > -1: # print('Model Layer {} will be trained @ {}'.format(name, args.lr*2)) # model_params.append({'params': param, 'lr': args.lr*2, 'weight_decay': 0}) # else: # print('Model Layer {} will be trained @ {}'.format(name, args.lr)) # model_params.append({'params': param, 'lr': args.lr, 'weight_decay': args.weight_decay}) e_weights = torch.FloatTensor(train_label_emb()) label_model = nn.Embedding.from_pretrained(e_weights) label_model = label_model.to(args.device) optimizer = optim.SGD(model.parameters(), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # define loss function (criterion) and optimizer criterion = nn.CrossEntropyLoss().to(args.device) # 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_acc1 = checkpoint['best_acc1'] if args.gpu is not None: # best_acc1 may be from a checkpoint from a different GPU best_acc1 = best_acc1.to(args.gpu) 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)) # Data loading code data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(args.input_size), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(args.input_size), transforms.CenterCrop(args.input_size), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } print("Initializing Datasets and Dataloaders...") # Create training and validation datasets image_datasets = { x: ImageFolder(os.path.join(args.data, x), data_transforms[x]) for x in ['train', 'val'] } # Create training and validation dataloaders dataloaders_dict = { x: torch.utils.data.DataLoader(image_datasets[x], batch_size=args.batch_size, shuffle=True, num_workers=4) for x in ['train', 'val'] } if args.evaluate: validate(dataloaders_dict['val'], model, criterion, args) return for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch, args) # train for one epoch train(dataloaders_dict['train'], model, label_model, criterion, optimizer, epoch, args) # evaluate on validation set acc1 = validate(dataloaders_dict['val'], model, label_model, criterion, args) # remember best acc@1 and save checkpoint is_best = acc1 > best_acc1 best_acc1 = max(acc1, best_acc1) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer': optimizer.state_dict(), }, is_best)
############# DataLoader ###################### if opt.dataset == 'lsun': dataset = dset.LSUN(db_path=opt.dataroot, classes=['bedroom_train'], transform=transforms.Compose([ transforms.Scale(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) elif opt.dataset == 'CelebA': dataset = ImageFolder(root=opt.dataroot, transform=transforms.Compose([ transforms.Resize(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) assert dataset dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize, shuffle=True, num_workers=int(opt.workers)) nz = int(opt.nz) ngf = int(opt.ngf) ndf = int(opt.ndf) nc = int(opt.nc)
args = parser.parse_args() data_dir = os.path.join('.', args.dataset) print(args.dataset) train_transform = transforms.Compose([transforms.ToTensor()]) if args.dataset == "cifar10": train_set = torchvision.datasets.CIFAR10(root=data_dir, train=True, download=True, transform=train_transform) print(type(train_set.train_data)) print(train_set.train_data.shape) print(train_set.__getitem__(0)[0].size()) print(train_set.train_data.mean(axis=(0, 1, 2))/255) print(train_set.train_data.std(axis=(0, 1, 2))/255) train_set = ImageFolder("cifar10/images/train", transform=train_transform) image_tensor = torch.stack([x for x, y in train_set]) image_tensor = image_tensor.numpy() print(image_tensor.shape) print(train_set.__getitem__(0)[0].size()) print(image_tensor.mean(axis=(0, 2, 3))) print(image_tensor.std(axis=(0, 2, 3))) elif args.dataset == "cifar100": train_set = torchvision.datasets.CIFAR100(root=data_dir, train=True, download=True, transform=train_transform) print(train_set.train_data.shape) print(np.mean(train_set.train_data, axis=(0, 1, 2))/255) print(np.std(train_set.train_data, axis=(0, 1, 2))/255) elif args.dataset == "mnist": train_set = torchvision.datasets.MNIST(root=data_dir, train=True, download=True, transform=train_transform)
'val': transforms.Compose(transform_val_list), 'satellite': transforms.Compose(transform_satellite_list)} train_all = '' if opt.train_all: train_all = '_all' image_datasets = {} image_datasets['satellite'] = datasets.ImageFolder(os.path.join(data_dir, 'satellite'), data_transforms['satellite']) image_datasets['street'] = datasets.ImageFolder(os.path.join(data_dir, 'street'), data_transforms['train']) image_datasets['drone'] = datasets.ImageFolder(os.path.join(data_dir, 'drone'), data_transforms['train']) image_datasets['google'] = ImageFolder(os.path.join(data_dir, 'google'), # google contain empty subfolder, so we overwrite the Folder data_transforms['train']) dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=opt.batchsize, shuffle=True, num_workers=2, pin_memory=True) # 8 workers may work faster for x in ['satellite', 'street', 'drone', 'google']} dataset_sizes = {x: len(image_datasets[x]) for x in ['satellite', 'street', 'drone', 'google']} class_names = image_datasets['street'].classes print(dataset_sizes) use_gpu = torch.cuda.is_available() ###################################################################### # Training the model # ------------------ # # Now, let's write a general function to train a model. Here, we will
transforms.Scale(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) data_dir = 'hymenoptera_data' train_dataset = datasets.ImageFolder(os.path.join(data_dir, 'train'), transform=transform_train) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True) train_infl = ImageFolder(os.path.join(data_dir, 'train'), transform=transform_train) loader_hess = DataLoader(train_infl, batch_size=args.batch_size, shuffle=True, num_workers=10) loader_infl = DataLoader(train_infl, batch_size=1, shuffle=False) val_dataset = ImageFolder(os.path.join(data_dir, 'val'), transform=transform_val) val_loader = DataLoader(val_dataset, batch_size=1, shuffle=False) file_time = time.strftime('%Y-%m-%d-%H:%M:%S')
random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) # specify the gpu id if using only 1 gpu if opt.ngpu == 1: os.environ['CUDA_VISIBLE_DEVICES'] = str(opt.gpu_id) if opt.cuda: torch.cuda.manual_seed_all(opt.manualSeed) cudnn.benchmark = True # dataset dataset = ImageFolder( root=opt.dataroot, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) ) dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt.batchSize, shuffle=True, num_workers=int(opt.workers)) # model netVAE = VAE() criterion = CustomLoss(3e-6) optimizer = optim.Adam(netVAE.parameters(), lr=0.0001, betas=(0.5, 0.999)) if opt.cuda: netVAE.cuda()
def make_dir(dir): try: os.mkdir(dir) except Exception as e: pass import numpy as np if __name__ == '__main__': data_root = config.dataset landmark_save_root = config.save landmark_save_dir = landmark_save_root + '/{}' landmark_save_path = landmark_save_dir + '/{}' dataset = ImageFolder(root=data_root) dataloader = data.DataLoader(dataset, batch_size=4, shuffle=False, num_workers=0, collate_fn=collate_fn, pin_memory=False) print('data loaded') print(len(dataset)) make_dir(landmark_save_root) maked_label = {} for i, it in enumerate(dataloader): for image, label, fname in it: fname = fname.split('.')[0] + '.png'
def get_dataset(args): ### explicitly set flip = True ####### if args.dataset == "cityscape": # if 'Det' in args.frame_disc_model or 'Det' in args.video_disc_model or args.frame_det_disc or args.video_det_disc: clip_file = "/data/linz/proj/Dataset/Cityscape/load_files/int_{}_len_3_max_{}bb_area_3000_extra_panet_lsclip.pkl".format( int(args.interval), int(args.num_track_per_img)) # if not args.track_gen and args.split == 'val': # clip_file = "/data/linz/proj/Dataset/Cityscape/load_files/int_{}_len_3_extra_lsclip.pkl".format(int(args.interval)) obj_coord_file = "/data/linz/proj/Dataset/Cityscape/obj_coords/int_{}_len_3_extra_512x1024_max_{}bb_area_3000_panet_lsclip.pkl".format( int(args.interval), int(args.num_track_per_img)) if args.syn_type == 'extra' and args.vid_length != 1: clip_file = "/data/linz/proj/Dataset/Cityscape/load_files/int_{}_len_{}_extra_lsclip.pkl".format( int(args.interval), args.vid_length + 2) if args.effec_flow: clip_file = "/data/linz/proj/Dataset/Cityscape/load_files/effec_flow_int_{}_len_3_extra_lsclip.pkl".format( int(args.interval)) import pickle with open(clip_file, 'rb') as f: load_f = pickle.load(f) if args.split == 'train': clips_train_file = load_f['train'] elif args.split == 'val': clips_val_file = load_f['val'] with open(obj_coord_file, 'rb') as f: load_f = pickle.load(f) if args.split == 'train': coords_train_file = load_f['train'] if args.split == 'val': coords_val_file = load_f['val'] # else: # coords_val_file = None crop_size = (args.input_h, args.input_w) if args.split == 'train': # train tfs = [] tfs.append( transforms.Compose( [ #transforms.Resize(re_size, interpolation=Image.BILINEAR), transforms.RandomCrop(crop_size) ])) # tfs.append(transforms.Compose([ transforms.Resize((150, 300), interpolation=Image.NEAREST), # transforms.RandomCrop((128, 256)) ])) tfs.append( transforms.Compose( [ #transforms.Resize((150, 300), interpolation=Image.NEAREST), transforms.RandomCrop(crop_size) ])) train_dataset = ImageFolder(args, clips_train_file, transform=tfs, bboxes=coords_train_file) else: train_dataset = None if args.split == 'val': # val tfs = [] tfs.append( transforms.Compose( [ #transforms.Resize(crop_size, interpolation=Image.BILINEAR) ])) tfs.append( transforms.Compose( [ #transforms.Resize((128, 256), interpolation=Image.NEAREST) ])) val_dataset = ImageFolder(args, clips_val_file, transform=tfs, bboxes=coords_val_file) else: val_dataset = None elif args.dataset == "ucf101": clip_file = "/data/linz/proj/Dataset/CyclicGen-master/UCF101_test_root_clip.pkl" with open(clip_file, 'rb') as f: import pickle load_f = pickle.load(f) clips_val_file = load_f['test'] re_size = (256, 256) crop_size = (256, 256) train_dataset = None # val tfs = [] tfs.append( transforms.Compose( [transforms.Resize(crop_size, interpolation=Image.BILINEAR)])) tfs.append( transforms.Compose( [transforms.Resize((256, 256), interpolation=Image.NEAREST)])) val_dataset = ImageFolder(args, clips_val_file, transform=tfs) # val_dataset = ImageFolder(args, clips_val_file,transform=None) elif args.dataset == 'vimeo': clip_train_file = '/data/linz/proj/Dataset/vimeo_triplet/tri_trainlist.txt' clip_val_file = '/data/linz/proj/Dataset/vimeo_triplet/tri_testlist.txt' clips_file = {'train': [], 'val': []} with open(clip_train_file, 'r') as f: for line in f: line = line.strip() if len(line) < 4: break clips_file['train'].append(line) with open(clip_val_file, 'r') as f: for line in f: line = line.strip() if len(line) < 4: break clips_file['val'].append(line) # crop_size = (128, 224) # train tfs = [] tfs.append( transforms.Compose( [ #transforms.Resize(re_size, interpolation=Image.BILINEAR), # transforms.RandomCrop(crop_size) ])) # tfs.append(transforms.Compose([ transforms.Resize((150, 300), interpolation=Image.NEAREST), # transforms.RandomCrop((128, 256)) ])) tfs.append( transforms.Compose( [ #transforms.Resize((150, 300), interpolation=Image.NEAREST), # transforms.RandomCrop(crop_size) ])) train_dataset = ImageFolder(args, clips_file['train'], transform=tfs) # val tfs = [] tfs.append( transforms.Compose( [ #transforms.Resize(crop_size, interpolation=Image.BILINEAR) ])) tfs.append( transforms.Compose( [ #transforms.Resize((128, 256), interpolation=Image.NEAREST) ])) val_dataset = ImageFolder(args, clips_file['val'], transform=tfs) else: raise Exception('Invalid dataset %s' % args.dataset) return train_dataset, val_dataset
def execute(execution_path, writer): print(cudnn.benchmark) print(cudnn.deterministic) if args.dataset == "mnist": args.number_of_dataset_classes = 10 dataset_path = args.dataset_dir if args.dataset_dir else "../datasets/mnist/images" normalize = transforms.Normalize(mean=[0.1307], std=[0.3081]) train_transform = transforms.Compose( [transforms.ToTensor(), normalize]) inference_transform = transforms.Compose([transforms.ToTensor(), normalize]) elif args.dataset == "cifar10": args.number_of_dataset_classes = 10 dataset_path = args.dataset_dir if args.dataset_dir else "../datasets/cifar10/images" normalize = transforms.Normalize(mean=[0.491, 0.482, 0.446], std=[0.247, 0.243, 0.261]) train_transform = transforms.Compose( [transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize]) inference_transform = transforms.Compose([transforms.ToTensor(), normalize]) elif args.dataset == "cifar100": args.number_of_dataset_classes = 100 dataset_path = args.dataset_dir if args.dataset_dir else "../datasets/cifar100/images" normalize = transforms.Normalize(mean=[0.507, 0.486, 0.440], std=[0.267, 0.256, 0.276]) train_transform = transforms.Compose( [transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize]) inference_transform = transforms.Compose([transforms.ToTensor(), normalize]) else: args.number_of_dataset_classes = 1000 dataset_path = args.dataset_dir if args.dataset_dir else "../datasets/imagenet2012/images" if args.arch.startswith('inception'): size = (299, 299) else: size = (224, 256) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transform = transforms.Compose( [transforms.RandomSizedCrop(size[0]), # 224 , 299 transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize]) inference_transform = transforms.Compose( [transforms.Scale(size[1]), # 256 transforms.CenterCrop(size[0]), # 224 , 299 transforms.ToTensor(), normalize]) args.normal_classes = sorted(random.sample(range(0, args.number_of_dataset_classes), args.number_of_model_classes)) print("NORMAL CLASSES:\t", args.normal_classes) train_path = os.path.join(dataset_path, 'train') test_path = os.path.join(dataset_path, 'val') # Creating sets... train_set = ImageFolder(train_path, transform=train_transform, selected_classes=args.normal_classes, target_transform=args.normal_classes.index) val_set = ImageFolder(train_path, transform=inference_transform, selected_classes=args.normal_classes, target_transform=args.normal_classes.index) # Preparing train and validation samplers... total_examples = {} for index in range(len(train_set)): _, label = train_set[index] if label not in total_examples: total_examples[label] = 1 else: total_examples[label] += 1 train_indexes = [] val_indexes = [] train_indexes_count = {} val_indexes_count = {} indexes_count = {} for index in range(len(train_set)): _, label = train_set[index] if label not in indexes_count: indexes_count[label] = 1 train_indexes.append(index) train_indexes_count[label] = 1 val_indexes_count[label] = 0 else: indexes_count[label] += 1 if indexes_count[label] <= int(total_examples[label] * args.train_set_split): train_indexes.append(index) train_indexes_count[label] += 1 else: val_indexes.append(index) val_indexes_count[label] += 1 print("TRAIN SET INDEXES TOTALS:", train_indexes_count) print("VALID SET INDEXES TOTALS:", val_indexes_count) train_sampler = SubsetRandomSampler(train_indexes) val_sampler = SubsetRandomSampler(val_indexes) # Create loaders... train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, sampler=train_sampler) val_loader = torch.utils.data.DataLoader(val_set, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, sampler=val_sampler) print("\n$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print("TRAINSET LOADER SIZE: ====>>>> ", len(train_loader.sampler)) print("VALIDSET LOADER SIZE: ====>>>> ", len(val_loader.sampler)) print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") # Dataset created... print("\nDATASET:", args.dataset) # create model model = create_model() print("\nMODEL:", model) best_train_acc1 = 0 best_val_acc1 = 0 if args.train: ################### # Training... ################### # define loss function (criterion)... criterion = nn.CrossEntropyLoss().cuda() # define optimizer... optimizer = torch.optim.SGD(model.parameters(), lr=args.original_learning_rate, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # define scheduler... scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=10, factor=0.2, verbose=True) print("\n################ TRAINING ################") best_model_file_path = os.path.join(execution_path, 'best_model.pth.tar') best_train_acc1, best_val_acc1 = train_val(train_loader, val_loader, model, criterion, optimizer, scheduler, args.epochs, writer, best_model_file_path) # save to json file writer.export_scalars_to_json(os.path.join(execution_path, 'log.json')) if args.extract_logits: ###################### # Extracting logits... ###################### # Train dataset uses val transform to extract... train_set = ImageFolder(train_path, transform=inference_transform, selected_classes=args.normal_classes) train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, sampler=train_sampler) val_set = ImageFolder(train_path, transform=inference_transform, selected_classes=args.normal_classes) val_loader = torch.utils.data.DataLoader(val_set, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, sampler=val_sampler) test_set = ImageFolder(test_path, transform=inference_transform) test_loader = torch.utils.data.DataLoader(test_set, batch_size=args.batch_size, num_workers=args.workers, pin_memory=True, shuffle=True) print("\n################ EXTRACTING LOGITS ################") best_model_file_path = os.path.join(execution_path, 'best_model.pth.tar') extract_logits_from_file(best_model_file_path, model, args.number_of_model_classes, execution_path, train_loader, val_loader, test_loader, "best_model") return best_val_acc1, best_train_acc1
<h1>Results</h1> {} '''.format(full_filename, " ".join(html_imgs)) return html else: html = ''' <!doctype html> <title>Upload new File</title> <h1>Upload new File</h1> <form method=post enctype=multipart/form-data> <input type=file name=file> <input type=submit value=Upload> </form> ''' return html if __name__ == '__main__': data = ImageFolder('./Flickr', transform=TRANSFORM) kwargs = {'num_workers': 1, 'pin_memory': True} if CUDA else {} data_loader = torch.utils.data.DataLoader(data, batch_size=BATCH_SIZE, **kwargs) search_engine = SearchEngine(data, cuda = CUDA, threshold = THRESHOLD, save_directory = SAVE_DIRECTORY, transform=TRANSFORM) search_engine.fit(data_loader = data_loader, load_embeddings = True, verbose = True) app.debug = False app.run( host=os.getenv('LISTEN', '0.0.0.0'), port=int(os.getenv('PORT', '80')) )
pbar.update(1) im, ann, im_fns = data[0], data[1], data[2] im = im.cuda() feat = model(im) x = feat.cpu().numpy() y = ann.numpy() precision = precision + clf.score(x, y) pbar.close() print("\nAverage Precision is {}".format(precision / len(loader))) if __name__ == '__main__': icdar_patches = "./data/icdar2015/patches" dataset = ImageFolder(root=icdar_patches, transform=transforms) loader = torch.utils.data.DataLoader(dataset, batch_size=20, shuffle=True) # extractor for deep features model = Extractor() model = model.cuda() for params in model.parameters(): params.requires_grad = False # vanilla svm clf = svm.SVC(kernel="rbf", gamma=10) train(loader=loader, model=model, clf=clf)
cudnn.benchmark = True if torch.cuda.is_available() and not opt.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) # datase t if opt.dataset == 'imagenet': # folder dataset dataset = ImageFolder(root=opt.dataroot, transform=transforms.Compose([ transforms.Scale(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]), classes_idx=(10, 20)) elif opt.dataset == 'AWA': # folder dataset dataset = dset.ImageFolder(root=opt.dataroot, transform=transforms.Compose([ transforms.Scale(opt.imageSize), transforms.CenterCrop(opt.imageSize), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])) elif opt.dataset == 'CUB':
def extract(self, input_path, output_path): '''extract features from single image without batch process. ''' assert self.mode.lower() in ['pca', 'delf'] batch_timer = AverageMeter() data_timer = AverageMeter() since = time.time() # dataloader. dataset = ImageFolder( root = input_path, transform = transforms.ToTensor()) self.dataloader = torch.utils.data.DataLoader( dataset = dataset, batch_size = 1, shuffle = True, num_workers = 0) feature_maps = [] if self.mode.lower() in ['pca']: bar = Bar('[{}]{}'.format(self.mode.upper(), self.title), max=len(self.dataloader)) for batch_idx, (inputs, _, filename) in enumerate(self.dataloader): # image size upper limit. if not (len(inputs.size()) == 4): if __DEBUG__: print('wrong input dimenstion! ({},{})'.format(filename, input.size())) continue; if not (inputs.size(2)*inputs.size(3) <= 1200*1200): if __DEBUG__: print('passed: image size too large! ({},{})'.format(filename, inputs.size())) continue; if not (inputs.size(2) >= 112 and inputs.size(3) >= 112): if __DEBUG__: print('passed: image size too small! ({},{})'.format(filename, inputs.size())) continue; data_timer.update(time.time() - since) # prepare inputs if __is_cuda__(): inputs = __cuda__(inputs) inputs = __to_var__(inputs) # get delf feature only for pca calculation. pca_feature = self.__extract_delf_feature__(inputs.data, filename, mode='pca') if pca_feature is not None: feature_maps.extend(pca_feature) batch_timer.update(time.time() - since) since = time.time() # progress log_msg = ('\n[Extract][Processing:({batch}/{size})] '+ \ 'eta: (data:{data:.3f}s),(batch:{bt:.3f}s),(total:{tt:})') \ .format( batch=batch_idx + 1, size=len(self.dataloader), data=data_timer.val, bt=batch_timer.val, tt=bar.elapsed_td) print(log_msg) bar.next() print('\nnumber of selected features so far: {}'.format(len(feature_maps))) if len(feature_maps) >= 10000000: # UPPER LIMIT. break; # free GPU cache every. if batch_idx % 10 == 0: torch.cuda.empty_cache() if __DEBUG__: print('GPU Memory flushed !!!!!!!!!') # trian PCA. self.pca(feature_maps) else: bar = Bar('[{}]{}'.format(self.mode.upper(), self.title), max=len(self.dataloader)) assert self.mode.lower() in ['delf'] feature_maps = [] for batch_idx, (inputs, labels, filename) in enumerate(self.dataloader): # image size upper limit. if not (len(inputs.size()) == 4): if __DEBUG__: print('wrong input dimenstion! ({},{})'.format(filename, input.size())) continue; if not (inputs.size(2)*inputs.size(3) <= 1200*1200): if __DEBUG__: print('passed: image size too large! ({},{})'.format(filename, inputs.size())) continue; if not (inputs.size(2) >= 112 and inputs.size(3) >= 112): if __DEBUG__: print('passed: image size too small! ({},{})'.format(filename, inputs.size())) continue; data_timer.update(time.time() - since) # prepare inputs if __is_cuda__(): inputs = __cuda__(inputs) inputs = __to_var__(inputs) # get delf everything (score, feature, etc.) delf_feature = self.__extract_delf_feature__(inputs.data, filename, mode='delf') if delf_feature is not None: feature_maps.append(delf_feature) # log. batch_timer.update(time.time() - since) since = time.time() log_msg = ('\n[Extract][Processing:({batch}/{size})] '+ \ 'eta: (data:{data:.3f}s),(batch:{bt:.3f}s),(total:{tt:})') \ .format( batch=batch_idx + 1, size=len(self.dataloader), data=data_timer.val, bt=batch_timer.val, tt=bar.elapsed_td) print(log_msg) bar.next() # free GPU cache every. if batch_idx % 10 == 0: torch.cuda.empty_cache() if __DEBUG__: print('GPU Memory flushed !!!!!!!!!') # use pickle to save DeLF features. self.__save_delf_features_to_file__(feature_maps, output_path)
'val': transforms.Compose(transform_val_list), 'satellite': transforms.Compose(transform_satellite_list) } train_all = '' if opt.train_all: train_all = '_all' image_datasets = {} image_datasets['satellite'] = datasets.ImageFolder( os.path.join(data_dir, 'satellite'), data_transforms['satellite']) image_datasets['street'] = datasets.ImageFolder( os.path.join(data_dir, 'street'), data_transforms['train']) image_datasets['drone'] = datasets.ImageFolder( os.path.join(data_dir, 'drone3'), data_transforms['train']) image_datasets['google'] = ImageFolder(os.path.join(data_dir, 'google'), data_transforms['train']) dataloaders = { x: torch.utils.data.DataLoader(image_datasets[x], batch_size=opt.batchsize, shuffle=True, num_workers=2, pin_memory=True) # 8 workers may work faster for x in ['satellite', 'street', 'drone', 'google'] } dataset_sizes = { x: len(image_datasets[x]) for x in ['satellite', 'street', 'drone', 'google'] } class_names = image_datasets['street'].classes
testtransformList.append(transforms.Resize(transResize)) testtransformList.append(transforms.CenterCrop(transCrop)) testtransformList.append(transforms.ToTensor()) testtransformList.append(normalize) testtransformSequence = transforms.Compose(testtransformList) confusion_meter = tnt.meter.ConfusionMeter(args.n_class, normalized=True) if args.use_gpu: os.environ["CUDA_VISIBLE_DEVICES"] = "{}".format(args.device) torch.cuda.manual_seed(args.random_seed) kwargs = {'num_workers': 4, 'pin_memory': True} if args.is_train: train_dataset = ImageFolder(os.path.join(args.data_dir, 'train'), traintransformSequence) val_dataset = ImageFolder(os.path.join(args.data_dir, 'valid'), traintransformSequence) # train_dataset, val_dataset = get_MNIST_train_val_dataset('./data/MNIST') train_loader, val_loader = get_train_val_loader( train_dataset, val_dataset, val_split=args.val_split, random_split=args.random_split, batch_size=args.batch_size, **kwargs) args.num_class = train_loader.dataset.num_class args.num_channels = train_loader.dataset.num_channels else: test_dataset = ImageFolder(os.path.join(args.data_dir, 'test'),