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(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 validate(epoch, val_loader, model, crit_cls, crit_reg, opt, ctx, gen_shape=False): """ One validation """ generated_shapes = [] original_shapes = [] sample_prob = opt.inner_sample_prob loss_cls_sum, loss_reg_sum, n = 0.0, 0.0, 0 for idx, data in enumerate(val_loader): start = time.time() shapes, labels, masks, params, param_masks = data[0], data[1], data[ 2], data[3], data[4] gt = shapes shapes = nd.expand_dims(shapes, axis=1) shapes = shapes.as_in_context(ctx) labels = labels.as_in_context(ctx) masks = masks.as_in_context(ctx) params = params.as_in_context(ctx) param_masks = param_masks.as_in_context(ctx) with autograd.train_mode(): out = model.decode(shapes) #out = model(shapes, labels, sample_prob) bsz, n_block, n_step = labels.shape labels = labels.reshape(bsz, n_block * n_step) masks = masks.reshape(bsz, n_block * n_step) out_pgm = out[0].reshape(bsz, n_block * n_step, opt.program_size + 1) bsz, n_block, n_step, n_param = params.shape params = params.reshape(bsz, n_block * n_step, n_param) param_masks = param_masks.reshape(bsz, n_block * n_step, n_param) out_param = out[1].reshape(bsz, n_block * n_step, n_param) loss_cls, acc = crit_cls(out_pgm, labels, masks) loss_reg = crit_reg(out_param, params, param_masks) end = time.time() loss_cls = loss_cls.mean().asscalar() loss_reg = loss_reg.mean().asscalar() if idx % opt.info_interval == 0: out_1 = nd.round(out[0]).astype('int64') out_2 = nd.round(out[1]).astype('int64') pred = nd.from_numpy(decode_multiple_block( out_1, out_2)).astype("float32").as_in_context(mx.cpu()) IoU = BatchIoU(pred, gt) print( "Test: epoch {} batch {}/{}, loss_cls = {:.3f}, loss_reg = {:.3f}, acc = {:.3f}, IoU = {:.3f} time = {:.3f}" .format(epoch, idx, len(val_loader), loss_cls, loss_reg, acc[0].asscalar(), IoU.mean(), end - start)) sys.stdout.flush()
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 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(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): """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 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(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 __init__(self, width, height, net=None, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), mixup=False, deg=8, **kwargs): self._width = width self._height = height self._mean = mean self._std = std self._mixup = mixup self._target_generator = None self._deg = deg if net is None: return # in case network has reset_ctx to gpu self._fake_x = mx.nd.zeros((1, 3, height, width)) net = copy.deepcopy(net) net.collect_params().reset_ctx(None) with autograd.train_mode(): _, self._anchors, self._offsets, self._feat_maps, _, _, _, _, _, _ = net( self._fake_x) from ....model_zoo.yolo.yolo_target import YOLOV3PrefetchTargetGenerator self._target_generator = YOLOV3PrefetchTargetGenerator(num_class=len( net.classes), deg=self._deg, **kwargs)
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 = 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('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 __init__(self, k, width, height, net=None, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), mixup=False, **kwargs): self._k = k self._width = width self._height = height self._mean = mean self._std = std self._mixup = mixup self._target_generator = None if net is None: return # in case network has reset_ctx to gpu self._fake_x = (mx.nd.zeros((1, 256, int(height / 8), int(width / 8))), mx.nd.zeros( (1, 512, int(height / 16), int(width / 16))), mx.nd.zeros( (1, 1024, int(height / 32), int(width / 32)))) net = copy.deepcopy(net) net.collect_params().reset_ctx(None) with autograd.train_mode(): _, self._anchors, self._offsets, self._feat_maps, _, _, _, _ = net( *self._fake_x) # from gluoncv.model_zoo.yolo.yolo_target import YOLOV3PrefetchTargetGenerator self._target_generator = YOLOV3PrefetchTargetGenerator(num_class=len( net.classes), **kwargs)
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 __init__(self, width, height, net=None, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), mixup=False, **kwargs): self._width = width self._height = height self._mean = mean self._std = std self._mixup = mixup self._internal_target_generator = None self._net_none = False if net is None: self._net_none = True return self._num_classes = len(net.classes) self._kwargs = kwargs # in case network has reset_ctx to gpu self._fake_x = mx.nd.zeros((1, 3, height, width)) old_ctx = list(net.collect_params().values())[0].list_ctx() net.collect_params().reset_ctx(mx.cpu()) with autograd.train_mode(): _, self._anchors, self._offsets, self._feat_maps, _, _, _, _ = net( self._fake_x) net.collect_params().reset_ctx(old_ctx)
def __init__(self, width, height, net=None, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), mixup=False, **kwargs): self._width = width self._height = height self._mean = mean self._std = std self._mixup = mixup self._target_generator = None if net is None: return # in case network has reset_ctx to gpu # 准备fake数据用于生成anchor # TO_DO:是否同样帮助了模型的延后初始化 self._fake_x = mx.nd.zeros((1, 3, height, width)) net = copy.deepcopy(net) net.collect_params().reset_ctx(None) with autograd.train_mode(): # 设置为train_mode,获取anchor等其他需要的信息 # 得到信息: # _anchors: 列表中装着每个层的3个anchor的大小 # _offsets: 每个cell的左上角坐标值 # _feat_maps:用于获得各层的特征图大小 _, self._anchors, self._offsets, self._feat_maps, _, _, _, _ = net(self._fake_x) from ....model_zoo.yolo.yolo_target import YOLOV3PrefetchTargetGenerator self._target_generator = YOLOV3PrefetchTargetGenerator( num_class=len(net.classes), **kwargs)
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 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 validate(epoch, val_loader, generator, opt, ctx, gen_shape=False): """ evaluate program generator, in terms of IoU """ generated_shapes = [] original_shapes = [] for idx, data in enumerate(val_loader): start = time.time() shapes = data.as_in_context(ctx) shapes = nd.expand_dims(shapes, axis=1) with autograd.train_mode(): out = generator.decode(shapes) end = time.time() if gen_shape: out_1 = nd.round(out[0]).astype('int64') out_2 = nd.round(out[1]).astype('int64') generated_shapes.append( decode_multiple_block(out_1, out_2).astype("float32")) original_shapes.append(data.asnumpy()) if idx % opt.info_interval == 0: print("Test: epoch {} batch {}/{}, time={:.3f}".format( epoch, idx, len(val_loader), end - start)) if gen_shape: generated_shapes = np.concatenate(generated_shapes, axis=0) original_shapes = np.concatenate(original_shapes, axis=0) return generated_shapes, original_shapes
def test_graph_conv(idtype, out_dim): g = dgl.from_networkx(nx.path_graph(3)) g = g.astype(idtype).to(F.ctx()) ctx = F.ctx() adj = g.adjacency_matrix(transpose=True, ctx=ctx) conv = nn.GraphConv(5, out_dim, norm='none', bias=True) conv.initialize(ctx=ctx) # test#1: basic h0 = F.ones((3, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 check_close(h1, _AXWb(adj, h0, conv.weight, conv.bias)) # test#2: more-dim h0 = F.ones((3, 5, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 check_close(h1, _AXWb(adj, h0, conv.weight, conv.bias)) conv = nn.GraphConv(5, out_dim) conv.initialize(ctx=ctx) # test#3: basic h0 = F.ones((3, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 # test#4: basic h0 = F.ones((3, 5, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 conv = nn.GraphConv(5, out_dim) conv.initialize(ctx=ctx) with autograd.train_mode(): # test#3: basic h0 = F.ones((3, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 # test#4: basic h0 = F.ones((3, 5, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 # test not override features g.ndata["h"] = 2 * F.ones((3, 1)) h1 = conv(g, h0) assert len(g.ndata) == 1 assert len(g.edata) == 0 assert "h" in g.ndata check_close(g.ndata['h'], 2 * F.ones((3, 1)))
def get_anchors(net): if net is None: return None for v in net.collect_params().values(): ctx = v.data().context break x = nd.zeros(shape=(1, 3, height, width)).as_in_context(ctx) with autograd.train_mode(): cls_preds, box_preds, anchors = net(x) return anchors
def test_graph_conv(): g = dgl.DGLGraph(nx.path_graph(3)) ctx = F.ctx() adj = g.adjacency_matrix(ctx=ctx) conv = nn.GraphConv(5, 2, norm=False, bias=True) conv.initialize(ctx=ctx) # test#1: basic h0 = F.ones((3, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 check_close(h1, _AXWb(adj, h0, conv.weight, conv.bias)) # test#2: more-dim h0 = F.ones((3, 5, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 check_close(h1, _AXWb(adj, h0, conv.weight, conv.bias)) conv = nn.GraphConv(5, 2) conv.initialize(ctx=ctx) # test#3: basic h0 = F.ones((3, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 # test#4: basic h0 = F.ones((3, 5, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 conv = nn.GraphConv(5, 2) conv.initialize(ctx=ctx) with autograd.train_mode(): # test#3: basic h0 = F.ones((3, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 # test#4: basic h0 = F.ones((3, 5, 5)) h1 = conv(g, h0) assert len(g.ndata) == 0 assert len(g.edata) == 0 # test not override features g.ndata["h"] = 2 * F.ones((3, 1)) h1 = conv(g, h0) assert len(g.ndata) == 1 assert len(g.edata) == 0 assert "h" in g.ndata check_close(g.ndata['h'], 2 * F.ones((3, 1)))
def _get_dali_dataloader(net, train_dataset, val_dataset, data_shape, global_batch_size, num_workers, devices, ctx, horovod): width, height = data_shape, data_shape with autograd.train_mode(): _, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx=ctx)) anchors = anchors.as_in_context(mx.cpu()) if horovod: batch_size = global_batch_size // hvd.size() pipelines = [ SSDDALIPipeline(device_id=hvd.local_rank(), batch_size=batch_size, data_shape=data_shape, anchors=anchors, num_workers=num_workers, dataset_reader=train_dataset[0]) ] else: num_devices = len(devices) batch_size = global_batch_size // num_devices pipelines = [ SSDDALIPipeline(device_id=device_id, batch_size=batch_size, data_shape=data_shape, anchors=anchors, num_workers=num_workers, dataset_reader=train_dataset[i]) for i, device_id in enumerate(devices) ] epoch_size = train_dataset[0].size() if horovod: epoch_size //= hvd.size() train_loader = DALIGenericIterator( pipelines, [('data', DALIGenericIterator.DATA_TAG), ('bboxes', DALIGenericIterator.LABEL_TAG), ('label', DALIGenericIterator.LABEL_TAG)], epoch_size, auto_reset=True) # validation if not horovod or hvd.rank() == 0: val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1)) val_loader = gluon.data.DataLoader(val_dataset.transform( SSDDefaultValTransform(width, height)), global_batch_size, False, batchify_fn=val_batchify_fn, last_batch='keep', num_workers=num_workers) else: val_loader = None return train_loader, val_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_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 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))) train_loader = gdata.DetectionDataLoader( train_dataset.transform(SSDDefaultTrainTransform(width, height, anchors)), batch_size, True, last_batch='rollover', num_workers=num_workers) val_loader = gdata.DetectionDataLoader( val_dataset.transform(SSDDefaultValTransform(width, height)), batch_size, False, 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 # 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 hybrid_forward(self, F, x, gamma, beta): # normalization with autograd.train_mode(): y = x.expand_dims(0).reshape(0, 0, self.ngroups, -1) y = y.reshape(1, -3, -1) batch = x.shape[0] y = F.BatchNorm(y, F.ones(batch * self.ngroups, ctx=x.context), F.zeros(batch * self.ngroups, ctx=x.context), F.zeros(batch * self.ngroups, ctx=x.context), F.ones(batch * self.ngroups, ctx=x.context), name='fwd', **self._kwargs) # scale and shift y = y.reshape_like(x).reshape(0, 0, -1) y = y * gamma.reshape(1, -1, 1) + beta.reshape(1, -1, 1) return y.reshape_like(x)
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size, num_workers, args): """Get dataloader: transform and batchify.""" 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, cls_targets, box_targets batchify_fn = Tuple(Stack(), Stack(), Stack()) train_loader = gluon.data.DataLoader( train_dataset.transform( SFDTrainTransform(width, height, anchors, (args.match_high_thresh, args.match_low_thresh), args.match_topk)), batch_size, shuffle=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(SFDValTransform()), batch_size, False, batchify_fn=val_batchify_fn, last_batch='keep', num_workers=num_workers) return train_loader, val_loader
def __init__(self, width, height, net=None, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), mixup=False, **kwargs): self._width = width self._height = height self._mean = mean self._std = std self._mixup = mixup self._target_generator = None if net is None: return # in case network has reset_ctx to gpu self._fake_x = mx.nd.zeros((1, 3, height, width)) net = copy.deepcopy(net) net.collect_params().reset_ctx(None) with autograd.train_mode(): _, self._anchors, self._offsets, self._feat_maps, _, _, _, _ = net(self._fake_x) from ....model_zoo.yolo.yolo_target import YOLOV3PrefetchTargetGenerator self._target_generator = YOLOV3PrefetchTargetGenerator( num_class=len(net.classes), **kwargs)
############################################################################## # Faster-RCNN network is callable with image tensor import mxnet as mx x = mx.nd.zeros(shape=(1, 3, 600, 800)) net.initialize() cids, scores, bboxes = net(x) ############################################################################## # Faster-RCNN returns three values, where ``cids`` are the class labels, # ``scores`` are confidence scores of each prediction, # and ``bboxes`` are absolute coordinates of corresponding bounding boxes. ############################################################################## # Faster-RCNN network behave differently during training mode: from mxnet import autograd with autograd.train_mode(): # this time we need ground-truth to generate high quality roi proposals during training gt_box = mx.nd.zeros(shape=(1, 1, 4)) cls_preds, box_preds, roi, samples, matches, rpn_score, rpn_box, anchors = net(x, gt_box) ############################################################################## # In training mode, Faster-RCNN returns a lot of intermediate values, which we require to train in an end-to-end flavor, # where ``cls_preds`` are the class predictions prior to softmax, # ``box_preds`` are bounding box offsets with one-to-one correspondence to proposals # ``roi`` is the proposal candidates, ``samples`` and ``matches`` are the samling/matching results of RPN anchors. # ``rpn_score`` and ``rpn_box`` are the raw outputs from RPN's convolutional layers. # and ``anchors`` are absolute coordinates of corresponding anchors boxes. ########################################################## # Training losses