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()
