def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers, ctx):
"""Get dataloader."""
width, height = data_shape, data_shape
num_class = len(train_dataset.classes)
batchify_fn = Tuple([Stack() for _ in range(6)
]) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
CenterNetDefaultTrainTransform(width,
height,
num_class=num_class,
scale_factor=net.scale)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
CenterNetDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size, num_workers, args):
"""Get dataloader."""
# when it is not in final_fit stage and val_dataset is not provided, we randomly
# sample (1 - args.split_ratio) data as our val_dataset
if (not args.final_fit) and (not val_dataset):
train_dataset, val_dataset = _train_val_split(train_dataset, args.split_ratio)
width, height = data_shape, data_shape
batchify_fn = Tuple(*([Stack() for _ in range(6)] + [Pad(axis=0, pad_val=-1) for _ in range(
1)])) # stack image, all targets generated
if args.no_random_shape:
train_loader = gluon.data.DataLoader(
train_dataset.transform(
YOLO3DefaultTrainTransform(width, height, net, mixup=args.mixup)),
batch_size, True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=num_workers)
else:
transform_fns = [YOLO3DefaultTrainTransform(x * 32, x * 32, net, mixup=args.mixup) for x in
range(10, 20)]
train_loader = RandomTransformDataLoader(
transform_fns, train_dataset, batch_size=batch_size, interval=10, last_batch='rollover',
shuffle=True, batchify_fn=batchify_fn, num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = None
if val_dataset:
val_loader = gluon.data.DataLoader(
val_dataset.transform(YOLO3DefaultValTransform(width, height)),
batch_size, False, batchify_fn=val_batchify_fn, last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, 512, 512)))
batchify_fn_train = Tuple(Stack(), Stack(), Stack())
train_loader = gluon.data.DataLoader(train_dataset.transform(
TrainTransform(width, height, anchors)),
batch_size,
shuffle=True,
batchify_fn=batchify_fn_train,
last_batch='rollover',
num_workers=num_workers)
batchify_fn = Tuple(Stack(), Stack())
val_loader = gluon.data.DataLoader(val_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
shuffle=False,
batchify_fn=batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def Model(self, model_name, use_pretrained=True, use_gpu=True, gpu_devices=[0]):
self.system_dict["model_name"] = model_name;
self.system_dict["use_pretrained"] = use_pretrained;
if(self.system_dict["model_name"] in self.system_dict["model_set_1"]):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"]);
self.system_dict["local"]["net"].reset_class(self.system_dict["classes"])
self.system_dict["img_shape"] = (300, 300);
width, height = self.system_dict["img_shape"][0], self.system_dict["img_shape"][1]
with autograd.train_mode():
_, _, anchors = self.system_dict["local"]["net"](mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(SSDDefaultTrainTransform(width, height, anchors)),
self.system_dict["batch_size"], True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu ,gpu_devices=gpu_devices);
self.system_dict["local"]["net"].collect_params().reset_ctx(self.system_dict["local"]["ctx"])
elif((self.system_dict["model_name"] in self.system_dict["model_set_2"]) or (self.system_dict["model_name"] in self.system_dict["model_set_3"])
or (self.system_dict["model_name"] in self.system_dict["model_set_4"])):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"]);
self.system_dict["local"]["net"].reset_class(self.system_dict["classes"])
self.system_dict["img_shape"] = (512, 512);
width, height = self.system_dict["img_shape"][0], self.system_dict["img_shape"][1]
with autograd.train_mode():
_, _, anchors = self.system_dict["local"]["net"](mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(SSDDefaultTrainTransform(width, height, anchors)),
self.system_dict["batch_size"], True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices);
self.system_dict["local"]["net"].collect_params().reset_ctx(self.system_dict["local"]["ctx"])
elif((self.system_dict["model_name"] in self.system_dict["model_set_5"]) or (self.system_dict["model_name"] in self.system_dict["model_set_6"])) :
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"]);
self.system_dict["local"]["net"].reset_class(self.system_dict["classes"])
self.system_dict["img_shape"] = (416, 416);
width, height = self.system_dict["img_shape"][0], self.system_dict["img_shape"][1]
train_transform = YOLO3DefaultTrainTransform(width, height, self.system_dict["local"]["net"])
batchify_fn = Tuple(*([Stack() for _ in range(6)] + [Pad(axis=0, pad_val=-1) for _ in range(1)]))
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(train_transform),
self.system_dict["batch_size"], True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices);
self.system_dict["local"]["net"].collect_params().reset_ctx(self.system_dict["local"]["ctx"])
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
anchors, _, _, _, _, _, _ = net(mx.nd.zeros((1, 3, height, width)))
# stack image, anchor_cls_targets, anchor_box_targets
# pad real_targets(xmin, ymin, xmax, ymax, label). will return length
batchify_fn = Tuple(Stack(), Stack(), Stack(),
Pad(axis=0, pad_val=-1, ret_length=True))
train_loader = gluon.data.DataLoader(train_dataset.transform(
RefineDetDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
# return: img (B, H, W, C); anchor_cls_targets (B, N); anchor_box_targets(B, N, 4);
# targets(B, P, 5), target_len (B, ). m_i is the num of objects in each img, P is the length after pad.
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def test_transforms_presets_center_net():
im_fname = gcv.utils.download('https://github.com/dmlc/web-data/blob/master/' +
'gluoncv/detection/biking.jpg?raw=true', path='biking.jpg')
x, orig_img = center_net.load_test(im_fname, short=512)
x1, orig_img1 = center_net.transform_test(mx.image.imread(im_fname), short=512)
np.testing.assert_allclose(x.asnumpy(), x1.asnumpy())
np.testing.assert_allclose(orig_img, orig_img1)
if not osp.isdir(osp.expanduser('~/.mxnet/datasets/voc')):
return
train_dataset = VOCDetectionTiny()
val_dataset = VOCDetectionTiny(splits=[('tiny_motorbike', 'test')])
width, height = (512, 512)
net = gcv.model_zoo.get_model('center_net_resnet18_v1b_voc', pretrained=False, pretrained_base=False)
net.initialize()
num_workers = 0
batch_size = 4
batchify_fn = Tuple([Stack() for _ in range(6)])
train_loader = gluon.data.DataLoader(
train_dataset.transform(center_net.CenterNetDefaultTrainTransform(width, height, num_class=len(train_dataset.classes), scale_factor=net.scale)),
batch_size, True, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(center_net.CenterNetDefaultValTransform(width, height)),
batch_size, False, batchify_fn=val_batchify_fn, last_batch='keep', num_workers=num_workers)
for loader in [train_loader, val_loader]:
for i, batch in enumerate(loader):
if i > 1:
break
pass
def getDataloader(self, train_dataset, val_dataset):
width, height = self.args.data_shape, self.args.data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
foo, bar, anchors = self.net(
mx.nd.zeros((1, 3, height, width), self.ctx[0]))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
self.args.batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=self.args.num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = None
if val_dataset is not None:
val_loader = gluon.data.DataLoader(
val_dataset.transform(SSDDefaultValTransform(width, height)),
self.args.batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=self.args.num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, valid_dataset, data_shape, batch_size,
num_workers):
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(valid_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
eval_metric = VOC07MApMetric(iou_thresh=0.5, class_names=classes)
return train_loader, val_loader, eval_metric
def test_transforms_presets_ssd():
im_fname = gcv.utils.download('https://github.com/dmlc/web-data/blob/master/' +
'gluoncv/detection/biking.jpg?raw=true', path='biking.jpg')
x, orig_img = ssd.load_test(im_fname, short=512)
x1, orig_img1 = ssd.transform_test(mx.image.imread(im_fname), short=512)
np.testing.assert_allclose(x.asnumpy(), x1.asnumpy())
np.testing.assert_allclose(orig_img, orig_img1)
if not osp.isdir(osp.expanduser('~/.mxnet/datasets/voc')):
return
train_dataset = VOCDetectionTiny()
val_dataset = VOCDetectionTiny(splits=[('tiny_motorbike', 'test')])
width, height = (512, 512)
net = gcv.model_zoo.get_model('ssd_512_resnet50_v1_voc', pretrained=False, pretrained_base=False)
net.initialize()
num_workers = 0
batch_size = 4
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(
train_dataset.transform(ssd.SSDDefaultTrainTransform(width, height, anchors)),
batch_size, True, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(ssd.SSDDefaultValTransform(width, height)),
batch_size, False, batchify_fn=val_batchify_fn, last_batch='keep', num_workers=num_workers)
train_loader2 = gluon.data.DataLoader(
train_dataset.transform(ssd.SSDDefaultTrainTransform(width, height)),
batch_size, True, batchify_fn=val_batchify_fn, last_batch='rollover', num_workers=num_workers)
for loader in [train_loader, val_loader, train_loader2]:
for i, batch in enumerate(loader):
if i > 1:
break
pass
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size, num_workers, args):
"""Get dataloader: transform and batchify."""
height, width = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, face_anchors, \
_, _, head_anchors, \
_, _, body_anchors = net(mx.nd.zeros((1, 3, height, width)))
anchors = [face_anchors, head_anchors, body_anchors]
# stack image,cls_target box_target
train_batchify_fn = Tuple(Stack(), # source img
Stack(), Stack(), Stack(), # face_cls_targets,head_cls_targets,body_cls_targets
Stack(), Stack(), Stack()) # face_box_targets,head_box_targets,body_cls_targets
# train_batchify_fn = Tuple(Stack(), # source img
# Pad(), Pad(), Pad(), # face_cls_targets,head_cls_targets,body_cls_targets
# Pad(), Pad(), Pad()) # face_box_targets,head_box_targets,body_cls_targets
# getdataloader
train_loader = gluon.data.DataLoader(train_dataset.transform(
PyramidBoxTrainTransform(width, height, anchors)),
batch_size=batch_size, shuffle=True,
batchify_fn=train_batchify_fn, num_workers=num_workers, last_batch='rollover')
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(PyramidBoxValTransform()),
batch_size=batch_size, shuffle=False, batchify_fn=val_batchify_fn, last_batch='keep', num_workers=num_workers)
return train_loader, val_loader
def _get_dataloader(net, test_dataset, data_shape, batch_size,
num_workers, num_devices, args):
"""Get dataloader."""
if args.meta_arch == 'yolo3':
width, height = data_shape, data_shape
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
test_loader = gluon.data.DataLoader(
test_dataset.transform(
YOLO3DefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return test_loader
elif args.meta_arch == 'faster_rcnn':
"""Get faster rcnn dataloader."""
test_bfn = Tuple(*[Append() for _ in range(3)])
short = net.short[-1] if isinstance(net.short,
(tuple,
list)) else net.short
# validation use 1 sample per device
test_loader = gluon.data.DataLoader(
test_dataset.transform(
FasterRCNNDefaultValTransform(short, net.max_size)),
num_devices,
False,
batchify_fn=test_bfn,
last_batch='keep',
num_workers=args.num_workers)
return test_loader
else:
raise NotImplementedError('%s not implemented.' %
args.meta_arch)
def get_coco_data_loaders(net, train_data, val_data, in_size, bs, n_workers,
ctx):
with autograd.train_mode():
fake_in_size = 1
channels = 3
_, _, anchors = net(
nd.zeros((fake_in_size, channels, in_size, in_size), ctx))
anchors = anchors.as_in_context(mx.cpu())
img_train_s = Stack()
class_targets = Stack()
box_targets = Stack()
train_batchify_fn = Tuple(img_train_s, class_targets, box_targets)
train_data_transformed = train_data.transform(
SSDDefaultTrainTransform(in_size, in_size, anchors))
train_data_loader = gluon.data.DataLoader(train_data_transformed,
batch_size=bs,
shuffle=True,
batchify_fn=train_batchify_fn,
last_batch='rollover',
num_workers=n_workers)
img_val_s = Stack()
padding = Pad(pad_val=-1)
val_batchify_fn = Tuple(img_val_s, padding)
val_data_transformed = val_data.transform(
SSDDefaultValTransform(in_size, in_size))
val_data_loader = gluon.data.DataLoader(val_data_transformed,
batch_size=bs,
shuffle=False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=n_workers)
return train_data_loader, val_data_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
batchify_fn = Tuple(
*([Stack() for _ in range(6)] +
[Pad(axis=0, pad_val=-1)
for _ in range(1)])) # stack image, all targets generated
transform_fns = [
YOLO3DefaultTrainTransform(x * 32, x * 32, net) for x in range(10, 20)
]
train_loader = RandomTransformDataLoader(transform_fns,
train_dataset,
batch_size=batch_size,
interval=10,
last_batch='rollover',
shuffle=True,
batchify_fn=batchify_fn,
num_workers=num_workers)
# train_loader = gluon.data.DataLoader(
# train_dataset.transform(YOLO3DefaultTrainTransform(width, height, net)),
# batch_size, True, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
YOLO3DefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def tri_data_loader(batch_size, transform_train, transform_valid, num_workers=0,
train_dataset=None, valid_dataset=None, valid_train_dataset=None,
batchify_fns=None, train_shuffle=True):
"""
batchify_fns: dict(), like in ssd
"""
if batchify_fns is None:
batchify_fns = {'train': Tuple(Stack(), Stack(), Stack()),
'valid': Tuple(Stack(), Pad(pad_val=-1)),
'valid_train': Tuple(Stack(), Pad(pad_val=-1))}
# 1. valid_data
valid_data = DataLoader(valid_dataset.transform(transform_valid), batch_size,
shuffle=False, batchify_fn=batchify_fns['valid'], last_batch='keep',
num_workers=num_workers)
# 2. train_data
train_data = DataLoader(train_dataset.transform(transform_train), batch_size,
shuffle=train_shuffle, batchify_fn=batchify_fns['train'], last_batch='rollover',
num_workers=num_workers)
# 3. valid_train_data
if valid_train_dataset is None:
return train_data, valid_data, train_dataset.classes
else:
valid_train_data = DataLoader(valid_train_dataset.transform(transform_valid), batch_size,
shuffle=False, batchify_fn=batchify_fns['valid_train'], last_batch='keep',
num_workers=num_workers)
return train_data, valid_data, train_dataset.classes, valid_train_data
def get_dataloader(net, train_dataset, validation_dataset, image_h, image_w,
batch_size, num_workers):
"""
Get dataloader.
"""
batchify_fn = Tuple(
*([Stack() for _ in range(6)] +
[Pad(axis=0, pad_val=-1)
for _ in range(1)])) # stack image, all targets generated
train_loader = gluon.data.DataLoader(train_dataset.transform(
YOLO3DefaultTrainTransform(image_w, image_h, net)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers,
prefetch=num_workers +
num_workers // 2)
val_transform = YOLO3DefaultValTransform(image_w, image_h)
batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
validation_dataset.transform(val_transform),
batch_size,
False,
batchify_fn=batchify_fn,
last_batch='keep',
num_workers=num_workers,
prefetch=num_workers + num_workers // 2)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers, args):
import os
os.system('pip3 install gluoncv')
import gluoncv as gcv
gcv.utils.check_version('0.6.0')
from gluoncv import data as gdata
from gluoncv import utils as gutils
from gluoncv.model_zoo import get_model
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.yolo import YOLO3DefaultTrainTransform
from gluoncv.data.transforms.presets.yolo import YOLO3DefaultValTransform
from gluoncv.data.dataloader import RandomTransformDataLoader
from gluoncv.utils.metrics.voc_detection import VOC07MApMetric
from gluoncv.utils.metrics.coco_detection import COCODetectionMetric
from gluoncv.utils import LRScheduler, LRSequential
"""Get dataloader."""
width, height = data_shape, data_shape
batchify_fn = Tuple(
*([Stack() for _ in range(6)] +
[Pad(axis=0, pad_val=-1)
for _ in range(1)])) # stack image, all targets generated
if args.no_random_shape:
print(len(train_dataset))
img, label = train_dataset[0]
print(img.shape, label.shape)
train_loader = gluon.data.DataLoader(train_dataset.transform(
YOLO3DefaultTrainTransform(width, height, net, mixup=args.mixup)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
else:
transform_fns = [
YOLO3DefaultTrainTransform(x * 32, x * 32, net, mixup=args.mixup)
for x in range(10, 20)
]
train_loader = RandomTransformDataLoader(transform_fns,
train_dataset,
batch_size=batch_size,
interval=10,
last_batch='rollover',
shuffle=True,
batchify_fn=batchify_fn,
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
YOLO3DefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers, ctx):
"""Loads data from a dataset and returns mini-batches of data, for both the training
and the validation set.
Arguments:
net: the Gluon model you will train, used to generate fake anchors for target generation.
train_dataset: Training dataset. Note that numpy and mxnet arrays can be directly used as a Dataset.
val_dataset: Validation dataset. Note that numpy and mxnet arrays can be directly used as a Dataset.
data_shape: Tuple, the input_shape of the model
batch_size: Size of mini-batch.
num_workers: The number of multiprocessing workers to use for data preprocessing.
ctx: Indicator to the usage of GPU.
Returns:
train_loader: Gluon training dataloader
val_loader: Gluon testing dataloader
Raises:
"""
width, height = data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(
train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch="rollover",
num_workers=num_workers,
)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch="keep",
num_workers=num_workers,
)
return train_loader, val_loader
def test_transforms_presets_yolo():
im_fname = gcv.utils.download(
'https://github.com/dmlc/web-data/blob/master/' +
'gluoncv/detection/biking.jpg?raw=true',
path='biking.jpg')
x, orig_img = yolo.load_test(im_fname, short=512)
x1, orig_img1 = yolo.transform_test(mx.image.imread(im_fname), short=512)
np.testing.assert_allclose(x.asnumpy(), x1.asnumpy())
np.testing.assert_allclose(orig_img, orig_img1)
if not osp.isdir(osp.expanduser('~/.mxnet/datasets/voc')):
return
train_dataset = gcv.data.VOCDetection(splits=((2007, 'trainval'),
(2012, 'trainval')))
val_dataset = gcv.data.VOCDetection(splits=[(2007, 'test')])
width, height = (512, 512)
net = gcv.model_zoo.get_model('yolo3_darknet53_voc',
pretrained=False,
pretrained_base=False)
net.initialize()
num_workers = 0
batch_size = 4
batchify_fn = Tuple(*([Stack() for _ in range(6)] +
[Pad(axis=0, pad_val=-1) for _ in range(1)]))
train_loader = gluon.data.DataLoader(train_dataset.transform(
yolo.YOLO3DefaultTrainTransform(width, height, net)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
yolo.YOLO3DefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
train_loader2 = gluon.data.DataLoader(train_dataset.transform(
yolo.YOLO3DefaultTrainTransform(width, height)),
batch_size,
True,
batchify_fn=val_batchify_fn,
last_batch='rollover',
num_workers=num_workers)
for loader in [train_loader, val_loader, train_loader2]:
for i, batch in enumerate(loader):
if i > 1:
break
pass
def get_dataloader(model, train_dataset, validation_dataset, height, width,
batch_size, num_workers):
"""
Get dataloader.
"""
import gluoncv as gcv
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
#In training mode, SSD returns three intermediate values
#cls_preds are the class predictions prior to softmax
#box_preds are bounding box offsets with one-to-one correspondence to anchors
with autograd.train_mode():
_, _, anchors = model(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
# SSDDefaultTrainTransform: data augmentation and prepprocessing
# random color jittering, random expansion with prob 0.5, random cropping
# resize with random interpolation, random horizontal flip,
# normalize (substract mean and divide by std)
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(height, width, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_dataloader(self, net, train_dataset, val_dataset, width, height, batch_size, num_workers):
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.yolo import YOLO3DefaultTrainTransform, YOLO3DefaultValTransform
# use fake data to generate fixed anchors for target generation
train_batchify_fn = Tuple(*([Stack() for _ in range(6)] + [Pad(axis=0, pad_val=-1) for _ in range(1)])) # stack image, all targets generated
train_loader = gluon.data.DataLoader(
train_dataset.transform(YOLO3DefaultTrainTransform(width, height, net)),
batch_size, True, batchify_fn=train_batchify_fn, last_batch='rollover', num_workers=num_workers)
val__batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(YOLO3DefaultValTransform(width, height)),
batch_size, True, batchify_fn=val__batchify_fn, last_batch='rollover', num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, data_shape, batch_size, num_workers, ctx):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
# can I point that to a bundle of png files instead?
train_dataset = gdata.RecordFileDetection(
os.path.join(os.environ['SM_CHANNEL_TRAIN'], 'train.rec'))
# this is the folder with all the training images
train_folder = os.environ['SM_CHANNEL_TRAIN']
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_dataloader(model, train_dataset, validation_dataset, height, width,
batch_size, num_workers):
"""Data pre-processing. Returns mini batches of dataset with transformations
Args:
model (SSD model): Object detection model
train_dataset (Dataset): Training images and labels
validation_dataset (Dataset): Validation images and labels
height (int): Height of the training image
width (int): Width of training image
batch_size (int): Number of images in a mini batch
num_workers (int): Number of multiprocessing workers
Returns:
Dataloader : Mini batches of data
"""
with autograd.train_mode():
_, _, anchors = model(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(height, width, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_faster_rcnn_dataloader(net, train_dataset, val_dataset, train_transform, val_transform,
batch_size, num_shards, args):
"""Get faster rcnn dataloader."""
if (not args.final_fit) and (not val_dataset):
train_dataset, val_dataset = _train_val_split(train_dataset, args.split_ratio)
train_bfn = FasterRCNNTrainBatchify(net, num_shards)
if hasattr(train_dataset, 'get_im_aspect_ratio'):
im_aspect_ratio = train_dataset.get_im_aspect_ratio()
else:
im_aspect_ratio = [1.] * len(train_dataset)
train_sampler = \
gcv.nn.sampler.SplitSortedBucketSampler(im_aspect_ratio, batch_size, num_parts=1,
part_index=0, shuffle=True)
train_loader = gluon.data.DataLoader(train_dataset.transform(
train_transform(net.short, net.max_size, net, ashape=net.ashape, multi_stage=True)),
batch_sampler=train_sampler, batchify_fn=train_bfn, num_workers=args.num_workers)
val_bfn = Tuple(*[Append() for _ in range(3)])
short = net.short[-1] if isinstance(net.short, (tuple, list)) else net.short
# validation use 1 sample per device
val_loader = None
if val_dataset:
val_loader = gluon.data.DataLoader(
val_dataset.transform(val_transform(short, net.max_size)), num_shards, False,
batchify_fn=val_bfn, last_batch='keep', num_workers=args.num_workers)
args.num_samples = len(train_dataset)
return train_loader, val_loader
def ssd_train_dataloader(net,
train_dataset,
data_shape=512,
batch_size=10,
num_workers=0):
'''
returns the train loader from gluoncv
'''
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
new_SSDDefaultTrainTransform = SSDDefaultTrainTransform(
width, height, anchors)
new_SSDDefaultTrainTransform.__call__ = new_trainloader_call
train_loader = gluon.data.DataLoader(
train_dataset.transform(new_SSDDefaultTrainTransform),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch="rollover",
num_workers=num_workers,
)
return train_loader
def test_load():
from opts import opts
opt = opts().init()
batch_size = 16
# inp, hm, wh, reg, dep, dim, rotbin, rotres, ind, reg_mask, rot_mask, meta
batchify_fn = Tuple(Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack())
num_workers = 2
train_dataset = CenterMultiPoseDataset(opt, split = 'train')
train_loader = gluon.data.DataLoader( train_dataset,
batch_size, True, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
ctx = [mx.gpu(int(i)) for i in opt.gpus_str.split(',') if i.strip()]
ctx = ctx if ctx else [mx.cpu()]
'''
inp, ind, \
hm, wh, reg, reg_mask, \ # 2d detection: center, wh, offset
kps, kps_mask, \ # 2d pose: joint locations relative to center
hm_hp, hp_offset, hp_ind, hp_mask # 2d pose: joint heapmaps (and offset to compoensate discretization)
'''
for i, batch in enumerate(train_loader):
print("{} Batch".format(i))
print("image batch shape: ", batch[0].shape)
print("indices batch shape", batch[1].shape)
print("center batch shape", batch[2].shape)
print("2d wh batch shape", batch[3].shape)
print("2d offset batch shape", batch[4].shape)
print("2d offset mask batch shape", batch[5].shape)
print("pose relative to center batch shape", batch[6].shape)
print("pose relative to center mask batch shape", batch[7].shape)
print("pose heatmap batch shape", batch[8].shape)
print("pose heatmap offset batch shape", batch[9].shape)
print("pose heatmap ind shape", batch[10].shape)
print("pose heatmap mask batch shape", batch[11].shape)
X = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0)
targets_inds = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0)
targets_center = gluon.utils.split_and_load(batch[2], ctx_list=ctx, batch_axis=0) # heatmaps: (batch, num_classes, H/S, W/S)
targets_2d_wh = gluon.utils.split_and_load(batch[3], ctx_list=ctx, batch_axis=0) # scale: wh (batch, 2, H/S, W/S)
targets_2d_offset = gluon.utils.split_and_load(batch[4], ctx_list=ctx, batch_axis=0) # offset: xy (batch, 2, H/s, W/S)
targets_2d_wh_mask = gluon.utils.split_and_load(batch[5], ctx_list=ctx, batch_axis=0)
targets_poserel = gluon.utils.split_and_load(batch[6], ctx_list=ctx, batch_axis=0)
targets_poserel_mask = gluon.utils.split_and_load(batch[7], ctx_list=ctx, batch_axis=0)
targets_posemap = gluon.utils.split_and_load(batch[8], ctx_list=ctx, batch_axis=0)
targets_posemap_offset = gluon.utils.split_and_load(batch[9], ctx_list=ctx, batch_axis=0)
targets_posemap_ind = gluon.utils.split_and_load(batch[10], ctx_list=ctx, batch_axis=0)
targets_posemap_mask = gluon.utils.split_and_load(batch[11], ctx_list=ctx, batch_axis=0)
print("len(targets_center): ", len(targets_center))
print("First item: image shape: ", X[0].shape)
print("First item: center heatmap shape: ", targets_center[0].shape)
return
def get_dataloader(net, data_shape, batch_size, num_workers, ctx):
"""Get dataloader."""
import os
os.system('pip3 install gluoncv --pre')
from gluoncv import data as gdata
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_dataset = gdata.RecordFileDetection(
os.path.join(os.environ['SM_CHANNEL_TRAIN'], 'train.rec'))
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_dataloader(net, train_dataset, val_dataset, train_transform,
val_transform, batch_size, num_shards, args):
"""Get dataloader."""
train_bfn = FasterRCNNTrainBatchify(net, num_shards)
#train_sampler = gcv.nn.sampler.SplitSampler(train_dataset.get_im_aspect_ratio(),
# batch_size,
# num_parts=hvd.size() if args.horovod else 1,
# part_index=hvd.rank() if args.horovod else 0,
# shuffle=True)
train_sampler = gcv.nn.sampler.SplitSampler(
batch_size,
num_parts=hvd.size() if args.horovod else 1,
part_index=hvd.rank() if args.horovod else 0)
train_loader = mx.gluon.data.DataLoader(train_dataset.transform(
train_transform(net.short,
net.max_size,
net,
ashape=net.ashape,
multi_stage=args.use_fpn)),
batch_sampler=train_sampler,
batchify_fn=train_bfn,
num_workers=args.num_workers)
val_bfn = Tuple(*[Append() for _ in range(3)])
short = net.short[-1] if isinstance(net.short,
(tuple, list)) else net.short
# validation use 1 sample per device
val_loader = mx.gluon.data.DataLoader(val_dataset.transform(
val_transform(short, net.max_size)),
num_shards,
False,
batchify_fn=val_bfn,
last_batch='keep',
num_workers=args.num_workers)
return train_loader, val_loader
def get_dataloader(train_dataset, data_shape, batch_size, num_workers, ctx):
"""Get dataloader."""
width, height = data_shape, data_shape
batchify_fn = Tuple(Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack(), Stack())
train_loader = gluon.data.DataLoader(train_dataset, batch_size, True, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
return train_loader
def get_dataloader(net, val_dataset, data_shape, batch_size, num_workers, args):
"""Get dataloader."""
width, height = data_shape, data_shape
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(YOLO3DefaultValTransform(width, height, 50, 'coco')),
batch_size, False, batchify_fn=val_batchify_fn, last_batch='keep', num_workers=num_workers)
return val_loader
