def __init__(self, batch_size, num_threads, device_id): super(HybridPipe, self).__init__(batch_size, num_threads, device_id, seed = 12) self.input = ops.CaffeReader(path = caffe_db_folder, random_shuffle = True) self.decode = ops.nvJPEGDecoder(device = "mixed", output_type = types.RGB) self.cmnp = ops.CropMirrorNormalize(device = "gpu", output_dtype = types.FLOAT, output_layout = types.NHWC, crop = (224, 224), image_type = types.RGB, mean = [128., 128., 128.], std = [1., 1., 1.]) self.affine = ops.WarpAffine(device = "gpu", matrix = [1.0, 0.8, 0.0, 0.0, 1.2, 0.0], fill_value = 128, interp_type = types.INTERP_LINEAR, use_image_center = True) self.uniform = ops.Uniform(range = (0.0,1.0)) self.iter = 0
def __init__(self, batch_size, num_threads, device_id, num_gpus, db_dir): super(TrainPipe, self).__init__(batch_size, num_threads, device_id) self.input = ops.MXNetReader(path=[db_dir + "train.rec"], index_path=[db_dir + "train.idx"], random_shuffle=False, shard_id=device_id, num_shards=num_gpus) self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) # self.blur = ops.GaussianBlur(device="cpu", sigma=5.0, window_size=5) # self.reshape = ops.Reshape(device="cpu", layout="HWC") self.normalize = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, mean=[123.0, 116.0, 103.0], std=[100.0, 100.0, 100.0]) self.transform_source = ops.ExternalSource() self.warp_gpu = ops.WarpAffine(device="gpu", interp_type=types.INTERP_LINEAR)
def __new__(cls, fill_value=0, interp_type='linear', **kwargs): """Create a ``WarpAffine`` operator. Parameters ---------- fill_value : number, optional The value to fill the empty regions. interp_type : str, optional, default='linear' The interpolation method. Returns ------ nvidia.dali.ops.WarpAffine The operator. """ if isinstance(interp_type, six.string_types): interp_type = getattr(types, 'INTERP_' + interp_type.upper()) return ops.WarpAffine(fill_value=fill_value, interp_type=interp_type, device=context.get_device_type(), **kwargs)
def __init__(self, cfg, root_dir, batch_size, num_threads, device_id=0, is_train=True): super(TripletPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) self.input_target_images = ops.ExternalSource() self.input_target_labels = ops.ExternalSource() self.input_pos_images = ops.ExternalSource() self.input_pos_labels = ops.ExternalSource() self.input_neg_images = ops.ExternalSource() self.input_neg_labels = ops.ExternalSource() self.dataset = CustomTripletIterator(batch_size, root_dir, cfg.random_shuffle) self.iterator = iter(self.dataset) self.is_train = is_train self.decode = ops.ImageDecoder(device='mixed', output_type=types.BGR) self.resize_op = ops.Resize(device='gpu', resize_longer=cfg.input_size) self.paste_ratio = ops.Uniform(range=(11, 15)) self.paste = ops.Paste(device="gpu", fill_value=(255, 255, 255)) # self.crop = ops.Crop(device ='gpu', crop=[224, 224]) output_dtype = types.FLOAT16 if cfg.fp16_using else types.FLOAT # output_dtype = types.FLOAT self.normalize = ops.CropMirrorNormalize( device="gpu", crop=(cfg.input_size, cfg.input_size), mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255], mirror=0, output_dtype=output_dtype, output_layout=types.NCHW, pad_output=False) self.rot_rand = (-30., 30.) self.cont_rand = (0.5, 1.5) self.bri_rand = (0.5, 1.5) self.sat_rand = (0.5, 1.5) self.hue_rand = (45., 55.) self.augmentations = {} self.augmentations["jitter"] = ops.Jitter(device="gpu") self.augmentations["water"] = ops.Water(device="gpu") # self.augmentations["shpere"] = ops.Sphere(device = "gpu") self.augmentations["warpaffine"] = ops.WarpAffine( device="gpu", matrix=[1.0, 0.8, 0.0, 0.0, 1.2, 0.0], use_image_center=True, interp_type=types.INTERP_LINEAR) # self.augmentations["paste"] = ops.Paste(device = "gpu", ratio = 2., fill_value = (55, 155, 155), # paste_x = .5, paste_y = .4) # self.augmentations["resize"] = ops.Resize(device = "gpu", resize_shorter = 480) self.augmentations["flip_v"] = ops.Flip(device="gpu", vertical=1, horizontal=0) self.augmentations["flip_h"] = ops.Flip(device="gpu", vertical=0, horizontal=1) # self.uniform = ops.Uniform(range = (0.0, 1.0)) self.aug_num_rad = (1, 3) self.aug_prop = 100
def __init__(self, batch_size, device_id, file_root, annotations_file, num_gpus, output_fp16=False, output_nhwc=False, pad_output=False, num_threads=1, seed=15): super(COCOPipeline, self).__init__(batch_size=batch_size, device_id=device_id, num_threads=num_threads, seed=seed) if torch.distributed.is_initialized(): shard_id = torch.distributed.get_rank() else: shard_id = 0 self.input = ops.COCOReader(file_root=file_root, annotations_file=annotations_file, shard_id=shard_id, num_shards=num_gpus, ratio=True, ltrb=True, random_shuffle=True, skip_empty=True) self.decode = ops.ImageDecoder(device="cpu", output_type=types.RGB) # Augumentation techniques self.rotate = ops.Rotate(device="gpu", angle=30, interp_type=types.INTERP_LINEAR, fill_value=0) self.crop = ops.SSDRandomCrop(device="cpu", num_attempts=1) self.twist = ops.ColorTwist(device="gpu") self.resize = ops.Resize(device="gpu", resize_x=300, resize_y=300) # Will flip with probability provided in CoinFlip self.flip = ops.Flip(device='gpu') self.coin_flip_v = ops.CoinFlip(probability=0.1) self.coin_flip_h = ops.CoinFlip(probability=0.1) # bbox flipping self.bbflip = ops.BbFlip(device='gpu', ltrb=True) # paste self.paste = ops.Paste(device='gpu', fill_value=0) self.paste_pos = ops.Uniform(range=(0, 1)) self.paste_ratio = ops.Uniform(range=(1, 2)) self.bbpaste = ops.BBoxPaste(device='cpu', ltrb=True) # prospective self.prospective_crop = ops.RandomBBoxCrop( device='cpu', aspect_ratio=[0.5, 2.0], thresholds=[0.1, 0.3, 0.5], scaling=[0.8, 1.0], ltrb=True ) # slice (after prospective crop) self.slice = ops.Slice(device='gpu') # color self.water = ops.Water(device='gpu') # self.contrast = ops.BrightnessContrast(device="gpu", brightness=0.5, contrast=1.5) # self.hsv = ops.Hsv(device="gpu", hue=45., saturation=0.2) self.sphere = ops.Sphere(device='gpu') self.warpaffine = ops.WarpAffine(device="gpu", matrix=[1.0, 0.8, 0.0, 0.0, 1.2, 0.0], interp_type=types.INTERP_LINEAR) output_dtype = types.FLOAT16 if output_fp16 else types.FLOAT output_layout = types.NHWC if output_nhwc else types.NCHW self.normalize = ops.CropMirrorNormalize(device="gpu", crop=(300, 300), mean=[0.0, 0.0, 0.0], std=[255.0, 255.0, 255.0], mirror=0, output_dtype=output_dtype, output_layout=output_layout, pad_output=pad_output) # Random variables self.rng1 = ops.Uniform(range=[0.5, 1.5]) self.rng2 = ops.Uniform(range=[0.875, 1.125]) self.rng3 = ops.Uniform(range=[-0.5, 0.5])