def get_simclr_pipeline_transform(size, s=1, num_aug=5): """Return a set of data augmentation transformations as described in the SimCLR paper.""" color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) if num_aug == 5: data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size=size), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size)), transforms.ToTensor() ]) elif num_aug == 7: data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size=size), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size)), transforms.RandomRotation(degrees=45), transforms.RandomAffine(degrees=45), transforms.ToTensor() ]) return data_transforms
def get_query_transforms(image_set): if image_set == 'train': # SimCLR style augmentation return transforms.Compose([ transforms.Resize((128, 128)), transforms.RandomApply( [ transforms.ColorJitter(0.4, 0.4, 0.4, 0.1) # not strengthened ], p=0.8), transforms.RandomGrayscale(p=0.2), transforms.RandomApply([GaussianBlur([.1, 2.])], p=0.5), transforms.ToTensor(), # transforms.RandomHorizontalFlip(), HorizontalFlip may cause the pretext too difficult, so we remove it transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) if image_set == 'val': return transforms.Compose([ transforms.Resize((128, 128)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) raise ValueError(f'unknown {image_set}')
def get_simclr_data_transforms_train(dataset_name): if dataset_name == "stl10": input_shape = (96, 96, 3) s = 1 # get a set of data augmentation transformations as described in the SimCLR paper. color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) return transforms.Compose([ transforms.RandomResizedCrop(size=input_shape[0]), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * input_shape[0])), transforms.ToTensor() ]) elif dataset_name == "cifar10": return transforms.Compose([ transforms.RandomResizedCrop(32), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply( [transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8), transforms.RandomGrayscale(p=0.2), transforms.ToTensor(), transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]) ]) else: raise RuntimeError(f"unknown dataset: {dataset_name}")
def __init__(self): self.transform = transforms.Compose([ transforms.RandomResizedCrop(224, interpolation=Image.BICUBIC), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply([ transforms.ColorJitter( brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1) ], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(p=1.0), Solarization(p=0.0), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) self.transform_prime = transforms.Compose([ transforms.RandomResizedCrop(224, interpolation=Image.BICUBIC), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply([ transforms.ColorJitter( brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1) ], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(p=0.1), Solarization(p=0.2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])
def get_simclr_data_transforms(input_shape, s=1, blur=0.1): # get a set of data augmentation transformations as described in the SimCLR paper. color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size=eval(input_shape)[0]), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), transforms.RandomApply( [GaussianBlur(kernel_size=int(0.1 * eval(input_shape)[0]))], p=blur), transforms.ToTensor() ]) return data_transforms
def __init__(self, hparams): super().__init__() self.data_dir = hparams["data_dir"] + "/snake_dataset/train" self.batch_size = hparams.get("batch_size") or 64 self.train_val_split_ratio = hparams.get("train_val_split_ratio") or 0.9 self.num_workers = hparams.get("num_workers") or 1 self.pin_memory = hparams.get("pin_memory") or False img_augmentation_transformations = [ # transforms.RandomAffine((-15, 15), translate=(0.2, 0.2)), transforms.RandomHorizontalFlip(p=1.0), transforms.RandomRotation((-15, 15)), transforms.ColorJitter(hue=.05, saturation=.05), ] self.transforms = transforms.Compose([ transforms.Resize((112, 112)), transforms.ToTensor(), transforms.RandomApply(img_augmentation_transformations, 0.5), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) self.data_train = None self.data_val = None
def get_simclr_data_transforms2(input_shape, s=1., blur=0.1): # get a set of data augmentation transformations as described in the SimCLR paper. color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size=eval(input_shape)[0]), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.5), transforms.ToTensor() ]) return data_transforms
def Transforms(Input_Dim, S=1): Color_Jitter = transforms.ColorJitter(0.8 * S, 0.8 * S, 0.8 * S, 0.2 * S) Data_Transforms = transforms.Compose([ transforms.RandomResizedCrop(size=Input_Dim[0]), transforms.RandomHorizontalFlip(), transforms.RandomApply([Color_Jitter], p=0.75), transforms.RandomGrayscale(p=0.2), GaussianBlur(int(0.1 * Input_Dim[0])), transforms.ToTensor(), ]) return Data_Transforms
def get_simclr_transform(size, s=1): """Return a set of data augmentation transformations as described in the SimCLR paper.""" color_jitter = transforms.ColorJitter(0.1 * s, 0.8 * s, 0.2 * s, 0 * s) data_transforms = transforms.Compose( [ #transforms.RandomResizedCrop(size=size), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=1), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size)), transforms.ToTensor() ]) return data_transforms
def get_simclr_pipeline_transform(size, s=1): """transforms can be improved to match well with SimCLR paper. this doesnt seem to be exactly what paper says. can try more transforms as well""" color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) # data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size=size), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size)), transforms.ToTensor() ]) return data_transforms
def get_simclr_transform(size, s=1): """Return a set of data augmentation transformations as described in the SimCLR paper.""" color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) data_transforms = transforms.Compose([ transforms.Resize(size=size), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size)), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ]) return data_transforms
def get_simclr_pipeline_transform(size, s=1): """ Returns a set of data augmentation transformations """ color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size)), transforms.ToTensor(), ]) return data_transforms
def get_simclr_data_transforms(input_shape, s=1): # get a set of data augmentation transformations as described in the SimCLR paper. normalize = transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)) color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) data_transforms = transforms.Compose([ transforms.RandomResizedCrop(size=eval(input_shape)[0], scale=(0.2, 1.)), transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), #GaussianBlur(kernel_size=int(0.1 * eval(input_shape)[0])), transforms.ToTensor(), normalize ]) return data_transforms
def get_transforms(size): base_transforms = transforms.Compose([transforms.Resize(size)]) additional_transforms = transforms.Compose([ transforms.RandomHorizontalFlip(p=0.5), # transforms.RandomApply([transforms.RandomRotation(degrees=5)], p=0.5), transforms.RandomChoice( [transforms.CenterCrop(size), transforms.RandomCrop(size)]), transforms.RandomApply([ transforms.ColorJitter( brightness=0.2, contrast=(0.9, 1.2), saturation=0.3, hue=0.01) ], p=0.5), transforms.ToTensor(), # transforms.Normalize(means, stds), Rescale(), ]) return base_transforms, additional_transforms
def get_faa_transforms_cifar_10(randomcrop=False, gauss=False): if randomcrop: random_crop = transforms.RandomCrop(32, padding=4) else: random_crop = transforms.RandomResizedCrop(28, scale=(0.2, 1.)) if not gauss: transform_train = transforms.Compose([ random_crop, transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) else: transform_train = transforms.Compose([ random_crop, transforms.RandomApply([moco.loader.GaussianBlur([.1, 2.])], p=0.5), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) print(transform_train) transform_train.transforms.insert(0, Augmentation(fa_reduced_cifar10())) print(transform_train) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD), ]) return transform_train, transform_test # okay then plug these into cifar 10, and u r set.
def create_transform(self): ''' Defines the transformation applied to the images before being returned. This can be extended as required ''' to_tensor = transforms.ToTensor() to_img = transforms.ToPILImage() self.apply_noise = transforms.Lambda(lambda x: to_img( torch.clamp( to_tensor(x) + self.noise_factor * torch.randn_like( to_tensor(x)), 0.0, 1.0))) change_colour = transforms.ColorJitter(brightness=(0.5, 1.5), contrast=(0.5, 1.5), saturation=(0, 1.5), hue=0) transform_list = [ transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply([change_colour], p=0.9) ] self.augment_data = transforms.Compose(transform_list) if not 'mean' in self.cfg.keys(): mean = [0.5, 0.5, 0.5] else: mean = [float(val) for val in self.cfg['mean'].split(',')] if not 'std' in self.cfg.keys(): std = [0.5, 0.5, 0.5] else: std = [float(val) for val in self.cfg['std'].split(',')] self.transform_to_tensor = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(mean=mean, std=std)])
def get_simclr_pipeline_transform(size, s=1, channels=3): """Return a set of data augmentation transformations as described in the SimCLR paper.""" #Original color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s) data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=size), # transforms.RandomHorizontalFlip(), transforms.RandomApply([color_jitter], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * size), channels=channels), transforms.ToTensor()]) # data_transforms = transforms.Compose([iaa.Sequential([iaa.SomeOf((1, 5), # [iaa.LinearContrast((0.5, 1.0)), # iaa.GaussianBlur((0.5, 1.5)), # iaa.Crop(percent=((0, 0.4),(0, 0),(0, 0.4),(0, 0.0)), keep_size=True), # iaa.Crop(percent=((0, 0.0),(0, 0.02),(0, 0),(0, 0.02)), keep_size=True), # iaa.Sharpen(alpha=(0.0, 0.5), lightness=(0.0, 0.5)), # iaa.PiecewiseAffine(scale=(0.02, 0.03), mode='edge'), # iaa.PerspectiveTransform(scale=(0.01, 0.02))], # random_order=True)]).augment_image, # transforms.ToTensor()]) return data_transforms
from albumentations import ( CLAHE, Blur, OpticalDistortion, GridDistortion, ElasticTransform, Solarize, RandomBrightnessContrast, RandomBrightness, Cutout, InvertImg, RandomContrast, RandomGamma, OneOf, Compose, JpegCompression, RandomShadow, PadIfNeeded, ToGray) tbaug = TenBrightAug() incbaug = IncBrightAug() colaug = ColorAug() distortaug = DistortAug() # grayimg = GrayImg() # binimg = BinImg() resizeimg = ResizeAug(800, 32) jpgaug = JPEGAug(1) randtf = transforms.RandomApply([distortaug, jpgaug]) tf01 = Compose([ JpegCompression(quality_lower=20, quality_upper=100), # RandomShadow(num_shadows_lower=1, num_shadows_upper=2), Cutout(num_holes=8, max_h_size=8, max_w_size=8), InvertImg(p=0.3), ]) tf = transforms.Compose([ # distortaug, # colaug, # tbaug, # incbaug, # jpgaug, # grayimg,
def RandomApply(self, **args): return self._add(transforms.RandomApply(**args))
LABEL_TRANSFORM = transforms.Compose([ transforms.RandomResizedCrop((384, 768), scale=(0.5, 2.), interpolation=0), transforms.RandomHorizontalFlip(), Relabel(run_cc=False), transforms.ToTensor() ]) TEST_LABEL_TRANSFORM = transforms.Compose([ transforms.Resize(size=(384, 768), interpolation=Image.NEAREST), Relabel(run_cc=False), transforms.ToTensor() ]) EXTENDED_TRANSFORM = transforms.Compose([ transforms.RandomApply([transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur([.1, 2.]), transforms.ToTensor(), ImgNormalize() ]) class CityscapesDataset: def __init__(self, root_dir, phase, class_name, instance_ratio=None, spoco=False): assert phase in ['train', 'val', 'test']
def __init__(self, root=r"C:\datasets\taco\tensors", augment_prob=0.0, reduce=0.0, image_size=84, tensors=True, random_seed=42, **kwargs): self.reduce = reduce self.tensors = tensors random.seed(random_seed) resize_train = transforms.Compose( [ transforms.Resize(image_size), transforms.CenterCrop(image_size), ] ) resize_test = transforms.Compose( [ transforms.Resize(image_size), transforms.CenterCrop(image_size), ] ) augment = transforms.Compose( [ # transforms.RandomRotation(degrees=15), transforms.RandomHorizontalFlip(p=0.5), # transforms.ColorJitter(), # transforms.RandomPerspective(p=0.2, distortion_scale=0.25), ] ) normalize = transforms.Compose( [ transforms.ToTensor(), transforms.Normalize(mean=MEAN, std=STD) ] ) self.test_transform = transforms.Compose( [ resize_test, normalize ] ) self.train_transform = transforms.Compose( [ resize_train, transforms.RandomApply([augment], p=augment_prob), normalize ] ) if not tensors: self.source_dataset_train = torchvision.datasets.ImageFolder(root=root) else: self.source_dataset_train = torchvision.datasets.DatasetFolder(root=root, loader=tensor_loader, extensions=('pt',)) self.dataset_train_size = len(self.source_dataset_train) items = [] labels = [] for i in range(self.dataset_train_size): items.append(ImageItem(self.source_dataset_train, i)) labels.append(self.source_dataset_train[i][1]) is_test = [0] * self.dataset_train_size super(TacoDataset, self).__init__(items, labels, is_test) self.train_subdataset, self.test_subdataset = self.subdataset.train_test_split() if reduce < 1: self.train_subdataset = self.train_subdataset.downscale(1 - reduce) else: self.train_subdataset = self.train_subdataset.balance(reduce)
def __init__(self, opt): # super(Batch_Balanced_Dataset, self).__init__() self.tbaug = TenBrightAug() self.incbaug = IncBrightAug() self.colaug = ColorAug() self.distortaug = DistortAug() self.grayimg = GrayImg() self.binimg = BinImg() self.jpgaug = JPEGAug(0.8) self.resizeimg = ResizeAug(opt.imgW, opt.imgH) self.resizeimg_test = ResizeAug(opt.imgW, opt.imgH, rand_scale=False) l1 = len(opt.train_data.strip().split(',')) if l1 == 1: self.batch_sizes = [int(opt.batch_size)] elif l1 == 3: self.batch_sizes = [ int(opt.batch_size * opt.batch_ratio), opt.batch_size - int(opt.batch_size * opt.batch_ratio) ] elif l1 == 4: b1 = int(opt.batch_size * opt.batch_ratio2) self.batch_sizes = [int(b1 * opt.batch_ratio), 0, 0] self.batch_sizes[1] = b1 - self.batch_sizes[0] self.batch_sizes[ 2] = opt.batch_size - self.batch_sizes[0] - self.batch_sizes[1] if not opt.alldata: self.test_books = [ '200021660', '200005598', 'hnsd006', 'umgy003', '100249416', 'umgy011', 'umgy010' ] else: print('use all data') self.test_books = [ # '200021660', # '200005598', 'hnsd006', 'umgy003', '100249416', 'umgy011', 'umgy010' ] self.train_tf1 = transforms.Compose([ self.distortaug, self.colaug, self.tbaug, self.incbaug, self.grayimg, self.binimg, self.tbaug, self.incbaug, self.jpgaug, self.resizeimg, transforms.ToTensor() ]) self.train_tf0 = transforms.Compose( [self.grayimg, self.resizeimg, transforms.ToTensor()]) self.train_tf00 = Compose([ OneOf([ OpticalDistortion(distort_limit=0.05, shift_limit=10, border_mode=cv2.BORDER_WRAP, p=0.5), ElasticTransform(p=0.5, alpha=1, sigma=50, alpha_affine=0.2, border_mode=cv2.BORDER_CONSTANT) ]), OneOf([ CLAHE(), Solarize(), RandomBrightness(), RandomContrast(limit=0.2), RandomBrightnessContrast(), ]), JpegCompression(quality_lower=20, quality_upper=100), RandomShadow(num_shadows_lower=1, num_shadows_upper=2), PadIfNeeded(min_height=64, min_width=100, border_mode=cv2.BORDER_CONSTANT, p=0.5), Cutout(num_holes=8, max_h_size=16, max_w_size=16), InvertImg(p=0.3), ToGray() ]) self.train_tf01 = Compose([ JpegCompression(quality_lower=20, quality_upper=100), Cutout(num_holes=4, max_h_size=8, max_w_size=8), InvertImg(p=0.3) ]) self.randtf = transforms.RandomApply([self.distortaug]) self.train_tf2 = transforms.Compose( [self.resizeimg_test, transforms.ToTensor()]) self.data_loader_list = [] self.datasets = [] self.data_samplers = [] self.opt = opt self.train_data = opt.train_data.strip().split(',') if not 'txt' in self.train_data[0]: self.datasets.append( RealImageLMDB(self.train_data[0], transform=self.train_tf0, transform2=self.train_tf00, testBooks=self.test_books, character=opt.character, max_batch_length=opt.batch_max_length)) else: self.datasets.append( RealImageTxtLMDB(self.train_data[0], transform=self.train_tf0, transform2=self.train_tf00, testBooks=self.test_books, max_batch_length=opt.batch_max_length)) if len(self.train_data) == 3: self.datasets.append( SynthImageLMDB(self.train_data[1], self.train_data[2], transform=self.train_tf2, transform2=self.train_tf01, size=(opt.imgH, opt.imgW), gray_bin_ratio=0.5, max_label_length=opt.batch_max_length)) if len(self.train_data) == 4: self.datasets.append( RealImageTxtLMDB(self.train_data[3], transform=self.train_tf0, transform2=self.train_tf00, testBooks=self.test_books, max_batch_length=opt.batch_max_length)) for i in range(len(self.datasets)): train_sampler = torch.utils.data.distributed.DistributedSampler( self.datasets[i]) self.data_samplers.append(train_sampler) self.data_loader_list.append( DataLoader(self.datasets[i], num_workers=int(opt.workers), shuffle=False, sampler=train_sampler, batch_size=self.batch_sizes[i], collate_fn=collate_fn, pin_memory=True, drop_last=True)) self.dataloader_iter_list = [iter(i) for i in self.data_loader_list] self.test_tf = transforms.Compose( [self.grayimg, self.resizeimg_test, transforms.ToTensor()]) self.test_dataset = RealImageLMDB(self.train_data[0], self.test_tf, testBooks=self.test_books, isTest=True, character=opt.character) self.test_sampler = torch.utils.data.distributed.DistributedSampler( self.test_dataset) self.test_loader = DataLoader(self.test_dataset, num_workers=int(opt.workers), shuffle=False, sampler=self.test_sampler, batch_size=max(2, int(opt.batch_size / 8)), collate_fn=collate_fn, drop_last=True)
def DataModule(batch_size, ks, imagenet_stats): # https://github.com/fastai/imagenette # Define parameters for dataset construction: dataset_url = 'https://s3.amazonaws.com/fast-ai-imageclas/imagenette2.tgz' dataset_filename = dataset_url.split('/')[-1] dataset_foldername = dataset_filename.split('.')[0] data_path = './data' dataset_filepath = os.path.join(data_path, dataset_filename) dataset_folderpath = os.path.join(data_path, dataset_foldername) os.makedirs(data_path, exist_ok=True) # Create a data folder (@ project folder) # If data does not exist, download it from specified URL: download = False if not os.path.exists(dataset_filepath): download = True else: md5_hash = hashlib.md5() file = open(dataset_filepath, "rb") content = file.read() md5_hash.update(content) digest = md5_hash.hexdigest() if digest != 'fe2fc210e6bb7c5664d602c3cd71e612': download = True if download: download_url(dataset_url, data_path) # Extract tar file containing dataset examples with tarfile.open(dataset_filepath, 'r:gz') as tar: tar.extractall(path=data_path) # Define model-input transforms for data augmentation: train_transform = TwoCropsTransform( transforms.Compose([ transforms.RandomResizedCrop(scale=(0.2, 1), size=224), transforms.RandomHorizontalFlip(), transforms.RandomApply( [transforms.ColorJitter(0.8, 0.8, 0.8, 0.2)], p=0.8), transforms.RandomGrayscale(p=0.2), # transforms.GaussianBlur(kernel_size=ks), transforms.ToTensor(), transforms.Normalize(**imagenet_stats) ])) # Define train and val dataset wrappers: dataset_train = torchvision.datasets.ImageFolder( os.path.join(dataset_folderpath, 'train'), train_transform) dataset_validation = torchvision.datasets.ImageFolder( os.path.join(dataset_folderpath, 'val'), train_transform) # Define train and val dataloaders: train_dataloader = torch.utils.data.DataLoader( dataset_train, batch_size=batch_size, num_workers=8, drop_last=True, shuffle=True, ) validation_dataloader = torch.utils.data.DataLoader( dataset_validation, batch_size=batch_size, num_workers=8, drop_last=True, shuffle=True, ) return train_dataloader, validation_dataloader, transforms
os.makedirs(save_path, exist_ok=True) device = "cuda" if T.cuda.is_available() else "cpu" print("device:", device) v = 0 a = 0.95 # SETUP DATA TRANSFORMS if args.random: r = args.random train_transforms = transforms.Compose([ transforms.ToTensor(), #transforms.RandomApply([ # transforms.GaussianBlur(3, sigma=(0.1, 2.0)) #], p=0.2), transforms.RandomApply( [transforms.Grayscale(num_output_channels=3)], p=0.2), transforms.RandomApply([ transforms.ColorJitter(brightness=r, contrast=r, saturation=r, hue=r) ]), transforms.RandomApply( [transforms.RandomAffine(r * 10, shear=r * 10)]), transforms.RandomResizedCrop((32, 32), scale=(1 - r, 1.0)), transforms.RandomHorizontalFlip(p=0.5), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) test_transforms = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
def train(cfg, step): # 设置保存目录 model_save_dir = os.path.join(cfg["output_dir"], "weights" + step) if not os.path.exists(model_save_dir): os.makedirs(model_save_dir) history_save_dir = os.path.join(cfg["output_dir"], "visual" + step) if not os.path.exists(history_save_dir): os.makedirs(history_save_dir) # time_mark = '2020_03_06_' # 以当前时间作为保存的文件名标识 time_mark = time.strftime('%Y_%m_%d_', time.localtime(time.time())) file_path = os.path.join(model_save_dir, time_mark + "epoch_{epoch}-model_weights.pth") history_path = os.path.join(history_save_dir, time_mark + "result.csv") callbacks_s = call_backs(file_path, history_path) # 加载数据集 train_dataset = ImageSelectFolder( root=cfg["train_dataset"], label=cfg["label"], select_condition=cfg["train_select"], data_expansion=True, transform=transforms.Compose([ transforms.RandomApply( [ transforms.RandomCrop(size=(448, 448)), # transforms.RandomResizedCrop(size=cfg["img_width"]), ], p=0.3), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(360), transforms.Resize((cfg["img_width"], cfg["img_hight"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) val_dataset = ImageSelectFolder( root=cfg["val_dataset"], label=cfg["label"], select_condition=cfg["val_select"], transform=transforms.Compose([ transforms.Resize((cfg["img_hight"], cfg["img_width"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) train_dataload = DataLoader(dataset=train_dataset, batch_size=cfg["batch_size"], shuffle=True) val_dataload = DataLoader(dataset=val_dataset, batch_size=cfg["batch_size"], shuffle=False) model = get_model(model_weight_path=cfg["model_weight_path"], model_name=cfg["model_name"], out_features=cfg["num_classes"], img_width=cfg["img_width"], img_hight=cfg["img_hight"], verbose=False) model.cuda() loss_function = nn.CrossEntropyLoss().cuda() optimizer = optim.Adam(model.parameters(), lr=cfg["lr"], weight_decay=1e-4) fit_generator = TrainFitGenerator(net=model, optimizer=optimizer, loss_function=loss_function, generator=train_dataload, epochs=cfg["nepochs"], validation_data=val_dataload, callbacks=callbacks_s) fit_generator.run() plot_training_metrics(fit_generator.history, history_save_dir, "loss", title=f"train and validation loss", is_show=False) plot_training_metrics(fit_generator.history, history_save_dir, "acc", title=f"train and validation accuracy", is_show=False)
def main(cfg, step): model_save_dir = os.path.join(cfg["output_dir"], "weights" + step) if not os.path.exists(model_save_dir): os.makedirs(model_save_dir) history_save_dir = os.path.join(cfg["output_dir"], "visual" + step) if not os.path.exists(history_save_dir): os.makedirs(history_save_dir) # time_mark = '2020_03_06_' # 以当前时间作为保存的文件名标识 time_mark = time.strftime('%Y_%m_%d_', time.localtime(time.time())) file_path = os.path.join(model_save_dir, time_mark + "epoch_{epoch}-model_weights.pth") history_path = os.path.join(history_save_dir, time_mark + "result.csv") callbacks_s = call_backs(file_path, history_path) train_dataset = ImageSelectFolder( root=cfg["train_dataset"], label=cfg["label"], select_condition=cfg["train_select"], data_expansion=True, transform=transforms.Compose([ transforms.RandomApply( [ transforms.RandomCrop(size=(448, 448)), # transforms.RandomResizedCrop(size=cfg["img_width"]), ], p=0.3), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(360), transforms.Resize((cfg["img_width"], cfg["img_hight"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) val_dataset = ImageSelectFolder( root=cfg["val_dataset"], label=cfg["label"], select_condition=cfg["val_select"], transform=transforms.Compose([ transforms.Resize((cfg["img_width"], cfg["img_hight"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) train_dataload = DataLoader(dataset=train_dataset, batch_size=cfg["batch_size"], shuffle=True) val_dataload = DataLoader(dataset=val_dataset, batch_size=cfg["batch_size"], shuffle=False) model = get_model(model_weight_path=cfg["model_weight_path"], model_name=cfg["model_name"], out_features=cfg["num_classes"], img_width=cfg["img_width"], img_hight=cfg["img_hight"], verbose=True) model.cuda() loss_function = nn.CrossEntropyLoss().cuda() # 定义额外的评价指标 recall = GetRecallScore(average="micro") precision = GetPrecisionScore(average="micro") f1 = GetF1Score(average="micro") metrics = {"recall": recall, "precision": precision, "f1 score": f1} train_transfer_learning(model, loss_function, train_dataload, val_dataload, cfg["tl_lr"], epochs=3, metrics=metrics) trrain_fine_tuning(model, loss_function, train_dataload, val_dataload, history_save_dir, lr=cfg["ft_lr"], epochs=cfg["nepochs"], callbacks=callbacks_s, metrics=metrics) del model
transformsList = [ # transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.RandomRotation(15), transforms.RandomAffine(degrees=0, translate=(.3, .7)), # transforms.ColorJitter( # brightness=float(0.1*np.random.rand(1)), # contrast=float(0.1*np.random.rand(1)), # saturation=float(0.1*np.random.rand(1)), # hue=float(0.1*np.random.rand(1))), #transforms.RandomGrayscale(p=0.1) ] data_aug_transforms = transformsList data_aug_transforms = transforms.RandomApply(transformsList, p=0.5) # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)***** # norm_transform = transforms.Compose([data_aug_transforms]+[transforms.ToTensor()]) # test_transform = transforms.Compose([transforms.ToTensor()]) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) val_loader = torch.utils.data.DataLoader(dataset=val_dataset, batch_size=batch_size, shuffle=False) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)