def load_images(images_file_path,
batch_size,
resize_size=256,
is_train=True,
crop_size=224,
is_cen=False,
sampler=None,
pseudo_labels=None):
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if not is_train:
transformer = transforms.Compose([
transforms.Resize(resize_size),
transforms.CenterCrop(crop_size),
transforms.ToTensor(), normalize
])
shuffle = False
last_bacth = 'keep'
else:
if is_cen:
transformer = transforms.Compose([
transforms.Resize(resize_size),
transforms.CenterCrop(crop_size),
transforms.RandomFlipLeftRight(),
transforms.ToTensor(), normalize
])
else:
transformer = transforms.Compose([
transforms.Resize(resize_size),
transforms.RandomResizedCrop(crop_size, scale=(0.8, 1.0)),
transforms.RandomFlipLeftRight(),
transforms.ToTensor(), normalize
])
shuffle = False if sampler is not None else True
last_bacth = 'keep'
imageset = ImageFolderDataset(images_file_path,
pseudo_labels=pseudo_labels)
data_loader = DataLoader(dataset=imageset.transform_first(transformer),
shuffle=shuffle,
batch_size=batch_size,
last_batch=last_bacth,
sampler=sampler,
num_workers=0)
return data_loader
def __init__(self, args):
self.args = args
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
# dataset and dataloader
trainset = get_segmentation_dataset(
args.dataset, split='train', transform=input_transform)
valset = get_segmentation_dataset(
args.dataset, split='val', transform=input_transform)
self.train_data = gluon.data.DataLoader(
trainset, args.batch_size, shuffle=True, last_batch='rollover',
num_workers=args.workers)
self.eval_data = gluon.data.DataLoader(valset, args.test_batch_size,
last_batch='keep', num_workers=args.workers)
# create network
model = get_segmentation_model(model=args.model, dataset=args.dataset,
backbone=args.backbone, norm_layer=args.norm_layer,
aux=args.aux, norm_kwargs=args.norm_kwargs)
# model.hybridize(static_alloc=True, static_shape=True)
print(model)
self.net = DataParallelModel(model, args.ctx, args.syncbn)
self.evaluator = DataParallelModel(SegEvalModel(model), args.ctx)
# resume checkpoint if needed
if args.resume is not None:
if os.path.isfile(args.resume):
model.load_params(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
# create criterion
criterion = SoftmaxCrossEntropyLossWithAux(args.aux)
self.criterion = DataParallelCriterion(criterion, args.ctx, args.syncbn)
# optimizer and lr scheduling
self.lr_scheduler = LRScheduler(mode='poly', baselr=args.lr,
niters=len(self.train_data),
nepochs=args.epochs)
kv = mx.kv.create(args.kvstore)
self.optimizer = gluon.Trainer(self.net.module.collect_params(), 'sgd',
{'lr_scheduler': self.lr_scheduler,
'wd':args.weight_decay,
'momentum': args.momentum,
'multi_precision': True},
kvstore = kv)
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
crop_ratio = opt.crop_ratio if opt.crop_ratio > 0 else 0.875
resize = int(math.ceil(input_size / crop_ratio))
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(resize, 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_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
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
def transform_eval(imgs,
resize_short=256,
crop_size=224,
mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225)):
"""A util function to transform all images to tensors as network input by applying
normalizations. This function support 1 NDArray or iterable of NDArrays.
Parameters
----------
imgs : NDArray or iterable of NDArray
Image(s) to be transformed.
resize_short : int, default=256
Resize image short side to this value and keep aspect ratio.
crop_size : int, default=224
After resize, crop the center square of size `crop_size`
mean : iterable of float
Mean pixel values.
std : iterable of float
Standard deviations of pixel values.
Returns
-------
mxnet.NDArray or list of such tuple
A (1, 3, H, W) mxnet NDArray as input to network
If multiple image names are supplied, return a list.
"""
if isinstance(imgs, mx.nd.NDArray):
imgs = [imgs]
for im in imgs:
assert isinstance(im, mx.nd.NDArray), "Expect NDArray, got {}".format(
type(im))
transform_fn = transforms.Compose([
transforms.Resize(resize_short, keep_ratio=True),
transforms.CenterCrop(crop_size),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
res = [transform_fn(img).expand_dims(0) for img in imgs]
if len(res) == 1:
return res[0]
return res
def predict(self, X, input_size=224, plot=True):
""" This method should be able to produce predictions regardless if:
X = single data example (e.g. single image),
X = task.Dataset object
"""
"""The task predict function given an input.
Parameters
----------
X : str or :func:`autogluon.task.ImageClassification.Dataset`
path to the input image or dataset
Example:
>>> ind, prob = classifier.predict('example.jpg')
"""
# model inference
input_size = self.model.input_size if hasattr(self.model, 'input_size') else input_size
resize = int(math.ceil(input_size / 0.875))
transform_fn = Compose([
Resize(resize),
CenterCrop(input_size),
ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
def predict_img(img):
# load and display the image
proba = self.predict_proba(img)
ind = mx.nd.argmax(proba, axis=1).astype('int')
idx = mx.nd.stack(mx.nd.arange(proba.shape[0], ctx=proba.context),
ind.astype('float32'))
probai = mx.nd.gather_nd(proba, idx)
return ind, probai
if isinstance(X, str) and os.path.isfile(X):
img = self.loader(X)
if plot:
plt.imshow(np.array(img))
plt.show()
img = transform_fn(img)
return predict_img(img)
if isinstance(X, AutoGluonObject):
X = X.init()
inds, probas = [], []
for x in X:
ind, proba = predict_img(x[0])
inds.append(ind)
probas.append(proba)
return inds, probas
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 get_tl_val_data(self, batch_size):
"""
获取TripletLoss验证数据, 一组3个, 数据扩充
"""
transform_val = transforms.Compose([
transforms.Resize(256),
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
td = TripletDataset(data_folder=self.val_folder,
data_file=self.val_file,
transform=transform_val,
saved_path=True)
val_data = DataLoader(dataset=td, batch_size=batch_size, shuffle=True)
return val_data, len(td)
def detect_img_to_class(self, img_path):
img = image.imread(img_path)
transform_fn = transforms.Compose([
transforms.Resize(224, keep_ratio=True),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
img = transform_fn(img)
img = nd.expand_dims(img, axis=0)
res = self.net_cl(img.as_in_context(self.ctx))
res = sigmoid(nd.squeeze(res)).asnumpy()
res = np.where(res > 0.5, 1, 0)
indexes, = np.where(res == 1)
return indexes
def preprocess(batch_size, size=(256, 256)):
transform_train = transforms.Compose([
transforms.Resize(size=size),
# Transpose the image from height*width*num_channels to num_channels*height*width
# and map values from [0, 255] to [0,1]
transforms.ToTensor(),
# Normalize the image with mean and standard deviation calculated across all images
transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])
])
train_data = gluon.data.DataLoader(
gluon.data.vision.CIFAR10(train=True).transform_first(transform_train),
batch_size=batch_size,
shuffle=False,
last_batch='discard')
return train_data # 我们需要的是 for i, batch in enumerate(train_data)中的batch[0](也就是图片数据，我们不需要标签数据)
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 __init__(self,
root,
subset,
input_size,
transform,
image_dir='imgs',
label_dir='gt',
image_set_dir='ImageSets',
image_suffix='.jpg',
label_suffix='.png',
inference=False):
self.input_size = input_size
self.resize_bilinear = gluon.data.vision.transforms.Resize(size=(self.input_size, self.input_size), interpolation=1)
self.resize_nearst = gluon.data.vision.transforms.Resize(size=(self.input_size, self.input_size), interpolation=0)
self.transform = transform
self.color_aug = transforms.RandomColorJitter(brightness=.3, contrast=.3, saturation=.3, hue=.3)
self.input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225])
])
self.inference = inference
if not isinstance(root, list):
root = [root]
subset = [subset]
label_name = label_dir
self.images_path = []
self.labels_path = []
self.img_info = []
for r, s in zip(root, subset):
txt_fname = os.path.join(r, image_set_dir, s + '.txt')
with open(txt_fname, 'r') as f:
image_names = f.read().split()
n = len(image_names)
image_path, label_path, img_info = [None] * n, [None] * n, [None] * n
for i in range(n):
image_path[i] = os.path.join(r, image_dir, image_names[i] + image_suffix)
label_path[i] = os.path.join(r, label_name, image_names[i] + label_suffix)
if self.inference:
data = mx.image.imread(image_path[i])
img_info[i] = {'name': image_names[i], 'size': data.shape[0:2]}
self.images_path += image_path
self.labels_path += label_path
self.img_info += img_info
print(f"{root} {subset} has {n} images.")
def __init__(self,
data_dir,
strides=4,
input_size=(640, 640),
num_kernels=6,
debug=False):
super(ICDAR, self).__init__()
self.data_dir = data_dir
self.imglst = glob.glob1(self.data_dir, '*g')
self.length = len(self.imglst)
self.input_size = input_size
self.strides = strides
self.num_kernel = num_kernels
self.debug = debug
self.trans = transforms.Compose([
# transforms.RandomColorJitter(brightness = 32.0 / 255, saturation = 0.5),
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
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 crop_resize_normalize(img, bbox_list, output_size):
output_list = []
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
for bbox in bbox_list:
x0 = max(int(bbox[0]), 0)
y0 = max(int(bbox[1]), 0)
x1 = min(int(bbox[2]), int(img.shape[1]))
y1 = min(int(bbox[3]), int(img.shape[0]))
w = x1 - x0
h = y1 - y0
res_img = image.fixed_crop(nd.array(img), x0, y0, w, h,
(output_size[1], output_size[0]))
res_img = transform_test(res_img)
output_list.append(res_img)
output_array = nd.stack(*output_list)
return output_array
def get_input():
labels = [x.rstrip() for x in open(label_path).readlines()]
img = mx.image.imread(img_path)
img = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])(img)
img = img.expand_dims(axis=0).asnumpy()
open('resnet_data/input', 'wb').write(img.tobytes())
sess = rt.InferenceSession(model_path)
input_name = sess.get_inputs()[0].name
label_name = sess.get_outputs()[0].name
pred = softmax(np.squeeze(sess.run([label_name], {input_name: img})[0]))
for i in np.argsort(pred)[::-1][0:5]:
print(f'id = {i}, class = {labels[i]}, prob = {pred[i]}')
def train_loader(path, batch_size=32, num_workers=4):
normalize = transforms.Normalize(mean=0.5, std=0.25)
train_transforms = transforms.Compose([
transforms.Resize((96,112)),# W x H
transforms.RandomFlipLeftRight(),
transforms.ToTensor(),
normalize,
])
def my_train_transform(img, label):
return train_transforms(img), label
train_dataset = datasets.ImageFolderDataset(path, transform=my_train_transform)
num_train = len(train_dataset)
print("number of total examples is %d" % num_train)
train_loader = data.DataLoader(
train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
print("number of batches for train, valid and test is %d"%(len(train_loader)))
return train_loader
def test(args):
# output folder
outdir = 'outdir'
if not os.path.exists(outdir):
os.makedirs(outdir)
# image transform
input_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
# dataset and dataloader
testset = get_segmentation_dataset(args.dataset,
split='test',
transform=input_transform)
test_data = gluon.data.DataLoader(testset,
args.test_batch_size,
last_batch='keep',
batchify_fn=test_batchify_fn,
num_workers=args.workers)
# create network
model = get_segmentation_model(model=args.model,
dataset=args.dataset,
backbone=args.backbone,
norm_layer=args.norm_layer)
print(model)
evaluator = MultiEvalModel(model, testset.num_class, ctx_list=args.ctx)
# load pretrained weight
assert (args.resume is not None)
if os.path.isfile(args.resume):
model.load_params(args.resume, ctx=args.ctx)
else:
raise RuntimeError("=> no checkpoint found at '{}'" \
.format(args.resume))
tbar = tqdm(test_data)
for i, (data, im_paths) in enumerate(tbar):
predicts = evaluator.parallel_forward(data)
for predict, impath in zip(predicts, im_paths):
predict = mx.nd.squeeze(mx.nd.argmax(predict, 1)).asnumpy()
mask = get_color_pallete(predict, args.dataset)
outname = os.path.splitext(impath)[0] + '.png'
mask.save(os.path.join(outdir, outname))
def get_val_data(rec_val, batch_size, data_nthreads, input_size, crop_ratio):
def val_batch_fn(batch, ctx):
data = batch[0].as_in_context(ctx)
label = batch[1].as_in_context(ctx)
return data, label
normalize = transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
crop_ratio = crop_ratio if crop_ratio > 0 else 0.875
resize = int(math.ceil(input_size / crop_ratio))
from gluoncv.utils.transforms import EfficientNetCenterCrop
from autogluon.utils import pil_transforms
if input_size >= 320:
transform_test = transforms.Compose([
pil_transforms.ToPIL(),
EfficientNetCenterCrop(input_size),
pil_transforms.Resize((input_size, input_size),
interpolation=Image.BICUBIC),
pil_transforms.ToNDArray(),
transforms.ToTensor(), normalize
])
else:
transform_test = transforms.Compose([
transforms.Resize(resize, keep_ratio=True),
transforms.CenterCrop(input_size),
transforms.ToTensor(), normalize
])
val_set = mx.gluon.data.vision.ImageRecordDataset(rec_val).transform_first(
transform_test)
val_sampler = SplitSampler(len(val_set),
num_parts=num_workers,
part_index=rank)
val_data = gluon.data.DataLoader(val_set,
batch_size=batch_size,
num_workers=data_nthreads,
sampler=val_sampler)
return val_data, val_batch_fn
def __init__(self,
modelname='deeplab_resnet152_voc',
palletename='pascal_voc'):
self.ctx = mx.gpu(0)
self.model = gluoncv.model_zoo.get_model(modelname,
pretrained=True,
root='.mxnet/models',
ctx=self.ctx)
self.transform_fn = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225])
])
if '_voc' in modelname:
self.palletename = 'pascal_voc'
elif '_ade' in modelname:
self.palletename = 'ade20k'
else:
print("invalid model name")
exit(0)
def _preprocessBeforeConversionToNumpy(self, image):
if isinstance(image, PIL.Image.Image):
image = np.array(image).astype(np.float32)
if len(image.shape) > 2:
image = image[:, :, 0:3]
else:
image = np.stack((image, ) * 3, axis=-1)
arr = mx.nd.array(image)
transform_fn = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
])
arr = transform_fn(arr)
arr = arr.expand_dims(axis=0)
return arr.asnumpy()
else:
raise IOError("Image Type not supported for preprocessing.")
def get_data_iters(batch_size):
train_set = [(name.split()[0], int(name.split()[1]))
for name in open(opt.train_data).readlines()]
val_set = [(name.split()[0], int(name.split()[1]))
for name in open(opt.val_data).readlines()]
normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform_train = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height),
interpolation=1),
transforms.RandomFlipLeftRight(),
transforms.ToTensor(), normalizer
])
transform_test = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height),
interpolation=1),
transforms.ToTensor(), normalizer
])
train_imgs = ImageTxtDataset(opt.data_dir,
train_set,
transform=transform_train)
val_imgs = ImageTxtDataset(opt.data_dir, val_set, transform=transform_test)
train_data = gluon.data.DataLoader(train_imgs,
batch_size,
sampler=RandomIdentitySampler(
train_set, 4),
last_batch='discard',
num_workers=opt.num_workers)
val_data = gluon.data.DataLoader(val_imgs,
batch_size,
sampler=RandomIdentitySampler(
val_imgs, 4),
last_batch='discard',
num_workers=opt.num_workers)
return train_data, val_data
def _evaluate(self, val_data, metric_name=None):
"""Test on validation dataset."""
if not isinstance(val_data, (gluon.data.DataLoader, mx.io.MXDataIter)):
if hasattr(val_data, 'to_mxnet'):
val_data = val_data.to_mxnet()
resize = int(math.ceil(self.input_size / self._cfg.train.crop_ratio))
normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
transform_test = transforms.Compose([
transforms.Resize(resize, keep_ratio=True),
transforms.CenterCrop(self.input_size),
transforms.ToTensor(),
normalize
])
val_data = gluon.data.DataLoader(
val_data.transform_first(transform_test),
batch_size=self._cfg.valid.batch_size, shuffle=False, last_batch='keep',
num_workers=self._cfg.valid.num_workers)
if metric_name == 'rmse':
rmse_metric = mx.metric.RMSE()
for _, batch in enumerate(val_data):
data, label = self.batch_fn(batch, self.ctx)
outputs = [self.net(X.astype(self._cfg.train.dtype, copy=False)) for X in data]
rmse_metric.update(label, outputs)
_, val_score = rmse_metric.get()
return val_score
else: # accuracy by default
acc_top1 = mx.metric.Accuracy()
acc_top5 = mx.metric.TopKAccuracy(min(5, self.num_class))
for _, batch in enumerate(val_data):
data, label = self.batch_fn(batch, self.ctx)
outputs = [self.net(X.astype(self._cfg.train.dtype, copy=False)) for X in data]
acc_top1.update(label, outputs)
acc_top5.update(label, outputs)
_, top1 = acc_top1.get()
_, top5 = acc_top5.get()
return top1, top5
def create_loader(self,
train_data,
test_data,
batch_size=4,
transformer=None):
if transformer:
train_data, test_data = self.transform(train_data, test_data,
transformer)
workers = multiprocessing.cpu_count()
train_data = gluon.data.DataLoader(train_data,
batch_size=batch_size,
shuffle=True,
num_workers=workers)
test_data = gluon.data.DataLoader(test_data,
batch_size=batch_size,
shuffle=True,
num_workers=workers)
else:
transformer = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(0.13, 0.31)])
train_data, test_data = self.transform(train_data, test_data,
transformer)
workers = multiprocessing.cpu_count()
train_data = gluon.data.DataLoader(train_data,
batch_size=batch_size,
shuffle=True,
num_workers=workers)
test_data = gluon.data.DataLoader(test_data,
batch_size=batch_size,
shuffle=True,
num_workers=workers)
return train_data, test_data
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 preprocess_img_imagenet(img_path):
"""Preprocessing required for ImageNet classification.
Reference:
https://github.com/onnx/models/tree/master/vision/classification/vgg
"""
import mxnet
from mxnet.gluon.data.vision import transforms
from PIL import Image
img = Image.open(img_path)
img = mxnet.ndarray.array(img)
transform_fn = transforms.Compose([
transforms.Resize(224),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
img = transform_fn(img)
img = img.expand_dims(axis=0) # Batchify.
return img.asnumpy()
def get_val_data_source(dataset_name, dataset_dir, batch_size, num_workers):
mean_rgb = (0.4914, 0.4822, 0.4465)
std_rgb = (0.2023, 0.1994, 0.2010)
transform_val = transforms.Compose([
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=False).transform_first(fn=transform_val),
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
def get_mnist_data(batch=128):
"""
Should construct a dataloader with the MNIST Dataset with the necessary transforms applied.
:param batch: batch size for the DataLoader.
:type batch: int
:return: a tuple of the training and validation DataLoaders
:rtype: (gluon.data.DataLoader, gluon.data.DataLoader)
"""
# YOUR CODE HERE
#raise NotImplementedError()
t = gluon.data.vision.datasets.MNIST(train=True, root=M5_IMAGES)
v = gluon.data.vision.datasets.MNIST(train=False, root=M5_IMAGES)
transformer = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(0.13, 0.31)
])
mnist_train = t.transform_first(transformer)
mnist_validation = v.transform_first(transformer)
train_dataloader = gluon.data.DataLoader(
mnist_train,
batch_size=batch,
shuffle=True,
num_workers=4
)
validation_dataloader = gluon.data.DataLoader(
mnist_validation,
batch_size=batch,
shuffle=False,
num_workers=4
)
return train_dataloader, validation_dataloader
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 get_data_iters(batch_size):
train_set, val_set = LabelList(ratio=opt.ratio,
root=opt.dataset_root,
name=opt.dataset)
normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform_train = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height),
interpolation=1),
transforms.RandomFlipLeftRight(),
RandomCrop(size=(opt.img_width, opt.img_height), pad=opt.pad),
transforms.ToTensor(), normalizer
])
train_imgs = ImageTxtDataset(train_set, transform=transform_train)
train_data = gluon.data.DataLoader(train_imgs,
batch_size,
shuffle=True,
last_batch='discard',
num_workers=opt.num_workers)
if opt.ratio < 1:
transform_test = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height),
interpolation=1),
transforms.ToTensor(), normalizer
])
val_imgs = ImageTxtDataset(val_set, transform=transform_test)
val_data = gluon.data.DataLoader(val_imgs,
batch_size,
shuffle=True,
last_batch='discard',
num_workers=opt.num_workers)
else:
val_data = None
return train_data, val_data
