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