def get_dataloaders(dataset, batch, dataroot, split=0.15, split_idx=0, horovod=False, target_lb=-1): if 'cifar' in dataset or 'svhn' in dataset: transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) elif 'imagenet' in dataset: transform_train = transforms.Compose([ transforms.RandomResizedCrop(224, scale=(0.08, 1.0), interpolation=Image.BICUBIC), transforms.RandomHorizontalFlip(), transforms.ColorJitter( brightness=0.4, contrast=0.4, saturation=0.4, ), transforms.ToTensor(), Lighting(0.1, _IMAGENET_PCA['eigval'], _IMAGENET_PCA['eigvec']), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) transform_test = transforms.Compose([ transforms.Resize(256, interpolation=Image.BICUBIC), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) else: raise ValueError('dataset=%s' % dataset) total_aug = augs = None if isinstance(C.get()['aug'], list): logger.debug('augmentation provided.') transform_train.transforms.insert(0, Augmentation(C.get()['aug'])) else: logger.debug('augmentation: %s' % C.get()['aug']) if C.get()['aug'] == 'fa_reduced_cifar10': transform_train.transforms.insert( 0, Augmentation(fa_reduced_cifar10())) elif C.get()['aug'] == 'fa_reduced_imagenet': transform_train.transforms.insert( 0, Augmentation(fa_resnet50_rimagenet())) elif C.get()['aug'] == 'fa_reduced_svhn': transform_train.transforms.insert(0, Augmentation(fa_reduced_svhn())) elif C.get()['aug'] == 'arsaug': transform_train.transforms.insert(0, Augmentation(arsaug_policy())) elif C.get()['aug'] == 'autoaug_cifar10': transform_train.transforms.insert( 0, Augmentation(autoaug_paper_cifar10())) elif C.get()['aug'] == 'autoaug_extend': transform_train.transforms.insert(0, Augmentation(autoaug_policy())) elif C.get()['aug'] in ['default', 'inception', 'inception320']: pass else: raise ValueError('not found augmentations. %s' % C.get()['aug']) if C.get()['cutout'] > 0: transform_train.transforms.append(CutoutDefault(C.get()['cutout'])) if dataset == 'cifar10': total_trainset = torchvision.datasets.CIFAR10( root=dataroot, train=True, download=False, transform=transform_train) testset = torchvision.datasets.CIFAR10(root=dataroot, train=False, download=False, transform=transform_test) elif dataset == 'reduced_cifar10': total_trainset = torchvision.datasets.CIFAR10( root=dataroot, train=True, download=False, transform=transform_train) sss = StratifiedShuffleSplit(n_splits=1, test_size=46000, random_state=0) # 4000 trainset sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) train_idx, valid_idx = next(sss) targets = [total_trainset.targets[idx] for idx in train_idx] total_trainset = Subset(total_trainset, train_idx) total_trainset.targets = targets testset = torchvision.datasets.CIFAR10(root=dataroot, train=False, download=True, transform=transform_test) elif dataset == 'cifar100': total_trainset = torchvision.datasets.CIFAR100( root=dataroot, train=True, download=True, transform=transform_train) testset = torchvision.datasets.CIFAR100(root=dataroot, train=False, download=True, transform=transform_test) elif dataset == 'svhn': trainset = torchvision.datasets.SVHN(root=dataroot, split='train', download=True, transform=transform_train) extraset = torchvision.datasets.SVHN(root=dataroot, split='extra', download=True, transform=transform_train) total_trainset = ConcatDataset([trainset, extraset]) testset = torchvision.datasets.SVHN(root=dataroot, split='test', download=True, transform=transform_test) elif dataset == 'reduced_svhn': total_trainset = torchvision.datasets.SVHN(root=dataroot, split='train', download=True, transform=transform_train) sss = StratifiedShuffleSplit(n_splits=1, test_size=73257 - 1000, random_state=0) # 1000 trainset sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) train_idx, valid_idx = next(sss) targets = [total_trainset.targets[idx] for idx in train_idx] total_trainset = Subset(total_trainset, train_idx) total_trainset.targets = targets testset = torchvision.datasets.SVHN(root=dataroot, split='test', download=True, transform=transform_test) elif dataset == 'imagenet': total_trainset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), transform=transform_train) testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), split='val', transform=transform_test) # compatibility total_trainset.targets = [lb for _, lb in total_trainset.samples] elif dataset == 'reduced_imagenet': # randomly chosen indices idx120 = [ 904, 385, 759, 884, 784, 844, 132, 214, 990, 786, 979, 582, 104, 288, 697, 480, 66, 943, 308, 282, 118, 926, 882, 478, 133, 884, 570, 964, 825, 656, 661, 289, 385, 448, 705, 609, 955, 5, 703, 713, 695, 811, 958, 147, 6, 3, 59, 354, 315, 514, 741, 525, 685, 673, 657, 267, 575, 501, 30, 455, 905, 860, 355, 911, 24, 708, 346, 195, 660, 528, 330, 511, 439, 150, 988, 940, 236, 803, 741, 295, 111, 520, 856, 248, 203, 147, 625, 589, 708, 201, 712, 630, 630, 367, 273, 931, 960, 274, 112, 239, 463, 355, 955, 525, 404, 59, 981, 725, 90, 782, 604, 323, 418, 35, 95, 97, 193, 690, 869, 172 ] total_trainset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), transform=transform_train) testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), split='val', transform=transform_test) # compatibility total_trainset.targets = [lb for _, lb in total_trainset.samples] sss = StratifiedShuffleSplit(n_splits=1, test_size=len(total_trainset) - 500000, random_state=0) # 4000 trainset sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) train_idx, valid_idx = next(sss) # filter out train_idx = list( filter(lambda x: total_trainset.labels[x] in idx120, train_idx)) valid_idx = list( filter(lambda x: total_trainset.labels[x] in idx120, valid_idx)) test_idx = list( filter(lambda x: testset.samples[x][1] in idx120, range(len(testset)))) targets = [ idx120.index(total_trainset.targets[idx]) for idx in train_idx ] for idx in range(len(total_trainset.samples)): if total_trainset.samples[idx][1] not in idx120: continue total_trainset.samples[idx] = (total_trainset.samples[idx][0], idx120.index( total_trainset.samples[idx][1])) total_trainset = Subset(total_trainset, train_idx) total_trainset.targets = targets for idx in range(len(testset.samples)): if testset.samples[idx][1] not in idx120: continue testset.samples[idx] = (testset.samples[idx][0], idx120.index(testset.samples[idx][1])) testset = Subset(testset, test_idx) print('reduced_imagenet train=', len(total_trainset)) else: raise ValueError('invalid dataset name=%s' % dataset) if total_aug is not None and augs is not None: total_trainset.set_preaug(augs, total_aug) print('set_preaug-') train_sampler = None if split > 0.0: sss = StratifiedShuffleSplit(n_splits=5, test_size=split, random_state=0) sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) for _ in range(split_idx + 1): train_idx, valid_idx = next(sss) if target_lb >= 0: train_idx = [ i for i in train_idx if total_trainset.targets[i] == target_lb ] valid_idx = [ i for i in valid_idx if total_trainset.targets[i] == target_lb ] train_sampler = SubsetRandomSampler(train_idx) valid_sampler = SubsetSampler(valid_idx) if horovod: import horovod.torch as hvd train_sampler = torch.utils.data.distributed.DistributedSampler( train_sampler, num_replicas=hvd.size(), rank=hvd.rank()) else: valid_sampler = SubsetSampler([]) if horovod: import horovod.torch as hvd train_sampler = torch.utils.data.distributed.DistributedSampler( valid_sampler, num_replicas=hvd.size(), rank=hvd.rank()) trainloader = torch.utils.data.DataLoader( total_trainset, batch_size=batch, shuffle=True if train_sampler is None else False, num_workers=32, pin_memory=True, sampler=train_sampler, drop_last=True) validloader = torch.utils.data.DataLoader(total_trainset, batch_size=batch, shuffle=False, num_workers=16, pin_memory=True, sampler=valid_sampler, drop_last=False) testloader = torch.utils.data.DataLoader(testset, batch_size=batch, shuffle=False, num_workers=32, pin_memory=True, drop_last=False) return train_sampler, trainloader, validloader, testloader
max_stage=6, final_tanh=False, ) # ConfigBase.parse() # use MNIST for test data_loader = DataLoader( datasets.MNIST( root='../../tutorials/data/mnist', train=True, download=False, transform=transforms.Compose([ transforms.Resize(net_config.im_res), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]) ]), ), batch_size=train_config.batch_size, shuffle=True, ) Generator, Discriminator = network.interface(net_config) intlog = lambda x: int(round(np.log2(x))) stage = intlog(net_config.im_res) - 2 generator = Generator().to(train_config.device) generator.alpha = net_config.start_alpha sumx.summary( generator,
def load_dataset(args): if args.dataset == 'mnist': if args.augmentation == 'none': train_transform = transforms.ToTensor() elif args.augmentation == 'crop': train_transform = transforms.Compose([ transforms.RandomCrop(28, padding=4), transforms.ToTensor(), ]) test_transform = transforms.ToTensor() train_data = datasets.MNIST('data/mnist', download=True, train=True, transform=train_transform) test_data = datasets.MNIST('data/mnist', download=True, train=False, transform=test_transform) in_ch = 1 out = 10 elif args.dataset == 'cifar10': if args.augmentation == 'none': train_transform = test_transform = transforms.ToTensor() elif args.augmentation == 'crop+flip+norm': train_transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) elif args.augmentation == 'crop+jitter+flip+norm': train_transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.ColorJitter(hue=.05, saturation=.05), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) train_data = datasets.CIFAR10('data/cifar10', download=True, train=True, transform=train_transform) test_data = datasets.CIFAR10('data/cifar10', download=True, train=False, transform=test_transform) in_ch = 3 out = 10 elif args.dataset == 'tiny-imagenet-200': if args.augmentation == 'none': train_transform = test_transform = transforms.ToTensor() elif args.augmentation == 'crop+flip+norm': train_transform = transforms.Compose([ transforms.RandomCrop(64, padding=8), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4802, 0.4481, 0.3975), (0.2770, 0.2691, 0.2821)), ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4802, 0.4481, 0.3975), (0.2770, 0.2691, 0.2821)), ]) elif args.augmentation == 'crop+jitter+flip+norm': train_transform = transforms.Compose([ transforms.RandomCrop(64, padding=8), transforms.ColorJitter(hue=.05, saturation=.05), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4802, 0.4481, 0.3975), (0.2770, 0.2691, 0.2821)), ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4802, 0.4481, 0.3975), (0.2770, 0.2691, 0.2821)), ]) train_data = TinyImageNet200('data/tiny-imagenet-200', download=True, split='train', transform=train_transform) test_data = TinyImageNet200('data/tiny-imagenet-200', download=True, split='val', transform=test_transform) in_ch = 3 out = 200 return train_data, test_data, in_ch, out
def __init__( self, c, nof_joints, checkpoint_path, resolution=(384, 288), interpolation=cv2.INTER_CUBIC, multiperson=True, max_batch_size=32, yolo_model_def="./models/detectors/yolo/config/yolov3.cfg", yolo_class_path="./models/detectors/yolo/data/coco.names", yolo_weights_path="./models/detectors/yolo/weights/yolov3.weights", device=torch.device("cpu")): """ Initializes a new SimpleHRNet object. HRNet (and YOLOv3) are initialized on the torch.device("device") and its (their) pre-trained weights will be loaded from disk. Arguments: c (int): number of channels. nof_joints (int): number of joints. checkpoint_path (str): hrnet checkpoint path. resolution (tuple): hrnet input resolution - format: (height, width). Default: (384, 288) interpolation (int): opencv interpolation algorithm. Default: cv2.INTER_CUBIC multiperson (bool): if True, multiperson detection will be enabled. This requires the use of a people detector (like YOLOv3). Default: True max_batch_size (int): maximum batch size used in hrnet inference. Useless without multiperson=True. Default: 16 yolo_model_def (str): path to yolo model definition file. Default: "./models/detectors/yolo/config/yolov3.cfg" yolo_class_path (str): path to yolo class definition file. Default: "./models/detectors/yolo/data/coco.names" yolo_weights_path (str): path to yolo pretrained weights file. Default: "./models/detectors/yolo/weights/yolov3.weights.cfg" device (:class:`torch.device`): the hrnet (and yolo) inference will be run on this device. Default: torch.device("cpu") """ self.c = c self.nof_joints = nof_joints self.checkpoint_path = checkpoint_path self.resolution = resolution # in the form (height, width) as in the original implementation self.interpolation = interpolation self.multiperson = multiperson self.max_batch_size = max_batch_size self.yolo_model_def = yolo_model_def self.yolo_class_path = yolo_class_path self.yolo_weights_path = yolo_weights_path self.device = device self.model = HRNet(c=c, nof_joints=nof_joints).to(device) self.model.load_state_dict( torch.load(checkpoint_path, map_location=self.device)) self.model.eval() if not self.multiperson: self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) else: self.detector = YOLOv3(model_def=yolo_model_def, class_path=yolo_class_path, weights_path=yolo_weights_path, classes=('person', ), max_batch_size=self.max_batch_size, device=device) self.transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((self.resolution[0], self.resolution[1])), # (height, width) transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pass
from torchvision.transforms import transforms from RandAugment import RandAugment from RandAugment.augmentations import CutoutDefault # Parameters for data cifar10_mean = (0.4914, 0.4822, 0.4465 ) # equals np.mean(train_set.train_data, axis=(0,1,2))/255 cifar10_std = (0.2471, 0.2435, 0.2616 ) # equals np.std(train_set.train_data, axis=(0,1,2))/255 # Augmentations. transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(cifar10_mean, cifar10_std) ]) transform_strong = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(cifar10_mean, cifar10_std) ]) transform_strong.transforms.insert(0, RandAugment(3, 4)) transform_strong.transforms.append(CutoutDefault(16)) transform_val = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(cifar10_mean, cifar10_std)])
]) data_config = OrderedDict([ ('dataset', 'SplitFashionMNIST'), ('valid', 0.0), ('num_workers', 4), ( 'train_transform', transforms.Compose([ lambda x: np.array(x).reshape((1, 28, 28)), lambda x: np.pad(x, ( (0, 0), (2, 2), (2, 2)), mode='minimum'), # Padding is only required by LeNet lambda x: torch.FloatTensor(x), lambda x: x / 255.0, transforms.Normalize(np.array([0.1307]), np.array([0.3081])) ])), ( 'test_transform', transforms.Compose([ lambda x: np.array(x).reshape((1, 28, 28)), lambda x: np.pad(x, ( (0, 0), (2, 2), (2, 2)), mode='minimum'), # Padding is only required by LeNet lambda x: torch.FloatTensor(x), lambda x: x / 255.0, transforms.Normalize(np.array([0.1307]), np.array([0.3081])) ])), ]) run_config = OrderedDict([
def preprocess(img): # Convert image from numpy to tensor to_tensor = torchvision.transforms.Compose( [transforms.ToTensor(), transforms.Normalize(mean, std)]) return to_tensor(img).unsqueeze(0)
def main(): # img_folders = ["../coco_img/bg2_0/", "../coco_img/bg2_127/", "../coco_img/bg2_255/", # "../coco_img/obj2_0/", "../coco_img/obj2_127/", "../coco_img/obj2_255/"] img_folders = [ "../coco_img/merged_bg2_0/", "../coco_img/merged_bg2_127/", "../coco_img/merged_bg2_255/", "../coco_img/merged_obj2_0/", "../coco_img/merged_obj2_127/", "../coco_img/merged_obj2_255/" ] img_folders = ["../coco_img/org/"] model_name = "MLCCOCO" model = MultilabelObject(None, 80).cuda() log_dir = "./" checkpoint = torch.load(os.path.join(log_dir, 'model_best.pth.tar'), encoding='bytes') new_checkpoint = OrderedDict() for k in checkpoint[b'state_dict']: new_checkpoint[k.decode('utf-8')] = checkpoint[b'state_dict'][k] model.load_state_dict(new_checkpoint) model.eval() with open("classes_list.pickle", "rb") as f: classes_list = pickle.load(f) for img_folder in img_folders: crop_size = 224 image_size = 256 batch_size = 64 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) val_transform = transforms.Compose([ transforms.Scale(image_size), transforms.CenterCrop(crop_size), transforms.ToTensor(), normalize ]) cocomlc = COCO_MLC(img_folder, val_transform) test_loader = torch.utils.data.DataLoader(cocomlc, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True) t = tqdm(test_loader, desc='testing {}'.format(img_folder)) result = {} for batch_idx, (imgs, paths) in enumerate(t): images = imgs.cuda() # print(images.shape) probs, labels, labels_probs = infer_batch(model, classes_list, inputs=images, threshold=0.5) for i in range(0, len(paths)): path = paths[i] result[path] = { "prob": probs[i], "labels": labels[i], "labels_probs": labels_probs[i] } pickle_file_name = "{}_{}.pickle".format( model_name, os.path.basename(os.path.normpath(img_folder))) pickle_path = os.path.join(".", "result_pickle", pickle_file_name) with open(pickle_path, 'wb') as handle: pickle.dump(result, handle) print("Done, Saved to {}".format(pickle_path))
def create_dataloader(data_manager, batch_size=128, validation_split=None, validation_source=None): """ Args: data_manager: Current version of the train data and the pool to sample from batch_size: batch_size validation_source : Whether to use train or test dataset for creating validation dataset, Defauts to None validation_split : Specify the ratio of samples to use in validation, defaults to 20% of source size Returns: PyTorch's train, test and pool loader. (Validation loader is also returned if source is not None) """ train_X, train_y = data_manager.get_train_data() test_X, test_y = data_manager.get_test_data() pool_X, pool_y = data_manager.get_unlabelled_pool_data() train_X, train_y = train_X.astype(np.float32), train_y.astype(np.float32) test_X, test_y = test_X.astype(np.float32), test_y.astype(np.float32) pool_X, pool_y = pool_X.astype(np.float32), pool_y.astype(np.float32) train_X, train_y = torch.from_numpy(train_X), torch.from_numpy(train_y) test_X, test_y = torch.from_numpy(test_X), torch.from_numpy(test_y) pool_X, pool_y = torch.from_numpy(pool_X), torch.from_numpy(pool_y) transform_train = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, 4), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) pool_dataset = DataHandler_For_Arrays(pool_X, pool_y) train_dataset = DataHandler_For_Arrays(train_X, train_y, transform=transform_train) test_dataset = DataHandler_For_Arrays(test_X, test_y, transform=transform_test) if validation_source is None: print( "INFO ------ Validation source not specified in config, experiment would run without validation set" ) else: if validation_source == "test": if validation_split is None: validation_size = int(len(test_dataset) * 0.2) else: assert ( 0 < validation_split < 1 ), f"Validation size must be >0 and <1, found {validation_split}" validation_size = int(len(test_dataset) * validation_split) print( f"Using Testing data to create validation dataset, size : {validation_size}" ) test_dataset, validation_dataset = random_split( test_dataset, lengths=[len(test_dataset) - validation_size, validation_size], ) elif validation_source == "train": if validation_split is None: validation_size = int(len(train_dataset) * 0.2) else: assert ( 0 < validation_split < 1 ), f"Validation size must be >0 and <1, found {validation_split}" validation_size = int(len(train_dataset) * validation_split) print( f"Using Training data to create validation dataset, size : {validation_size}" ) train_dataset, validation_dataset = random_split( train_dataset, lengths=[ len(train_dataset) - validation_size, validation_size ], ) train_loader = DataLoader( train_dataset, sampler=RandomSampler(train_dataset), batch_size=batch_size, num_workers=2, pin_memory=pin_memory, ) test_loader = DataLoader( test_dataset, sampler=SequentialSampler(test_dataset), batch_size=batch_size, num_workers=2, pin_memory=pin_memory, ) pool_loader = DataLoader(pool_dataset, batch_size=batch_size, num_workers=2, pin_memory=pin_memory) if validation_source is not None: val_loader = DataLoader( validation_dataset, sampler=SequentialSampler(validation_dataset), batch_size=batch_size, num_workers=2, pin_memory=pin_memory, ) return (train_loader, test_loader, pool_loader, val_loader) else: return (train_loader, test_loader, pool_loader)
return sample, path def __len__(self): return len(self.samples) def __repr__(self): fmt_str = '>> PATH : {}\n'.format(self.dir) fmt_str += '>> LEN : {}\n'.format(self.__len__()) return fmt_str def get_vidname(self): return os.path.dirname(self.dir).split('/')[-1] if __name__ == '__main__': base = '/DB/VCDB/frame_1_per_sec/frames' db = CC_WEB_VIDEO() db.get_VideoList() videos = os.listdir(base) videos.sort(key=lambda x: int(x)) normalize = trn.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) video_trn = trn.Compose([trn.Resize(224), trn.ToTensor(), normalize]) for vid in videos: dt = DirDataset(os.path.join(base, vid), video_trn) dl = DataLoader(dt, batch_size=4, num_workers=2) for i, (im, path) in enumerate(dl): print(i, path)
def __len__(self): return self.data.shape[0] def __getitem__(self, idx): row = self.data.iloc[idx] img = Image.open(row['path']) if self.transform: img = self.transform(img) target = row['label_id'] - 1 if 'label_id' in row else -1 return img, target ''' 设置全局变量的方差和标准差 ''' normalize_torch = transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ) normalize_05 = transforms.Normalize( mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5] ) ''' 图像预处理,修改尺寸的操作。 ''' def preprocess(normalize, image_size): return transforms.Compose([ transforms.Resize((image_size, image_size)), transforms.ToTensor(), normalize ])
def get_dataloaders(dataset, batch, dataroot, split=0.15, split_idx=0, multinode=False, target_lb=-1): if 'cifar' in dataset or 'svhn' in dataset: transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) elif 'imagenet' in dataset: input_size = 224 sized_size = 256 if 'efficientnet' in C.get()['model']['type']: input_size = EfficientNet.get_image_size(C.get()['model']['type']) sized_size = input_size + 32 # TODO # sized_size = int(round(input_size / 224. * 256)) # sized_size = input_size logger.info('size changed to %d/%d.' % (input_size, sized_size)) transform_train = transforms.Compose([ EfficientNetRandomCrop(input_size), transforms.Resize((input_size, input_size), interpolation=Image.BICUBIC), # transforms.RandomResizedCrop(input_size, scale=(0.1, 1.0), interpolation=Image.BICUBIC), transforms.RandomHorizontalFlip(), transforms.ColorJitter( brightness=0.4, contrast=0.4, saturation=0.4, ), transforms.ToTensor(), Lighting(0.1, _IMAGENET_PCA['eigval'], _IMAGENET_PCA['eigvec']), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) transform_test = transforms.Compose([ EfficientNetCenterCrop(input_size), transforms.Resize((input_size, input_size), interpolation=Image.BICUBIC), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) else: raise ValueError('dataset=%s' % dataset) total_aug = augs = None if isinstance(C.get()['aug'], list): logger.debug('augmentation provided.') transform_train.transforms.insert(0, Augmentation(C.get()['aug'])) else: logger.debug('augmentation: %s' % C.get()['aug']) if C.get()['aug'] == 'fa_reduced_cifar10': transform_train.transforms.insert( 0, Augmentation(fa_reduced_cifar10())) elif C.get()['aug'] == 'fa_reduced_imagenet': transform_train.transforms.insert( 0, Augmentation(fa_resnet50_rimagenet())) elif C.get()['aug'] == 'fa_reduced_svhn': transform_train.transforms.insert(0, Augmentation(fa_reduced_svhn())) elif C.get()['aug'] == 'arsaug': transform_train.transforms.insert(0, Augmentation(arsaug_policy())) elif C.get()['aug'] == 'autoaug_cifar10': transform_train.transforms.insert( 0, Augmentation(autoaug_paper_cifar10())) elif C.get()['aug'] == 'autoaug_extend': transform_train.transforms.insert(0, Augmentation(autoaug_policy())) elif C.get()['aug'] in ['default']: pass else: raise ValueError('not found augmentations. %s' % C.get()['aug']) if C.get()['cutout'] > 0: transform_train.transforms.append(CutoutDefault(C.get()['cutout'])) if dataset == 'cifar10': total_trainset = torchvision.datasets.CIFAR10( root=dataroot, train=True, download=True, transform=transform_train) testset = torchvision.datasets.CIFAR10(root=dataroot, train=False, download=True, transform=transform_test) elif dataset == 'reduced_cifar10': total_trainset = torchvision.datasets.CIFAR10( root=dataroot, train=True, download=True, transform=transform_train) sss = StratifiedShuffleSplit(n_splits=1, test_size=46000, random_state=0) # 4000 trainset sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) train_idx, valid_idx = next(sss) targets = [total_trainset.targets[idx] for idx in train_idx] total_trainset = Subset(total_trainset, train_idx) total_trainset.targets = targets testset = torchvision.datasets.CIFAR10(root=dataroot, train=False, download=True, transform=transform_test) elif dataset == 'cifar100': total_trainset = torchvision.datasets.CIFAR100( root=dataroot, train=True, download=True, transform=transform_train) testset = torchvision.datasets.CIFAR100(root=dataroot, train=False, download=True, transform=transform_test) elif dataset == 'svhn': trainset = torchvision.datasets.SVHN(root=dataroot, split='train', download=True, transform=transform_train) extraset = torchvision.datasets.SVHN(root=dataroot, split='extra', download=True, transform=transform_train) total_trainset = ConcatDataset([trainset, extraset]) testset = torchvision.datasets.SVHN(root=dataroot, split='test', download=True, transform=transform_test) elif dataset == 'reduced_svhn': total_trainset = torchvision.datasets.SVHN(root=dataroot, split='train', download=True, transform=transform_train) sss = StratifiedShuffleSplit(n_splits=1, test_size=73257 - 1000, random_state=0) # 1000 trainset sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) train_idx, valid_idx = next(sss) targets = [total_trainset.targets[idx] for idx in train_idx] total_trainset = Subset(total_trainset, train_idx) total_trainset.targets = targets testset = torchvision.datasets.SVHN(root=dataroot, split='test', download=True, transform=transform_test) elif dataset == 'imagenet': total_trainset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), transform=transform_train, download=True) testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), split='val', transform=transform_test) # compatibility total_trainset.targets = [lb for _, lb in total_trainset.samples] elif dataset == 'reduced_imagenet': # randomly chosen indices # idx120 = sorted(random.sample(list(range(1000)), k=120)) idx120 = [ 16, 23, 52, 57, 76, 93, 95, 96, 99, 121, 122, 128, 148, 172, 181, 189, 202, 210, 232, 238, 257, 258, 259, 277, 283, 289, 295, 304, 307, 318, 322, 331, 337, 338, 345, 350, 361, 375, 376, 381, 388, 399, 401, 408, 424, 431, 432, 440, 447, 462, 464, 472, 483, 497, 506, 512, 530, 541, 553, 554, 557, 564, 570, 584, 612, 614, 619, 626, 631, 632, 650, 657, 658, 660, 674, 675, 680, 682, 691, 695, 699, 711, 734, 736, 741, 754, 757, 764, 769, 770, 780, 781, 787, 797, 799, 811, 822, 829, 830, 835, 837, 842, 843, 845, 873, 883, 897, 900, 902, 905, 913, 920, 925, 937, 938, 940, 941, 944, 949, 959 ] total_trainset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), transform=transform_train) testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'), split='val', transform=transform_test) # compatibility total_trainset.targets = [lb for _, lb in total_trainset.samples] sss = StratifiedShuffleSplit(n_splits=1, test_size=len(total_trainset) - 50000, random_state=0) # 4000 trainset sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) train_idx, valid_idx = next(sss) # filter out train_idx = list( filter(lambda x: total_trainset.labels[x] in idx120, train_idx)) valid_idx = list( filter(lambda x: total_trainset.labels[x] in idx120, valid_idx)) test_idx = list( filter(lambda x: testset.samples[x][1] in idx120, range(len(testset)))) targets = [ idx120.index(total_trainset.targets[idx]) for idx in train_idx ] for idx in range(len(total_trainset.samples)): if total_trainset.samples[idx][1] not in idx120: continue total_trainset.samples[idx] = (total_trainset.samples[idx][0], idx120.index( total_trainset.samples[idx][1])) total_trainset = Subset(total_trainset, train_idx) total_trainset.targets = targets for idx in range(len(testset.samples)): if testset.samples[idx][1] not in idx120: continue testset.samples[idx] = (testset.samples[idx][0], idx120.index(testset.samples[idx][1])) testset = Subset(testset, test_idx) print('reduced_imagenet train=', len(total_trainset)) else: raise ValueError('invalid dataset name=%s' % dataset) if total_aug is not None and augs is not None: total_trainset.set_preaug(augs, total_aug) print('set_preaug-') train_sampler = None if split > 0.0: sss = StratifiedShuffleSplit(n_splits=5, test_size=split, random_state=0) sss = sss.split(list(range(len(total_trainset))), total_trainset.targets) for _ in range(split_idx + 1): train_idx, valid_idx = next(sss) if target_lb >= 0: train_idx = [ i for i in train_idx if total_trainset.targets[i] == target_lb ] valid_idx = [ i for i in valid_idx if total_trainset.targets[i] == target_lb ] train_sampler = SubsetRandomSampler(train_idx) valid_sampler = SubsetSampler(valid_idx) if multinode: train_sampler = torch.utils.data.distributed.DistributedSampler( Subset(total_trainset, train_idx), num_replicas=dist.get_world_size(), rank=dist.get_rank()) else: valid_sampler = SubsetSampler([]) if multinode: train_sampler = torch.utils.data.distributed.DistributedSampler( total_trainset, num_replicas=dist.get_world_size(), rank=dist.get_rank()) logger.info( f'----- dataset with DistributedSampler {dist.get_rank()}/{dist.get_world_size()}' ) trainloader = torch.utils.data.DataLoader( total_trainset, batch_size=batch, shuffle=True if train_sampler is None else False, num_workers=8, pin_memory=True, sampler=train_sampler, drop_last=True) validloader = torch.utils.data.DataLoader(total_trainset, batch_size=batch, shuffle=False, num_workers=4, pin_memory=True, sampler=valid_sampler, drop_last=False) testloader = torch.utils.data.DataLoader(testset, batch_size=batch, shuffle=False, num_workers=8, pin_memory=True, drop_last=False) return train_sampler, trainloader, validloader, testloader
valid_dir = os.path.join(split_dir, 'valid') print('train_dir:\n', train_dir) print('valid_dir:\n', valid_dir) # 规定图像数据的处理方式 # 参数:列表---列表中放置的是各种图片数据处理方式 # 返回一个数据处理对象 transform = transforms.Compose([ # 图片尺寸固定 transforms.Resize((32, 32)), # 将图片固定为32*32的大小 # 将数据转化为tensor transforms.ToTensor(), # 转化为 tensor # 图片数据的归一化 # data - mean / std transforms.Normalize(mean=norm_mean, std=norm_std), ]) # 实例化DataSet train_data = RMBDataSet(data_dir=train_dir, transform=transform) valid_data = RMBDataSet(data_dir=valid_dir, transform=transform) # 实例化DataLoader train_loader = DataLoader( dataset=train_data, # 规定的是数据的读取规则 batch_size=BATCH_SIZE, # 每批次读取多少个样本 shuffle=True, # 打乱顺序 ) valid_loader = DataLoader( dataset=valid_data, # 规定的是数据的读取规则 batch_size=BATCH_SIZE, # 每批次读取多少个样本
def __init__(self, root): self.root = root self.imgs = os.listdir(root) self.transforms = T.Compose( [T.ToTensor(), T.Normalize(mean=[0.3], std=[0.5])])
def __init__(self, root, mode, batchsz, resize, startidx=0): """ :param root: root path of mini-imagenet :param mode: train, val or test :param batchsz: batch size of sets, not batch of imgs :param n_way: :param k_shot: :param k_query: num of qeruy imgs per class :param resize: resize to :param startidx: start to index label from startidx """ self.batchsz = batchsz #batch of imgs self.resize = resize # resize to self.startidx = startidx # index label not from 0, but from startidx print('shuffle DB :%s, b:%d, resize:%d' % (mode, batchsz, resize)) if mode == 'train': # self.transform = transforms.Compose([lambda x: Image.open(x).convert('RGB'), # transforms.Resize((self.resize, self.resize)), # # transforms.RandomHorizontalFlip(), # # transforms.RandomRotation(5), # transforms.ToTensor(), # transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) # ]) self.transform = transforms.Compose([ lambda x: Image.open(x).convert('RGB'), transforms.Resize((self.resize, self.resize)), # transforms.RandomHorizontalFlip(), # transforms.RandomRotation(5), transforms.ToTensor(), transforms.Normalize((0, 0, 0), (1, 1, 1)) ]) else: # self.transform = transforms.Compose([lambda x: Image.open(x).convert('RGB'), # transforms.Resize((self.resize, self.resize)), # transforms.ToTensor(), # transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) # ]) self.transform = transforms.Compose([ lambda x: Image.open(x).convert('RGB'), transforms.Resize((self.resize, self.resize)), transforms.ToTensor(), transforms.Normalize((0, 0, 0), (1, 1, 1)) ]) self.path = os.path.join(root, 'images') # image path csvdata = self.loadCSV(os.path.join(root, mode + '.csv')) # csv path self.data = [] self.img2label = {} for i, (k, v) in enumerate(csvdata.items()): self.data.extend(v) # [[img1, img2, ...], [img111, ...]] self.img2label[k] = i + self.startidx # {"img_name[:9]":label} self.cls_num = len(self.data) # self.create_batch(self.batchsz) support_x = torch.FloatTensor(self.cls_num, 3, self.resize, self.resize) support_x_temp = np.array(self.data) #.tolist() #support_y = np.zeros((self.cls_num), dtype=np.int) flatten_x = [os.path.join(self.path, item) for item in support_x_temp] temp = [self.img2label[item[:9]] for item in support_x_temp] support_y = np.array(temp).astype(np.int32) for i, path in enumerate(flatten_x): support_x[i] = self.transform(path) self.loading_data = DataSubset(support_x, torch.LongTensor(support_y))
# Hyper-parameters latent_size = 64 hidden_size = 256 image_size = 784 num_epochs = 200 batch_size = 100 sample_dir = 'sample' # Create a directory if not exists if not os.path.exists(sample_dir): os.makedirs(sample_dir) # Image processing transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, ), (0.5, ))]) # MNIST dataset mnist = torchvision.datasets.MNIST(root='../data/', train=True, transform=transform, download=True) # Data loader data_loader = torch.utils.data.DataLoader(dataset=mnist, batch_size=batch_size, shuffle=True) # Discriminator D = nn.Sequential(nn.Linear(image_size, hidden_size), nn.LeakyReLU(0.2), nn.Linear(hidden_size, hidden_size), nn.LeakyReLU(0.2),
def __getitem__(self, idx): fileLocation = self.data[idx]['image'] inputI = Image.open(open(fileLocation, 'rb')).convert('RGB') imageShow = inputI imagelabel = self.data[idx]['label'] #output = self.data[idx]['label'] #inputI = rescale(inputI, OUTPUT_SIZE) #inputI = torch.from_numpy(inputI) #inputI = inputI.view(1, 64, 64) #if self.normalize: composed = transforms.Compose([transforms.Resize((128,128)), transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))]) inputI = composed(inputI) output = self.onehot[self.data[idx]['label']] #imageShow.show() return inputI, output
from geomstats.learning.preprocessing import ToTangentSpace from geomstats.visualization import Sphere from sklearn.decomposition import PCA from sklearn.manifold import TSNE from sklearn.preprocessing import StandardScaler from torch.nn import CrossEntropyLoss from torchvision.datasets import CIFAR10 from torchvision.models import resnet18 from torchvision.transforms import transforms import numpy as np from tqdm import tqdm from matplotlib import pyplot as plt if __name__ == '__main__': transform = transforms.Compose((transforms.ToTensor(), transforms.Normalize(0.5, 0.5, 0.5))) test_dataset = CIFAR10('data', train=True, transform=transform, download=False) net = resnet18(pretrained=False, num_classes=10).eval() net.load_state_dict(torch.load('saves/resnet18_cifar10.sv')) image_size = 32 * 32 * 3 num_images = 3000 features = np.zeros((0, image_size)) labels = [] for idx, data in enumerate(tqdm(test_dataset)): if idx == num_images: break features = np.concatenate((features, data[0].reshape((1, image_size)).numpy())) labels.append(data[1])
def main(): BATCH_SIZE = 100 LR = 1e-3 EPOCHS = 15 print('Number of epochs: ', EPOCHS) print('Learning Rate: ', LR) print('Batch size: ', BATCH_SIZE) transforms_ = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0, ), (1, ))]) mnist_train = datasets.FashionMNIST('../data', train=True, download=True, transform=transforms_) dataset_train = SiameseDataset(mnist_train) sTrainDataLoader = DataLoader(dataset_train, batch_size=BATCH_SIZE, shuffle=True, num_workers=6) mnist_test = datasets.FashionMNIST('../data', train=False, download=True, transform=transforms_) dataset_test = SiameseDataset(mnist_test) sTestDataLoader = DataLoader(dataset_test, batch_size=BATCH_SIZE, shuffle=False, num_workers=6) pairwise_loss = ParwiseLoss() net = Net() net.cuda() optimizer = optim.Adam(net.parameters(), lr=LR) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=1, verbose=True) train_losses = [] test_losses = [] for epoch in range(EPOCHS): print('Epoch:{} '.format(epoch)) train_loss = train(net, optimizer, sTrainDataLoader, pairwise_loss) test_loss = test(net, sTestDataLoader, pairwise_loss) scheduler.step(test_loss) train_losses.append(train_loss) test_losses.append(test_loss) sTestDataLoader2 = DataLoader(dataset_test, batch_size=10000, shuffle=False, num_workers=6) emb = getembeddings(net, sTestDataLoader2) plotLoss(EPOCHS, train_losses, test_losses) plot2D(emb)
plt.title(cvt_title) plt.pause(3) # edit showing time df = pd.read_excel('./sample_data/KFace_data_information_Folder1_400.xlsx' ) # change xlsx file directory train_transforms = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.RandomChoice([ transforms.ColorJitter(0.2, 0.2, 0.2, 0.2), ]), transforms.ToTensor(), transforms.Normalize((0.4452, 0.4457, 0.4464), (0.2592, 0.2596, 0.2600)), ]) if __name__ == '__main__': train_dataset = ImageFolder( root='./sample_data/image', transform=train_transforms) # change image directory train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, num_workers=4) for batch, (input, targets) in enumerate(train_loader): out = make_grid(input) imshow(out, title=targets, df=df)
cudnn.benchmark = True else: device = torch.device("cpu") if not os.path.exists(args.output_folder): os.mkdir(args.output_folder) nlabel = 6 transform = {} transform['train'] = transforms.Compose([ transforms.RandomVerticalFlip(), transforms.RandomHorizontalFlip(), transforms.RandomHorizontalFlip(), transforms.RandomRotation(10), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform['val'] = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) transform['test'] = transform['val'] ''' extract_images("001c62abd11fa4b57bf7a6c603a11bb9", "/kaggle/input/prostate-cancer-grade-assessment/train_images", 256, False) '''
def main(args): transform = transforms.Compose([ transforms.Resize((args.img_size, args.img_size)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.224]) ]) dset_train = ArgoDataset(args, transform) train_loader = DataLoader(dset_train, batch_size=args.batch_size, shuffle=False, collate_fn=collate_video) # dataloader_iterator = iter(train_loader) # X= next(dataloader_iterator) args.device = None if not args.disable_cuda and torch.cuda.is_available(): args.device = torch.device('cuda') else: args.device = torch.device('cpu') if args.model_type == 'resnet152': model = models.resnet152(pretrained=True) for par in model.parameters(): par.requires_grad = False # model.layer4.register_forward_hook(hook) model.fc = Identity() if args.model_type == 'resnet101': resnet = models.resnet101(pretrained=True) model = nn.Sequential( resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1, resnet.layer2, resnet.layer3, ) if args.model_type == 'vgg16': vgg16 = models.vgg16(pretrained=True) model = vgg16.features # Enable multi-GPU execution if needed. if torch.cuda.device_count() > 1: print("Using ", torch.cuda.device_count(), "GPUs!") model = nn.DataParallel(model) model.to(device=args.device) model.eval() filename = os.path.join( args.output_base, args.model_type + '_' + args.split + '_features.h5') hf = h5py.File(filename, 'w') with torch.no_grad(): for batch in tqdm(train_loader): image_names, video_idxs, images = batch images = images.to(device=args.device) output = model(images) output = output.detach().cpu() print(output.shape) for i in range(output.size(0) // 7): start = i * args.num_frames end = (i + 1) * args.num_frames name = str(image_names[i]) + '@' + str(video_idxs[i]) hf.create_dataset(name=name, data=output[start:end]) hf.close()
if sum_loss < best_loss: best_loss = sum_loss state = { 'net': net.state_dict(), 'loss': best_loss, 'epoch': epoch, } if not os.path.isdir('checkpoint'): os.mkdir('checkpoint') torch.save(state, './checkpoint/ckpt.pth') if __name__ == '__main__': img_trans = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) train_set = VocDataset(root=r"H:\drone_image_and_annotation_mixed\train", train=True, transform=img_trans, input_size=1080) train_loader = DataLoader(dataset=train_set, batch_size=12, shuffle=True, sampler=None, batch_sampler=None, num_workers=12, pin_memory=True, drop_last=True, collate_fn=collate_fn, timeout=0,
ActiveLearningDataModule, ActiveLearningLoop, ) from baal.active import get_heuristic log = structlog.get_logger() IMG_SIZE = 128 train_transforms = transforms.Compose([ transforms.Resize((IMG_SIZE, IMG_SIZE)), transforms.RandomHorizontalFlip(), transforms.RandomRotation(30), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_transforms = transforms.Compose([ transforms.Resize((IMG_SIZE, IMG_SIZE)), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) class DataModule_(ImageClassificationData): @property def num_classes(self): return 10 def get_data_module(heuristic, data_path):
def ext_face_feats(sphere_face, img_path, pretrained_model=os.path.join(cfg['model_zoo_base'], 'sphere20a.pth')): """ extract face features :param sphere_face: :param img_path: :param pretrained_model: :return: """ assert os.path.exists(pretrained_model) if sphere_face is None: sphere_face = SphereFaceNet() device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') sphere_face.load_state_dict(torch.load(pretrained_model)) sphere_face = sphere_face.to(device) img = cv2.imread(img_path) mtcnn_result = detect_face(img_path) print(mtcnn_result) if len(mtcnn_result) > 0: bbox = mtcnn_result[0]['box'] margin_pixel = 10 face_region = img[bbox[0] - margin_pixel:bbox[0] + bbox[2] + margin_pixel, bbox[1] - margin_pixel:bbox[1] + bbox[3] + margin_pixel] ratio = max(face_region.shape[0], face_region.shape[1]) / min( face_region.shape[0], face_region.shape[1]) if face_region.shape[0] < face_region.shape[1]: face_region = cv2.resize(face_region, (int(ratio * 64), 64)) face_region = face_region[:, int((face_region.shape[0] - 64) / 2):int((face_region.shape[0] - 64) / 2) + 64] else: face_region = cv2.resize(face_region, (64, int(ratio * 64))) face_region = face_region[int((face_region.shape[1] - 64) / 2):int((face_region.shape[1] - 64) / 2) + 64, :] face_region = Image.fromarray(face_region.astype(np.uint8)) preprocess = transforms.Compose([ transforms.Resize((96, 112)), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) face_region = preprocess(face_region) face_region.unsqueeze_(0) face_region = face_region.to(device) x = face_region.to(device) x = sphere_face.forward(x) x = x.to("cpu").detach().numpy().flatten() return { 'status': 0, 'message': 'extracted feature', 'feature': x / np.linalg.norm(x) } else: return {'status': 0, 'message': 'No face detected!', 'feature': None}
from torchvision.transforms import transforms from Resnet import ResNet, BasicBlock from SwatsVanillaGlobal import SwatsVanillaGlobal import numpy as np import math import matplotlib.pyplot as plt device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') print(device) batch_is = 128 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.247, 0.243, 0.261]) ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.247, 0.243, 0.261]) ]) trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train) trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_is, shuffle=True, num_workers=1,
NUM_EPOCHS = 25 degree = 45 def binary(c): for index in range(len(c)): if c[index] > 0.5: c[index] = 1 else: c[index] = 0 return c normMean = [0.4948052, 0.48568845, 0.44682974] normStd = [0.24580306, 0.24236229, 0.2603115] normTransform = transforms.Normalize(normMean, normStd) transform = transforms.Compose([ transforms.RandomHorizontalFlip(p=0.5), torchvision.transforms.RandomVerticalFlip(p=0.5), transforms.RandomRotation(degrees=degree, resample=False, expand=False, center=None), transforms.ToTensor(), normTransform ]) test_dataset = MyDataset(root_dir='./archive', root_dir1='/test/', names_file='/sampleSubmission.csv', transform=transform)
def main(): '''Main entrypoint function for training.''' # Parse command-line arguments args = parse_args() fmt = {'disc_loss':'.5e', 'gen_loss':'.5e' } logger_name = "wgan-train_"+args.optimizer logger = Logger(logger_name, fmt=fmt) logger_disc = Logger(logger_name+"_discriminator", fmt=fmt) logger_gen = Logger(logger_name+"_generator", fmt=fmt) # Create directory for saving outputs os.makedirs('out', exist_ok=True) # Initialise CIFAR-10 data loader # train_loader = DataLoader(torchvision.datasets.CIFAR10('./data/cifar-10'), # args.batch_size, num_workers = 4, pin_memory = True, drop_last = True) transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) trainset = torchvision.datasets.CIFAR10(root='./data/cifar-10', train=True, download=True, transform=transform) train_loader = torch.utils.data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=2) inf_train_data = loop_data_loader(train_loader) # Build neural network models and copy them onto the GPU generator = Generator().cuda() discriminator = Discriminator().cuda() # Select which Lipschitz constraint to use if args.unimproved: lipschitz_constraint = lipschitz.WeightClipping(discriminator) else: lipschitz_constraint = lipschitz.GradientPenalty(discriminator) # Initialise the parameter optimisers optim_gen = optim.Adam(generator.parameters(), lr=2e-4, betas=(0, 0.999)) if args.optimizer == "adashift": optim_disc = AdaShift(discriminator.parameters(), lr=2e-4, betas=(0, 0.999)) elif args.optimizer == "amsgrad": optim_disc = optim.Adam(discriminator.parameters(), lr=2e-4, betas=(0, 0.999), amsgrad=True) else: assert args.optimizer == "adam" optim_disc = optim.Adam(discriminator.parameters(), lr=2e-4, betas=(0, 0.999)) i,j = 0, 0 # Run the main training loop for epoch in range(args.epochs): avg_disc_loss = 0 avg_gen_loss = 0 for gen_iter in range(args.gen_iters): # Train the discriminator (aka critic) for _ in range(args.disc_iters): inputs, labels = next(inf_train_data) inputs.requires_grad = True real_var = inputs.cuda() disc_loss = calculate_disc_gradients( discriminator, generator, real_var, lipschitz_constraint) avg_disc_loss += disc_loss.item() optim_disc.step() if i % args.log_interval == 0: logger_disc.add_scalar(i, 'disc_loss', disc_loss.item()) i += 1 # Train the generator gen_loss = calculate_gen_gradients(discriminator, generator, args.batch_size) avg_gen_loss += gen_loss.item() optim_gen.step() if j % args.log_interval == 0: logger_gen.add_scalar(j, 'gen_loss', gen_loss.item()) j += 1 # # Save generated images # torchvision.utils.save_image((generator.last_output.data.cpu() + 1) / 2, # 'out/samples.png', nrow=8, range=(-1, 1)) # Advance the progress bar progress.bar(gen_iter + 1, args.gen_iters, prefix='Epoch {:4d}'.format(epoch), length=30) # Calculate mean losses avg_disc_loss /= args.gen_iters * args.disc_iters avg_gen_loss /= args.gen_iters logger.add_scalar(epoch, 'gen_loss', avg_gen_loss) logger.add_scalar(epoch, 'disc_loss', avg_disc_loss) inception_score = compute_inception_score(generator, generator_batch_size=args.batch_size) logger.add_scalar(epoch, "inception_score_mean", inception_score[0]) logger.add_scalar(epoch, "inception_score_std", inception_score[1]) logger_disc.save() logger_gen.save() logger.save() # Print loss metrics for the last batch of the epoch print(f"\nepoch {epoch}:" f" disc_loss={disc_loss:8.4f}" f" gen_loss={gen_loss:8.4f}" f" inception_score={inception_score[0]:8.4f}") # Save the discriminator weights and optimiser state torch.save({ 'epoch': epoch + 1, 'model_state': discriminator.state_dict(), 'optim_state': optim_disc.state_dict(), }, os.path.join('out',args.optimizer + '_discriminator.pth')) # Save the generator weights and optimiser state torch.save({ 'epoch': epoch + 1, 'model_state': generator.state_dict(), 'optim_state': optim_gen.state_dict(), }, os.path.join('out', args.optimizer+'_generator.pth'))
import os import argparse import numpy as np import cv2 import torch from torch.utils.data import DataLoader from torchvision import datasets from torchvision.transforms import transforms from torchvision.models.resnet import resnet18 transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) parser = argparse.ArgumentParser() parser.add_argument('--dataset-dir', type=str, default='PKUMMDv1', help='dataset directory') parser.add_argument('--gpu', default=False, action='store_true', help='whether to use gpus for training') parser.add_argument('--batch-size', type=int, default=1, help='batch size') parser.add_argument('--num-workers', type=int, default=4, help='number of workers for multiprocessing') parser.add_argument('--model-path',
from torchvision.transforms import transforms from tqdm import tqdm from matplotlib import pyplot as plt import numpy as np # If you get 503 while downloading MNIST then download it manually # wget www.di.ens.fr/~lelarge/MNIST.tar.gz # tar -zxvf MNIST.tar.gz BATCH_SIZE = 32 DEVICE = torch.device('cuda:0') if torch.cuda.is_available() else torch.device( 'cpu') transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))]) trainset = tv.datasets.MNIST(root='.', train=True, download=True, transform=transform) dataloader = DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0) def imshow(axs, inp): inp = inp.cpu().detach().numpy() mean = 0.1307 std = 0.3081 inp = ((mean * inp) + std)