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_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 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 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 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 # 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 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, 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(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 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(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 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, 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, 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 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 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 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): """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 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(dataset, batch_size): width, height = FLAGS.data_shape, FLAGS.data_shape batchify_fn = Tuple(Stack(), Pad(pad_val=-1), Stack()) loader = gluon.data.DataLoader(dataset.transform( YOLO3VideoInferenceTransform(width, height)), batch_size, False, last_batch='keep', num_workers=FLAGS.num_workers, batchify_fn=batchify_fn) return loader
def get_dataloader(net, train_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) return train_loader
def get_traindataloader(net, train_dataset, data_shape, batch_size, num_workers, is_shuffle=True): 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))) #print(anchors) # mxnet ndarray, shape: 1 * 6132 * 4 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, is_shuffle, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers) return train_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(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(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, 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_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
def get_ori_evaldataloader(val_dataset, data_shape, batch_size, num_workers): width, height = data_shape, data_shape batchify_fn = Tuple(Stack(), Pad(pad_val=-1)) val_loader = gluon.data.DataLoader( val_dataset.transform(SSDOriTransform(width, height)), batchify_fn=batchify_fn, batch_size=batch_size, shuffle=False, last_batch='discard', num_workers=num_workers) return val_loader
def get_dataloader(val_dataset, data_shape, batch_size, num_workers): """Get dataloader.""" width, height = data_shape, data_shape batchify_fn = Tuple(Stack(), Pad(pad_val=-1)) val_loader = gluon.data.DataLoader( val_dataset.transform(SSDDefaultValTransform(width, height)), batchify_fn=batchify_fn, batch_size=batch_size, shuffle=False, last_batch='rollover', num_workers=num_workers) return val_loader