def get_train_data(rec_train, batch_size, data_nthreads, input_size, crop_ratio, args): def train_batch_fn(batch, ctx): data = batch[0].as_in_context(ctx) label = batch[1].as_in_context(ctx) return data, label jitter_param = 0.4 lighting_param = 0.1 resize = int(math.ceil(input_size / crop_ratio)) train_transforms = [] if args.auto_aug: print('Using AutoAugment') from autogluon.utils.augment import AugmentationBlock, autoaug_imagenet_policies train_transforms.append(AugmentationBlock(autoaug_imagenet_policies())) from gluoncv.utils.transforms import EfficientNetRandomCrop from autogluon.utils import pil_transforms if input_size >= 320: train_transforms.extend([ EfficientNetRandomCrop(input_size), pil_transforms.Resize((input_size, input_size), interpolation=Image.BICUBIC), pil_transforms.RandomHorizontalFlip(), pil_transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) else: train_transforms.extend([ transforms.RandomResizedCrop(input_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) transform_train = transforms.Compose(train_transforms) train_set = mx.gluon.data.vision.ImageRecordDataset( rec_train).transform_first(transform_train) train_sampler = SplitSampler(len(train_set), num_parts=num_workers, part_index=rank) train_data = gluon.data.DataLoader( train_set, batch_size=batch_size, # shuffle=True, last_batch='discard', num_workers=data_nthreads, sampler=train_sampler) return train_data, train_batch_fn
def __init__(self, name=None, train_path=None, val_path=None, input_size=224, crop_ratio=0.875, jitter_param=0.4, **kwargs): self.name = name self.train_path = train_path self.val_path = val_path self.input_size = input_size resize = int(math.ceil(input_size / crop_ratio)) self.transform_train = transforms.Compose([ transforms.Resize(resize), transforms.RandomResizedCrop(input_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(0.1), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) self.transform_val = transforms.Compose([ transforms.Resize(resize), transforms.CenterCrop(input_size), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) self._read_dataset(**kwargs)
def load_img_batch(dataset, batch_size, type): if type == 'train': transform=img_transforms.Compose([\ #随机对图像裁剪出面积为原图像面积的0.08~1倍 #高/宽:3/4 ~ 4/3,最后高度与宽度都缩放到224像素 img_transforms.RandomResizedCrop(224,scale=(0.08,1.0),ratio=(3.0/4.0,4.0/3.0)),\ #随机左右翻转 img_transforms.RandomFlipLeftRight(),\ #随机变化亮度、对比度、饱和度 img_transforms.RandomColorJitter(brightness=0.4,contrast=0.4,saturation=0.4),\ #随机噪声 img_transforms.RandomLighting(0.1),\ img_transforms.ToTensor(),\ # 对图像的每个通道做标准化 img_transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])]) return gdata.DataLoader(dataset.transform_first(transform), batch_size=batch_size, shuffle=True, last_batch='keep') elif type == 'test': transform=img_transforms.Compose([\ img_transforms.Resize(256),\ img_transforms.CenterCrop(224),\ img_transforms.ToTensor(),\ img_transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])]) return gdata.DataLoader(dataset.transform_first(transform), batch_size=batch_size, shuffle=False, last_batch='keep')
def get_train_data_source(dataset_name, dataset_dir, batch_size, num_workers): jitter_param = 0.4 lighting_param = 0.1 mean_rgb = (0.4914, 0.4822, 0.4465) std_rgb = (0.2023, 0.1994, 0.2010) transform_train = transforms.Compose([ RandomCrop(size=32, pad=4), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ]) if dataset_name == "CIFAR10": dataset_class = gluon.data.vision.CIFAR10 elif dataset_name == "CIFAR100": dataset_class = CIFAR100Fine else: raise Exception('Unrecognized dataset: {}'.format(dataset_name)) return gluon.data.DataLoader(dataset=dataset_class( root=dataset_dir, train=True).transform_first(fn=transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers)
def imagenet_train_transform(ds_metainfo, mean_rgb=(0.485, 0.456, 0.406), std_rgb=(0.229, 0.224, 0.225), jitter_param=0.4, lighting_param=0.1): input_image_size = ds_metainfo.input_image_size if ds_metainfo.aug_type == "default": interpolation = 1 elif ds_metainfo.aug_type == "ext1": interpolation = 10 elif ds_metainfo.aug_type == "ext2": interpolation = 10 else: raise RuntimeError("Unknown augmentation type: {}\n".format( ds_metainfo.aug_type)) return transforms.Compose([ transforms.RandomResizedCrop(size=input_image_size, interpolation=interpolation), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ])
def test_of_trans(): transformer = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomLighting(0.1), # transforms.ToTensor(), # transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) up_folder = os.path.abspath(os.path.join(ROOT_DIR, '..')) img_folder = os.path.join(up_folder, 'data_set', 'XX-ImageLabel', 'train_data_416') img_file = os.path.join(DATA_DIR, "t_img_tags_train.txt") # 数据类别 img_saved = os.path.join(img_file + ".tp.npz") td = TripletDataset(data_folder=img_folder, data_file=img_file, saved_path=img_saved, transform=transformer) # td = TripletDataset(data_folder=img_folder, data_file=img_file, saved_path=img_saved) train_data = DataLoader(td, batch_size=4, shuffle=True) for count, data in enumerate(train_data): print('OK') imgs, labels = data[0], data[1] print(imgs.shape, labels.shape) if count == 0: plt.subplot(131) plt.imshow(imgs[0][0].asnumpy()) plt.subplot(132) plt.imshow(imgs[0][1].asnumpy()) plt.subplot(133) plt.imshow(imgs[0][2].asnumpy()) plt.show() break
def get_data_loader(data_dir, batch_size, num_workers): normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) jitter_param = 0.4 lighting_param = 0.1 input_size = opt.input_size def batch_fn(batch, ctx): data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0) label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0) return data, label transform_train = transforms.Compose([ transforms.RandomResizedCrop(input_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) transform_test = transforms.Compose([ transforms.Resize(256, keep_ratio=True), transforms.CenterCrop(input_size), transforms.ToTensor(), normalize ]) train_data = gluon.data.DataLoader( imagenet.classification.ImageNet(data_dir, train=True).transform_first(transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers) val_data = gluon.data.DataLoader( imagenet.classification.ImageNet(data_dir, train=False).transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=num_workers) return train_data, val_data, batch_fn
def get_train_data_source(dataset_dir, batch_size, num_workers, input_image_size=(224, 224)): jitter_param = 0.4 lighting_param = 0.1 mean_rgb = (0.485, 0.456, 0.406) std_rgb = (0.229, 0.224, 0.225) transform_train = transforms.Compose([ transforms.RandomResizedCrop(input_image_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ]) dataset = CUB200_2011(root=dataset_dir, train=True).transform_first(fn=transform_train) # num_training_samples = len(dataset) return gluon.data.DataLoader(dataset=dataset, batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers)
def get_data_loader(data_dir, batch_size, num_workers): normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) jitter_param = 0.4 lighting_param = 0.1 def batch_fn(batch, ctx): data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0) label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0) return data, label if opt.mode == 'symbolic': train_data = mx.io.NDArrayIter( mx.nd.random.normal(shape=(opt.dataset_size, 3, 224, 224)), label=mx.nd.array(range(opt.dataset_size)), batch_size=batch_size, ) # val_data = mx.io.NDArrayIter( # mx.nd.random.normal(shape=(opt.dataset_size, 3, 224, 224)), # label=mx.nd.array(range(opt.dataset_size)), # batch_size=batch_size, # ) else: transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) # transform_test = transforms.Compose([ # transforms.Resize(256, keep_ratio=True), # transforms.CenterCrop(224), # transforms.ToTensor(), # normalize # ]) train_data = gluon.data.DataLoader(imagenet.classification.ImageNet( data_dir, train=True).transform_first(transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers) # val_data = gluon.data.DataLoader( # imagenet.classification.ImageNet(data_dir, train=False).transform_first(transform_test), # batch_size=batch_size, shuffle=False, num_workers=num_workers) if 'sync' in opt.kvstore: raise ValueError( "Need to resize iterator for distributed training to not hang at the end" ) # return train_data, val_data, batch_fn return train_data, batch_fn
def imagenet_train_transform(ds_metainfo, mean_rgb=(0.485, 0.456, 0.406), std_rgb=(0.229, 0.224, 0.225), jitter_param=0.4, lighting_param=0.1): """ Create image transform sequence for training subset. Parameters: ---------- ds_metainfo : DatasetMetaInfo ImageNet-1K dataset metainfo. mean_rgb : tuple of 3 float Mean of RGB channels in the dataset. std_rgb : tuple of 3 float STD of RGB channels in the dataset. jitter_param : float How much to jitter values. lighting_param : float How much to noise intensity of the image. Returns ------- Sequential Image transform sequence. """ input_image_size = ds_metainfo.input_image_size if ds_metainfo.aug_type == "aug0": interpolation = 1 transform_list = [] elif ds_metainfo.aug_type == "aug1": interpolation = 10 transform_list = [] elif ds_metainfo.aug_type == "aug2": interpolation = 10 transform_list = [ ImgAugTransform() ] else: raise RuntimeError("Unknown augmentation type: {}\n".format(ds_metainfo.aug_type)) transform_list += [ transforms.RandomResizedCrop( size=input_image_size, interpolation=interpolation), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter( brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize( mean=mean_rgb, std=std_rgb) ] return transforms.Compose(transform_list)
def preprocess_train_data(normalize, jitter_param, lighting_param): transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) return transform_train
def cifar10_train_transform(mean_rgb=(0.4914, 0.4822, 0.4465), std_rgb=(0.2023, 0.1994, 0.2010), jitter_param=0.4, lighting_param=0.1): return transforms.Compose([ RandomCrop(size=32, pad=4), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ])
def get_data_loader(data_dir, batch_size, num_workers, input_image_size=(224, 224), resize_inv_factor=0.875): assert (resize_inv_factor > 0.0) if isinstance(input_image_size, int): input_image_size = (input_image_size, input_image_size) normalize = transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) jitter_param = 0.4 lighting_param = 0.1 resize_value = int( math.ceil(float(input_image_size[0]) / resize_inv_factor)) def batch_fn(batch, ctx): data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0) label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0) return data, label transform_train = transforms.Compose([ transforms.RandomResizedCrop(input_image_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) transform_test = transforms.Compose([ transforms.Resize(resize_value, keep_ratio=True), transforms.CenterCrop(input_image_size), transforms.ToTensor(), normalize ]) train_data = gluon.data.DataLoader(ImageNet( data_dir, train=True).transform_first(transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers) val_data = gluon.data.DataLoader(ImageNet( data_dir, train=False).transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=num_workers) return train_data, val_data, batch_fn
def imagenet_train_transform(input_image_size=(224, 224), mean_rgb=(0.485, 0.456, 0.406), std_rgb=(0.229, 0.224, 0.225), jitter_param=0.4, lighting_param=0.1): return transforms.Compose([ transforms.RandomResizedCrop(input_image_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ])
def generate_transform(train, resize, _is_osx, input_size, jitter_param): if _is_osx: # using PIL to load image (slow) if train: transform = Compose( [ RandomResizedCrop(input_size), RandomHorizontalFlip(), ColorJitter(0.4, 0.4, 0.4), ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ] ) else: transform = Compose( [ Resize(resize), CenterCrop(input_size), ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ] ) else: if train: transform = transforms.Compose( [ transforms.RandomResizedCrop(input_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter( brightness=jitter_param, contrast=jitter_param, saturation=jitter_param ), transforms.RandomLighting(0.1), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ] ) else: transform = transforms.Compose( [ transforms.Resize(resize), transforms.CenterCrop(input_size), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ] ) return transform
def get_data_loader(data_dir, batch_size, num_workers, input_size, crop_ratio, train_dataset=None, val_dataset=None): normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) jitter_param = 0.4 lighting_param = 0.1 input_size = input_size crop_ratio = crop_ratio if crop_ratio > 0 else 0.875 resize = int(math.ceil(input_size / crop_ratio)) transform_train = transforms.Compose([ transforms.RandomResizedCrop(input_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) transform_test = transforms.Compose([ transforms.Resize(resize, keep_ratio=True), transforms.CenterCrop(input_size), transforms.ToTensor(), normalize ]) if not train_dataset: train_dataset = imagenet.classification.ImageNet(data_dir, train=True) if not val_dataset: val_dataset = imagenet.classification.ImageNet(data_dir, train=False) train_data = gluon.data.DataLoader( train_dataset.transform_first(transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers) val_data = gluon.data.DataLoader( val_dataset.transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=num_workers) return train_data, val_data, loader_batch_fn
def get_data_raw(dataset_path, batch_size, num_workers): train_path = os.path.join(dataset_path, 'train') val_path = os.path.join(dataset_path, 'val') test_path = os.path.join(dataset_path, 'test') normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) jitter_param = 0.4 lighting_param = 0.1 input_size = 224 crop_ratio = 0.875 resize = int(math.ceil(input_size / crop_ratio)) transform_train = transforms.Compose([ transforms.RandomResizedCrop(input_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) transform_test = transforms.Compose([ transforms.Resize(resize, keep_ratio=True), transforms.CenterCrop(input_size), transforms.ToTensor(), normalize ]) train_data = gluon.data.DataLoader(gluon.data.vision.ImageFolderDataset( train_path).transform_first(transform_train), batch_size=batch_size, shuffle=True, num_workers=num_workers) val_data = gluon.data.DataLoader(gluon.data.vision.ImageFolderDataset( val_path).transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=num_workers) test_data = gluon.data.DataLoader(gluon.data.vision.ImageFolderDataset( test_path).transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=num_workers) return train_data, val_data, test_data
def get_data_loader(logger): jitter_param = 0.4 lighting_param = 0.1 transform_train = transforms.Compose([ transforms.Resize(256), # ImageNetPolicy(), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) transform_test = transforms.Compose([ transforms.Resize(256), # transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) synsets, all_items = list_images(root=config.DATA_PATH) train_items, test_items = train_test_split( all_items, test_size=config.TEST_SIZE, random_state=config.RANDOM_STATE) # 训练集和测试集 train_dataset = ImageFolderDataset(synsets=synsets, list_images=train_items, flag=1) test_dataset = ImageFolderDataset(synsets=synsets, list_images=test_items, flag=1) logger.info('训练集的样本数是:%s,测试集的样本数是:%s' % (len(train_dataset), len(test_dataset))) train_dataloader = gluon.data.DataLoader( train_dataset.transform_first(transform_train), batch_size=config.BATCH_SIZE, last_batch='rollover', shuffle=True, num_workers=config.WORKERS) test_dataloader = gluon.data.DataLoader( test_dataset.transform_first(transform_test), batch_size=config.BATCH_SIZE, last_batch='rollover', shuffle=False, num_workers=config.WORKERS) return train_dataloader, test_dataloader
def cifar10_train_transform(ds_metainfo, mean_rgb=(0.4914, 0.4822, 0.4465), std_rgb=(0.2023, 0.1994, 0.2010), jitter_param=0.4, lighting_param=0.1): assert (ds_metainfo is not None) assert (ds_metainfo.input_image_size[0] == 32) return transforms.Compose([ RandomCrop(size=32, pad=4), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ])
def get_train_data_loader(data_dir, batch_size, num_workers, input_image_size, mean_rgb, std_rgb, jitter_param, lighting_param): transform_train = transforms.Compose([ transforms.RandomResizedCrop(input_image_size), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ]) return gluon.data.DataLoader(dataset=ImageNet( root=data_dir, train=True).transform_first(fn=transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers)
def test_transformer(): from mxnet.gluon.data.vision import transforms transform = transforms.Compose([ transforms.Resize(300), transforms.CenterCrop(256), transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(0.1, 0.1, 0.1, 0.1), transforms.RandomBrightness(0.1), transforms.RandomContrast(0.1), transforms.RandomSaturation(0.1), transforms.RandomHue(0.1), transforms.RandomLighting(0.1), transforms.ToTensor(), transforms.Normalize([0, 0, 0], [1, 1, 1])]) transform(mx.nd.ones((245, 480, 3), dtype='uint8')).wait_to_read()
def get_train_data(batch_size=8): """ process train data, add transforms. :param batch_size: per process num of samples :return: train data """ transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomLighting(0.1), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) img_folder, img_file = get_data_path() td = MultilabelDataset(data_folder=img_folder, data_file=img_file) train_data = DataLoader(td.transform_first(transform_train), batch_size=batch_size, shuffle=True) return train_data
def get_transform(jitter_param=0.4, pca_noise=0.2): # Init transformer # See https://mxnet.apache.org/api/python/docs/tutorials/packages/gluon/data/data_augmentation.html transform_train = transforms.Compose([ transforms.Resize(32), transforms.RandomResizedCrop((32, 32), scale=(0.8, 1.0), ratio=(0.9, 1.1)), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param, hue=jitter_param), transforms.RandomLighting(alpha=pca_noise), transforms.ToTensor(), transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]) ]) transform_test = transforms.Compose([ transforms.Resize(32), transforms.ToTensor(), transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]) ]) return transform_train, transform_test
def get_triplet_train_data(batch_size=8): """ triplet loss :param batch_size: 批次大小 :return: """ transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomLighting(0.1), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) img_folder, img_file = get_data_path() img_saved = os.path.join(img_file + ".tp.npz") td = TripletDataset(data_folder=img_folder, data_file=img_file, saved_path=img_saved, transform=transform_train) train_data = DataLoader(td, batch_size=batch_size, shuffle=True) return train_data
def GluonTransformation(data: mx.nd.array): """ data: mx.nd.array h,w,c retrun data: mx.nd.array """ data = mx.nd.array(data) transform = transforms.Compose([ transforms.RandomResizedCrop(200, (0.8, 1.0)), transforms.CenterCrop((300, 300)), transforms.RandomFlipLeftRight(), transforms.RandomFlipTopBottom(), transforms.RandomLighting(0.3), transforms.RandomColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.2), transforms.Resize(384), transforms.ToTensor(), # h,w,c -> c, h, w transforms.Normalize(0, 1) ]) data = transform(data) return data # if __name__=='__main__': # img=cv2.imread('1.jpg') # img_out=ImageRotate(img,30) # # img_out=transformation(img) # cv2.imshow('ori',img) # cv2.imshow('rotate',img_out) # cv2.waitKey(0) # # cv2.imshow('img',mx.nd.clip(img_out,0,255).asnumpy().astype(np.uint8)) # # cv2.imshow('img',img_out.asnumpy().astype(np.uint8)) # # cv2.waitKey(0) # print('done!')
def generate_transform(train, input_size, jitter_param=0.4, crop_ratio=1): resize = int(math.ceil(input_size / crop_ratio)) if train: transform = transforms.Compose([ transforms.RandomResizedCrop(input_size, scale=(0.6, 1)), transforms.RandomFlipTopBottom(), transforms.RandomFlipLeftRight(), RandomColorDistort(), RandomExpansion(), transforms.RandomLighting(0.2), transforms.Resize(resize), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) else: transform = transforms.Compose([ transforms.Resize(resize), transforms.CenterCrop(input_size), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) return transform
def get_dataloader(train_dataset, val_dataset, batch_size, num_workers): jitter_param = 0.4 lighting_param = 0.1 normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) transform_train = transforms.Compose([ transforms.Resize(480), transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) transform_test = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize ]) train_data = gluon.data.DataLoader( train_dataset.transform_first(transform_train), batch_size=batch_size, shuffle=True, num_workers=num_workers, last_batch='rollover') val_data = gluon.data.DataLoader( val_dataset.transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=num_workers, last_batch='keep') return train_data, val_data
def get_train_data(self, batch_size): """ 获取训练数据,数据扩充 """ transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomLighting(0.1), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) td = MultilabelDataset(data_folder=self.train_folder, data_file=self.train_file, transform=transform_train) train_data = DataLoader(dataset=td, batch_size=batch_size, shuffle=True) return train_data, len(td)
def get_train_data_source(dataset_args, batch_size, num_workers): jitter_param = 0.4 lighting_param = 0.1 mean_rgb = (0.4914, 0.4822, 0.4465) std_rgb = (0.2023, 0.1994, 0.2010) data_dir = dataset_args.data_dir transform_train = transforms.Compose([ RandomCrop(size=32, pad=4), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), transforms.Normalize(mean=mean_rgb, std=std_rgb) ]) return gluon.data.DataLoader(dataset=gluon.data.vision.CIFAR10( root=data_dir, train=True).transform_first(fn=transform_train), batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers)
def train_indoor(args, config, reporter): vars(args).update(config) np.random.seed(args.seed) random.seed(args.seed) mx.random.seed(args.seed) # Set Hyper-params batch_size = args.batch_size * max(args.num_gpus, 1) ctx = [mx.gpu(i) for i in range(args.num_gpus)] if args.num_gpus > 0 else [mx.cpu()] # Define DataLoader train_path = os.path.join(args.data, 'train') test_path = os.path.join(args.data, 'val') jitter_param = 0.4 lighting_param = 0.1 normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) transform_train = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param, saturation=jitter_param), transforms.RandomLighting(lighting_param), transforms.ToTensor(), normalize ]) transform_test = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize ]) train_data = gluon.data.DataLoader(gluon.data.vision.ImageFolderDataset( train_path).transform_first(transform_train), batch_size=batch_size, shuffle=True, num_workers=args.num_workers) test_data = gluon.data.DataLoader(gluon.data.vision.ImageFolderDataset( test_path).transform_first(transform_test), batch_size=batch_size, shuffle=False, num_workers=args.num_workers) # Load model architecture and Initialize the net with pretrained model finetune_net = get_model(args.model, pretrained=True) with finetune_net.name_scope(): finetune_net.fc = nn.Dense(args.classes) finetune_net.fc.initialize(init.Xavier(), ctx=ctx) finetune_net.collect_params().reset_ctx(ctx) finetune_net.hybridize() # Define trainer trainer = gluon.Trainer(finetune_net.collect_params(), 'sgd', { 'learning_rate': args.lr, 'momentum': args.momentum, 'wd': args.wd }) L = gluon.loss.SoftmaxCrossEntropyLoss() metric = mx.metric.Accuracy() def train(epoch): if epoch == args.lr_step: trainer.set_learning_rate(trainer.learning_rate * args.lr_factor) for i, batch in enumerate(train_data): data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0, even_split=False) label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0, even_split=False) with ag.record(): outputs = [finetune_net(X) for X in data] loss = [L(yhat, y) for yhat, y in zip(outputs, label)] for l in loss: l.backward() trainer.step(batch_size) mx.nd.waitall() def test(): test_loss = 0 for i, batch in enumerate(test_data): data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0, even_split=False) label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0, even_split=False) outputs = [finetune_net(X) for X in data] loss = [L(yhat, y) for yhat, y in zip(outputs, label)] test_loss += sum([l.mean().asscalar() for l in loss]) / len(loss) metric.update(label, outputs) _, test_acc = metric.get() test_loss /= len(test_data) reporter(mean_loss=test_loss, mean_accuracy=test_acc) for epoch in range(1, args.epochs + 1): train(epoch) test()