def __init__(self, batch_size, num_threads, path, training, annotations, world, device_id, mean, std, resize, max_size, stride): super().__init__(batch_size=batch_size, num_threads=num_threads, device_id = device_id, prefetch_queue_depth=num_threads, seed=42) self.path = path self.training = training self.stride = stride self.iter = 0 self.reader = ops.COCOReader(annotations_file=annotations, file_root=path, num_shards=world,shard_id=torch.cuda.current_device(), ltrb=True, ratio=True, shuffle_after_epoch=True, save_img_ids=True) self.decode_train = ops.ImageDecoderSlice(device="mixed", output_type=types.RGB) self.decode_infer = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.bbox_crop = ops.RandomBBoxCrop(device='cpu', ltrb=True, scaling=[0.3, 1.0], thresholds=[0.1,0.3,0.5,0.7,0.9]) self.bbox_flip = ops.BbFlip(device='cpu', ltrb=True) self.img_flip = ops.Flip(device='gpu') self.coin_flip = ops.CoinFlip(probability=0.5) if isinstance(resize, list): resize = max(resize) self.rand_resize = ops.Uniform(range=[resize, float(max_size)]) self.resize_train = ops.Resize(device='gpu', interp_type=types.DALIInterpType.INTERP_CUBIC, save_attrs=True) self.resize_infer = ops.Resize(device='gpu', interp_type=types.DALIInterpType.INTERP_CUBIC, resize_longer=max_size, save_attrs=True) padded_size = max_size + ((self.stride - max_size % self.stride) % self.stride) self.pad = ops.Paste(device='gpu', fill_value = 0, ratio=1.1, min_canvas_size=padded_size, paste_x=0, paste_y=0) self.normalize = ops.CropMirrorNormalize(device='gpu', mean=mean, std=std, crop=padded_size, crop_pos_x=0, crop_pos_y=0)
def __init__(self, split, args=None): #batch_size, num_threads, data_dir, crop, shuffle=False, device_id=0, size=256, dali_cpu=False): self.split = split self.bs = args.batch_size if self.split == 'train' else args.val_batch_size self.shuffle = self.split == 'train' self.data_dir = os.path.join(args.root, split) self.crop = args.input_size super(HybridPipe, self).__init__(self.bs, args.workers, 0, seed=12) self.input = ops.FileReader(file_root=self.data_dir, shard_id=0, num_shards=1, random_shuffle=self.shuffle) dali_device = "gpu" if split == 'train': self.decode = ops.ImageDecoderRandomCrop(device="mixed", output_type=types.RGB, device_memory_padding=211025920, host_memory_padding=140544512, random_aspect_ratio=[0.75, 1.333], random_area=[0.08, 1.0], num_attempts=100) #self.res = ops.Resize(device=dali_device, resize_x=args.input_size, resize_y=args.input_size, interp_type=types.INTERP_TRIANGULAR) self.res = ops.Resize(device=dali_device, resize_shorter=args.input_size, interp_type=types.INTERP_TRIANGULAR) else: self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device=dali_device, resize_shorter=256, interp_type=types.INTERP_TRIANGULAR) self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(self.crop, self.crop), image_type=types.RGB, mean=[0.485 * 255,0.456 * 255,0.406 * 255], std=[0.229 * 255,0.224 * 255,0.225 * 255]) self.coin = ops.CoinFlip(probability=0.5)
def __init__(self, batch_size, num_threads, device_id, data_dir, crop_size, resize_size, full_sized=False, square=False): self.eii = ExternalInputIterator(data_dir, batch_size, train=False, full=full_sized) self.eii_iterator = iter(self.eii) super(CaffeValPipe, self).__init__(batch_size, num_threads, device_id) self.input = ops.ExternalSource() self.input_label = ops.ExternalSource() self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.full_sized = full_sized resize_not_needed = (not square) and (not full_sized) self.resize_needed = not resize_not_needed if self.resize_needed: print(f"Resize will happen for VAL dataset, full_sized={full_sized}, square={square}") if square: self.res = ops.Resize(device='gpu', resize_x=resize_size, resize_y=resize_size, interp_type=types.INTERP_TRIANGULAR) else: self.res = ops.Resize(device='gpu', resize_shorter=resize_size, interp_type=types.INTERP_TRIANGULAR) else: print(f"No resize will happen for VAL dataset, full_sized={full_sized}, square={square}") self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop_size, crop_size), image_type=types.RGB, mean=[0.485 * 255,0.456 * 255,0.406 * 255], std=[0.229 * 255,0.224 * 255,0.225 * 255])
def __init__(self, data_paths, num_shards, batch_size, num_threads, device_id, prefetch, fp16, random_shuffle, nhwc, dont_use_mmap, decoder_type, decoder_cache_params, reader_queue_depth, shard_id): super(CommonPipeline, self).__init__(batch_size, num_threads, device_id, random_shuffle, prefetch_queue_depth=prefetch) if decoder_type == 'roi': print('Using nvJPEG with ROI decoding') self.decode_gpu = ops.ImageDecoderRandomCrop(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_x=224, resize_y=224) elif decoder_type == 'roi_split': print('Using nvJPEG with ROI decoding and split CPU/GPU stages') self.decode_gpu = ops.ImageDecoderRandomCrop(device="mixed", output_type=types.RGB, split_stages=True) self.res = ops.Resize(device="gpu", resize_x=224, resize_y=224) elif decoder_type == 'cached': assert decoder_cache_params['cache_enabled'] == True cache_size = decoder_cache_params['cache_size'] cache_threshold = decoder_cache_params['cache_threshold'] cache_type = decoder_cache_params['cache_type'] print( 'Using nvJPEG with cache (size : {} threshold: {}, type: {})'. format(cache_size, cache_threshold, cache_type)) self.decode_gpu = ops.ImageDecoder(device="mixed", output_type=types.RGB, cache_size=cache_size, cache_threshold=cache_threshold, cache_type=cache_type, cache_debug=False) self.res = ops.RandomResizedCrop(device="gpu", size=(224, 224)) elif decoder_type == 'split': print('Using nvJPEG with split CPU/GPU stages') self.decode_gpu = ops.ImageDecoder(device="mixed", output_type=types.RGB, split_stages=True) self.res = ops.RandomResizedCrop(device="gpu", size=(224, 224)) else: print('Using nvJPEG') self.decode_gpu = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.RandomResizedCrop(device="gpu", size=(224, 224)) layout = types.NHWC if nhwc else types.NCHW out_type = types.FLOAT16 if fp16 else types.FLOAT self.cmnp = ops.CropMirrorNormalize( device="gpu", dtype=out_type, output_layout=layout, crop=(224, 224), mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255]) self.coin = ops.random.CoinFlip(probability=0.5)
def __init__(self, batch_size, num_threads, path, training, annotations, world, device_id, mean, std, resize, max_size, stride, rotate_augment=False, augment_brightness=0.0, augment_contrast=0.0, augment_hue=0.0, augment_saturation=0.0): super().__init__(batch_size=batch_size, num_threads=num_threads, device_id=device_id, prefetch_queue_depth=num_threads, seed=42) self.path = path self.training = training self.stride = stride self.iter = 0 self.rotate_augment = rotate_augment self.augment_brightness = augment_brightness self.augment_contrast = augment_contrast self.augment_hue = augment_hue self.augment_saturation = augment_saturation self.reader = ops.COCOReader(annotations_file=annotations, file_root=path, num_shards=world, shard_id=torch.cuda.current_device(), ltrb=True, ratio=True, shuffle_after_epoch=True, save_img_ids=True) self.decode_train = ops.ImageDecoderSlice(device="mixed", output_type=types.RGB) self.decode_infer = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.bbox_crop = ops.RandomBBoxCrop(device='cpu', ltrb=True, scaling=[0.3, 1.0], thresholds=[0.1, 0.3, 0.5, 0.7, 0.9]) self.bbox_flip = ops.BbFlip(device='cpu', ltrb=True) self.img_flip = ops.Flip(device='gpu') self.coin_flip = ops.CoinFlip(probability=0.5) self.bc = ops.BrightnessContrast(device='gpu') self.hsv = ops.Hsv(device='gpu') # Random number generation for augmentation self.brightness_dist = ops.NormalDistribution(mean=1.0, stddev=augment_brightness) self.contrast_dist = ops.NormalDistribution(mean=1.0, stddev=augment_contrast) self.hue_dist = ops.NormalDistribution(mean=0.0, stddev=augment_hue) self.saturation_dist = ops.NormalDistribution(mean=1.0, stddev=augment_saturation) if rotate_augment: raise RuntimeWarning("--augment-rotate current has no effect when using the DALI data loader.") if isinstance(resize, list): resize = max(resize) self.rand_resize = ops.Uniform(range=[resize, float(max_size)]) self.resize_train = ops.Resize(device='gpu', interp_type=types.DALIInterpType.INTERP_CUBIC, save_attrs=True) self.resize_infer = ops.Resize(device='gpu', interp_type=types.DALIInterpType.INTERP_CUBIC, resize_longer=max_size, save_attrs=True) padded_size = max_size + ((self.stride - max_size % self.stride) % self.stride) self.pad = ops.Paste(device='gpu', fill_value=0, ratio=1.1, min_canvas_size=padded_size, paste_x=0, paste_y=0) self.normalize = ops.CropMirrorNormalize(device='gpu', mean=mean, std=std, crop=(padded_size, padded_size), crop_pos_x=0, crop_pos_y=0)
def __init__(self, batch_size, num_threads, device_id, csv_path, data_path, valid=False, nfold=0): super(DALIPipeline, self).__init__(batch_size, num_threads, device_id) self.data_path = data_path self.csv_file = csv_path self.valid = valid self.data = pd.read_csv(self.csv_file) if nfold > 0: self.data = self.data.sort_values(by=['image', 'label']) self.data = self.data.sample(frac=1, random_state=0).reset_index(drop=True) len_fold = int(len(self.data) / nfold) if valid: self.data = self.data[len_fold * (nfold - 1):].reset_index(drop=True) else: self.data = self.data[:len_fold * (nfold - 1)].reset_index(drop=True) self.data.to_csv('data/dali.txt', header=False, index=False, sep=' ') self.input = ops.FileReader(file_root=data_path, file_list='data/dali.txt') self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.random_resize = ops.Resize(device="gpu", image_type=types.RGB, interp_type=types.INTERP_LINEAR) self.resize = ops.Resize(device="gpu", image_type=types.RGB, interp_type=types.INTERP_LINEAR, resize_x=227., resize_y=227.) self.cmn = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT, crop=(227, 227), image_type=types.RGB, mean=[128., 128., 128.], std=[1., 1., 1.]) self.normalize = ops.NormalizePermute(device="gpu", height=227, width=227, image_type=types.RGB, mean=[128., 128., 128.], std=[1., 1., 1.]) self.uniform = ops.Uniform(range=(0.0, 1.0)) self.resize_rng = ops.Uniform(range=(256, 480))
def __init__(self, device_id, shard_id, num_shards, size, crop, options): super(ValPipeline, self).__init__(options.batchsize, options.dataloader_workers, device_id, seed=12 + device_id) self.input = ops.FileReader(file_root=options.val_dir, shard_id=shard_id, num_shards=num_shards, random_shuffle=False, pad_last_batch=True) self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_shorter=size, interp_type=types.INTERP_TRIANGULAR) dtype = types.FLOAT16 if options.fp16 else types.FLOAT layout = types.NCHW img_mean, img_std = get_mean_std(options) self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=dtype, output_layout=layout, crop=(crop, crop), image_type=types.RGB, mean=img_mean, std=img_std, pad_output=False)
def build_train_and_test_transforms(): """Returns torchvision OR nvidia-dali transforms. :returns: train_transforms, test_transforms :rtype: list, list """ resize_shape = (args.image_size_override, args.image_size_override) if 'dali' in args.task: # Lazy import DALI dependencies because debug cpu nodes might not have DALI. import nvidia.dali.ops as ops import nvidia.dali.types as types from datasets.dali_imagefolder import ColorJitter, RandomHorizontalFlip, RandomGrayScale train_transform = [ ops.RandomResizedCrop(device="gpu" if args.cuda else "cpu", size=resize_shape, random_area=(0.08, 1.0), random_aspect_ratio=(3. / 4, 4. / 3)), RandomHorizontalFlip(prob=0.2, cuda=args.cuda), ColorJitter(brightness=0.8 * args.color_jitter_strength, contrast=0.8 * args.color_jitter_strength, saturation=0.2 * args.color_jitter_strength, hue=0.2 * args.color_jitter_strength, prob=0.8, cuda=args.cuda), RandomGrayScale(prob=0.2, cuda=args.cuda) # TODO: Gaussian-blur ] test_transform = [ ops.Resize(resize_x=resize_shape[0], resize_y=resize_shape[1], device="gpu" if args.cuda else "cpu", image_type=types.RGB, interp_type=types.INTERP_LINEAR) ] else: from datasets.utils import GaussianBlur train_transform = [ # transforms.CenterCrop(first_center_crop_size), transforms.RandomResizedCrop( (args.image_size_override, args.image_size_override)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply([ transforms.ColorJitter( brightness=0.8 * args.color_jitter_strength, contrast=0.8 * args.color_jitter_strength, saturation=0.8 * args.color_jitter_strength, hue=0.2 * args.color_jitter_strength) ], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int(0.1 * args.image_size_override), p=0.5) ] test_transform = [transforms.Resize(resize_shape)] return train_transform, test_transform
def __init__(self, batch_size, num_threads, device_id = 0, seed = 0): super(TestPipeline, self).__init__(batch_size, num_threads, device_id, seed) self.input = ops.COCOReader( file_root = file_root, annotations_file = annotations_file, shard_id = 0, num_shards = 1, ratio=False, save_img_ids=True) self.decode = ops.ImageDecoder(device = "cpu", output_type = types.RGB) self.resize = ops.Resize( device = "cpu", image_type = types.RGB, interp_type = types.INTERP_LINEAR) self.cmn = ops.CropMirrorNormalize( device = "cpu", output_dtype = types.FLOAT, crop = (224, 224), image_type = types.RGB, mean = [128., 128., 128.], std = [1., 1., 1.]) self.res_uniform = ops.Uniform(range = (256.,480.)) self.uniform = ops.Uniform(range = (0.0, 1.0)) self.cast = ops.Cast( device = "cpu", dtype = types.FLOAT16)
def __init__(self, batch_size, num_threads, device_id, data_dir, crop, size, dali_cpu=False): super(DALIValPipe, self).__init__( batch_size, num_threads, device_id, seed=12 + device_id ) self.input = ops.FileReader( file_root=data_dir, shard_id=device_id, num_shards=1, random_shuffle=True ) #let user decide which pipeline works him bets for RN version he runs if dali_cpu: dali_device = "cpu" self.decode = ops.HostDecoder( device=dali_device, output_type=types.RGB) else: dali_device = "gpu" # This padding sets the size of the internal nvJPEG buffers to be # able to handle all images from full-sized ImageNet # without additional reallocations self.decode = ops.nvJPEGDecoder( device="mixed", output_type=types.RGB, device_memory_padding=211025920, host_memory_padding=140544512 ) self.res = ops.Resize( device=dali_device, resize_shorter=size) self.cmnp = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop, crop), image_type=types.RGB, mean=[0.485 * 255,0.456 * 255,0.406 * 255], std=[0.229 * 255,0.224 * 255,0.225 * 255]) print('DALI "{0}" variant'.format(dali_device))
def __init__(self, batch_size, num_threads, device_id, data_dir, crop, size): super(HybridValPipe, self).__init__(batch_size, num_threads, device_id, seed=12 + device_id) if torch.distributed.is_initialized(): local_rank = torch.distributed.get_rank() world_size = torch.distributed.get_world_size() else: local_rank = 0 world_size = 1 self.input = ops.FileReader(file_root=data_dir, shard_id=local_rank, num_shards=world_size, random_shuffle=False) self.decode = ops.nvJPEGDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_shorter=size) self.cmnp = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop, crop), image_type=types.RGB, mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255])
class HybridPipe(Pipeline): def __init__(self, batch_size, num_threads, device_id, pipelined=True, async=True): super(HybridPipe, self).__init__(batch_size, num_threads, device_id, exec_pipelined=pipelined, exec_async=async) self.input = ops.ExternalSource() self.decode = ops.nvJPEGDecoder(device="mixed", output_type=types.RGB) self.resize = ops.Resize(device="gpu", image_type=types.RGB, interp_type=types.INTERP_LINEAR) self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT16, crop=(224, 224), image_type=types.RGB, mean=[128., 128., 128.], std=[1., 1., 1.]) self.uniform = ops.Uniform(range=(0., 1.)) self.resize_uniform = ops.Uniform(range=(256., 480.)) self.mirror = ops.CoinFlip(probability=0.5) self.iter = 0
def __init__(self, batch_size, num_threads, device_id, data_dir, crop, dali_cpu=False): super(HybridTrainPipe, self).__init__(batch_size, num_threads, device_id, seed=12 + device_id) self.input = ops.FileReader(file_root=data_dir, shard_id=args.local_rank, num_shards=args.world_size, random_shuffle=True) #let user decide which pipeline works him bets for RN version he runs dali_device = 'cpu' if dali_cpu else 'gpu' decoder_device = 'cpu' if dali_cpu else 'mixed' # This padding sets the size of the internal nvJPEG buffers to be able to handle all images from full-sized ImageNet # without additional reallocations device_memory_padding = 211025920 if decoder_device == 'mixed' else 0 host_memory_padding = 140544512 if decoder_device == 'mixed' else 0 self.decode = ops.ImageDecoderRandomCrop(device=decoder_device, output_type=types.RGB, device_memory_padding=device_memory_padding, host_memory_padding=host_memory_padding, random_aspect_ratio=[0.8, 1.25], random_area=[0.1, 1.0], num_attempts=100) self.res = ops.Resize(device=dali_device, resize_x=crop, resize_y=crop, interp_type=types.INTERP_TRIANGULAR) self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop, crop), image_type=types.RGB, mean=[0.485 * 255,0.456 * 255,0.406 * 255], std=[0.229 * 255,0.224 * 255,0.225 * 255]) self.coin = ops.CoinFlip(probability=0.5)
def __init__(self, batch_size, num_threads, device, device_id=0, shard_id=0, num_shards=1, seed=0): super(TestPipeline, self).__init__(batch_size, num_threads, device_id, seed) self.device = device self.input = ops.COCOReader(file_root=file_root, annotations_file=annotations_file, shard_id=shard_id, num_shards=num_shards, ratio=False, save_img_ids=True) self.decode = ops.ImageDecoder( device='mixed' if device is 'gpu' else 'cpu', output_type=types.RGB) self.resize = ops.Resize(device=device, image_type=types.RGB, resize_x=224, resize_y=224, interp_type=types.INTERP_LINEAR) self.cmn = ops.CropMirrorNormalize(device=device, output_dtype=types.FLOAT, image_type=types.RGB, mean=[128., 128., 128.], std=[1., 1., 1.]) self.cast = ops.Cast(device=device, dtype=types.INT16)
def __init__(self, params, device_id, files, labels): super().__init__(params.batch_size, params.num_gpus * 8, device_id, seed=params.seed) # file_root有坑,并不是文件夹名字就是label,按照文件夹顺序(1, 10, 11, 2, 20, 21, ...)分别给与0,1,2,3,4...标签 self.input = ops.FileReader(files=files, labels=labels, random_shuffle=True) self.decocer = ops.ImageDecoder(device='mixed', output_type=types.RGB) self.resize = ops.Resize(device='gpu', resize_shorter=224) self.pos_rng_x = ops.random.Uniform(range=(0.0, 1.0)) self.pos_rng_y = ops.random.Uniform(range=(0.0, 1.0)) self.crop = ops.Crop(device='gpu', crop_h=224, crop_w=224) self.flip = ops.Flip(device='gpu') self.coinflip = ops.random.CoinFlip(probability=0.5) self.hsv = ops.Hsv(device='gpu') self.saturation = ops.random.Uniform(range=(0.8, 1.0)) self.value = ops.random.Uniform(range=(0.8, 1.0)) mean = torch.Tensor(params.mean).unsqueeze(0).unsqueeze(0) * 255 std = torch.Tensor(params.std).unsqueeze(0).unsqueeze(0) * 255 self.normalize = ops.Normalize(axes=[0, 1], mean=mean, stddev=std, device='gpu', batch=False) self.transpose = ops.Transpose(device='gpu', perm=[2, 0, 1])
def __init__(self, batch_size, num_threads, device_id, data_dir="./", dali_cpu=False): super(DecodeCropResizePipeline, self).__init__(batch_size, num_threads, device_id, seed=12) self.input = ops.FileReader(file_root=data_dir, random_shuffle=True) if dali_cpu: decoder_device = "cpu" else: decoder_device = "mixed" device_memory_padding = 211025920 if decoder_device == 'mixed' else 0 host_memory_padding = 140544512 if decoder_device == 'mixed' else 0 dali_device = "cpu" if dali_cpu else "gpu" self.decode = ops.ImageDecoderRandomCrop( device=decoder_device, output_type=types.RGB, device_memory_padding=device_memory_padding, host_memory_padding=host_memory_padding, random_aspect_ratio=[0.8, 1.25], random_area=[0.1, 1.0], num_attempts=100) self.res = ops.Resize(device=dali_device, resize_x=224, resize_y=224, interp_type=types.INTERP_TRIANGULAR)
def __init__(self, device, batch_size, num_threads=1, device_id=0): super(MultichannelPipeline, self).__init__(batch_size, num_threads, device_id) self.device = device self.reader = ops.FileReader(file_root=multichannel_tiff_root) decoder_device = 'mixed' if self.device == 'gpu' else 'cpu' self.decoder = ops.ImageDecoder(device=decoder_device, output_type=types.ANY_DATA) self.resize = ops.Resize(device=self.device, resize_y=900, resize_x=300, min_filter=types.DALIInterpType.INTERP_LINEAR) self.crop = ops.Crop(device=self.device, crop_h=220, crop_w=224, crop_pos_x=0.3, crop_pos_y=0.2, image_type=types.ANY_DATA) self.transpose = ops.Transpose(device=self.device, perm=(1, 0, 2), transpose_layout=False) self.cmn = ops.CropMirrorNormalize(device=self.device, std=255., mean=0., output_layout="HWC", output_dtype=types.FLOAT)
def __init__(self, device, batch_size, layout, iterator, num_threads=1, device_id=0, tested_operator = None): super(MultichannelSynthPipeline, self).__init__(batch_size, num_threads, device_id) self.device = device self.layout = layout self.iterator = iterator self.inputs = ops.ExternalSource() self.tested_operator = tested_operator if self.tested_operator == 'resize' or not self.tested_operator: self.resize = ops.Resize(device = self.device, resize_y = 900, resize_x = 300, min_filter=types.DALIInterpType.INTERP_LINEAR) if self.tested_operator == 'crop' or not self.tested_operator: self.crop = ops.Crop(device = self.device, crop = (220, 224), crop_pos_x = 0.3, crop_pos_y = 0.2) if self.tested_operator == 'transpose' or not self.tested_operator: self.transpose = ops.Transpose(device = self.device, perm = (1, 0, 2), transpose_layout = False) if self.tested_operator == 'normalize' or not self.tested_operator: self.cmn = ops.CropMirrorNormalize(device = self.device, std = 255., mean = 0., output_layout = "HWC", dtype = types.FLOAT)
def __init__(self, batch_size: int, num_threads: int, device_id: int, sequence_length: int, initial_prefetch_size: int, data: List, shuffle: bool): """ :param batch_size: size of dataset batch :param num_threads: number of parallel threads :param device_id: "gpu" or "cpu" :param sequence_length: number of frames :param initial_prefetch_size: count of videos readed preliminarily :param data: input video paths :param shuffle: suffle samples """ super().__init__(batch_size, num_threads, device_id, seed=16) self.input = ops.VideoReader(device="gpu", filenames=data, sequence_length=sequence_length, shard_id=0, num_shards=1, random_shuffle=shuffle, initial_fill=initial_prefetch_size) self.extract = ops.ElementExtract(device="gpu", element_map=list( range(0, FRAMES_PER_VIDEO))) self.resize = ops.Resize(device="gpu", resize_x=config.IMG_SIZE, resize_y=config.IMG_SIZE)
def __init__(self, imageset_dir, image_size=128, random_shuffle=False, batch_size=64, num_threads=2, device_id=0): super(ImagePipeline, self).__init__(batch_size, num_threads, device_id, seed=12) eii = ExternalInputIterator(imageset_dir, batch_size, random_shuffle) self.iterator = iter(eii) self.num_inputs = len(eii.frontal_indices) # The source for the inputs and targets self.input = ops.ExternalSource() self.target = ops.ExternalSource() # nvJPEGDecoder below accepts CPU inputs, but returns GPU outputs (hence device = "mixed") self.decode = ops.nvJPEGDecoder(device="mixed", output_type=types.RGB) # The rest of pre-processing is done on the GPU self.res = ops.Resize(device="gpu", resize_x=image_size, resize_y=image_size) self.norm = ops.NormalizePermute(device="gpu", output_dtype=types.FLOAT, mean=[128., 128., 128.], std=[128., 128., 128.], height=image_size, width=image_size)
def __init__(self, device, batch_size, relative, use_wildcard, num_threads=3, device_id=0, num_gpus=1): super(ReshapePipeline, self).__init__(batch_size, num_threads, device_id, seed=7865, exec_async=True, exec_pipelined=True) self.device = device self.input = ops.readers.Caffe(path=caffe_db_folder, shard_id=device_id, num_shards=num_gpus) self.decode = ops.ImageDecoder(device="cpu", output_type=types.RGB) W = 320 H = 224 self.resize = ops.Resize(device="cpu", resize_x=W, resize_y=H) WC = -1 if use_wildcard else W * 3 if relative: rel_shape = (-1, 3) if use_wildcard else (1, 3) self.reshape = ops.Reshape(device=device, rel_shape=rel_shape, layout="ab") else: self.reshape = ops.Reshape(device=device, shape=(H, WC), layout="ab")
def __init__(self, root, split, batch_size, device_id, dali_cpu=False, local_rank=0, world_size=1, num_workers=2, augment=False, resize=False, resize_size=314, crop=True, crop_size=314, shuffle=True, flip=True, rotate=False, rotate_angle=10.0): super(VOCDali, self).__init__(batch_size, num_threads=num_workers, device_id=device_id, seed=12 + device_id) self.iterator = iter(VOCIter(batch_size, split, root, shuffle)) self.split = split assert self.split in ['train', 'val'] dali_device = "gpu" if not dali_cpu else "cpu" self.input = ops.ExternalSource() self.input_label = ops.ExternalSource() self.is_flip = flip self.is_rotate = rotate self.is_augment = augment self.is_crop = crop self.is_resize = resize self.decode = ops.ImageDecoder(device='mixed', output_type=types.RGB) # self.cast = ops.Cast(device='gpu', dtype=types.INT32) self.rng = ops.Uniform(range=(0., 1.)) self.coin = ops.CoinFlip(probability=0.5) # 定义大小 self.resize = ops.Resize(device="gpu", resize_x=resize_size, resize_y=resize_size, interp_type=types.INTERP_TRIANGULAR) # 定义旋转 self.rotate = ops.Rotate(device="gpu", angle=rotate_angle) # 定义翻转 self.flip = ops.Flip(device="gpu", vertical=1, horizontal=0) # 定义剪裁 self.crop = ops.Crop(device=dali_device, crop_h=crop_size, crop_w=crop_size) # 定义正则化 self.cmnp = ops.CropMirrorNormalize( device=dali_device, output_dtype=types.FLOAT, output_layout=types.NCHW, image_type=types.RGB, mean=[0.45734706 * 255, 0.43338275 * 255, 0.40058118 * 255], std=[0.23965294 * 255, 0.23532275 * 255, 0.2398498 * 255])
def __init__(self, cfg): super(ClsTrainPipe, self).__init__(batch_size=cfg.dataset.loader.batch_size, num_threads=cfg.dataset.loader.num_workers, device_id=cfg.device.local_rank) self.eii = ClsInputIterator(cfg=cfg, is_train=True) self.source = ops.ExternalSource(source=self.eii, num_outputs=2) self.decode = ops.ImageDecoderRandomCrop( device='mixed', output_type=types.RGB, random_aspect_ratio=[0.8, 1.25], random_area=[0.3, 1.0], num_attempts=100) self.rotate = ops.Rotate(device='gpu', fill_value=127.5) self.res = ops.Resize(device='gpu', resize_x=cfg.dataset.transform.image_size, resize_y=cfg.dataset.transform.image_size, interp_type=types.INTERP_TRIANGULAR) self.cmnp = ops.CropMirrorNormalize( device='gpu', dtype=types.FLOAT, output_layout=types.NCHW, crop=(cfg.dataset.transform.image_size, cfg.dataset.transform.image_size), mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255]) self.coin = ops.CoinFlip(probability=0.5) self.angle = ops.Uniform( range=(-1 * cfg.dataset.transform.max_rotate_angle, cfg.dataset.transform.max_rotate_angle))
def __init__(self, batch_size, num_threads, shard_id, image_dir, file_list, nvjpeg_padding, seed=1, num_shards=1, channel_last=True, dtype='half', pad_output=False): super(ValPipeline, self).__init__(batch_size, num_threads, shard_id, seed=seed) self.input = ops.FileReader(file_root=image_dir, file_list=file_list, random_shuffle=False, num_shards=num_shards, shard_id=shard_id) self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB, device_memory_padding=nvjpeg_padding, host_memory_padding=nvjpeg_padding) self.res = ops.Resize(device="gpu", resize_shorter=256) self.cmnp = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT16 if dtype == "half" else types.FLOAT, output_layout=types.NHWC if channel_last else types.NCHW, crop=(224, 224), image_type=types.RGB, mean=_pixel_mean, std=_pixel_std, pad_output=pad_output)
def __init__(self, batch_size, num_threads, device_id, image_dir, file_list, seed=1, num_gpu=1): super(ValPipeline, self).__init__(batch_size, num_threads, device_id, seed=seed) self.input = ops.FileReader(file_root=image_dir, file_list=file_list, random_shuffle=False, num_shards=num_gpu, shard_id=0) self.decode = ops.nvJPEGDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_shorter=256) self.cmnp = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(224, 224), image_type=types.RGB, mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255])
def __init__(self, iterator, batch_size, num_threads, device_id): super().__init__(batch_size, num_threads, device_id, seed=12) self.iterator = iterator self.input = ops.ExternalSource() self.input_label = ops.ExternalSource() self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_x=224, resize_y=224, interp_type=types.INTERP_TRIANGULAR)
def __init__(self, batch_size, num_threads, device_id, data_dir, crop, size): super(HybridValPipe, self).__init__(batch_size, num_threads, device_id, seed=12 + device_id) # self.input = ops.FileReader(file_root=data_dir, shard_id=args.local_rank, num_shards=args.world_size, random_shuffle=False) index_path = [] for path in os.listdir("/home/guojia/idx_files/val"): index_path.append(os.path.join("/home/guojia/idx_files/val", path)) index_path = sorted(index_path) self.input = ops.TFRecordReader(path=data_dir, index_path=index_path, shard_id=args.local_rank, num_shards=args.world_size, random_shuffle=True, features={ 'image/height': tfrec.FixedLenFeature([1], tfrec.int64, -1), 'image/width': tfrec.FixedLenFeature([1], tfrec.int64, -1), 'image/colorspace': tfrec.FixedLenFeature([], tfrec.string, ''), 'image/channels': tfrec.FixedLenFeature([], tfrec.int64, -1), 'image/class/label': tfrec.FixedLenFeature([1], tfrec.int64, -1), 'image/class/synset': tfrec.FixedLenFeature([], tfrec.string, ''), 'image/format': tfrec.FixedLenFeature((), tfrec.string, ""), 'image/filename': tfrec.FixedLenFeature((), tfrec.string, ""), 'image/encoded': tfrec.FixedLenFeature((), tfrec.string, "") }) self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_shorter=size, interp_type=types.INTERP_TRIANGULAR) self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop, crop), image_type=types.RGB, mean=[0.485 * 255,0.456 * 255,0.406 * 255], std=[0.229 * 255,0.224 * 255,0.225 * 255])
def __init__(self, args, batch_size, num_threads, device_id, rec_path, idx_path, shard_id, num_shards, crop_shape, nvjpeg_padding, prefetch_queue=3, resize_shp=None, output_layout=types.NCHW, pad_output=True, dtype='float16', dali_cpu=False, nvjpeg_width_hint=5980, nvjpeg_height_hint=6430): super(HybridValPipe, self).__init__(batch_size, num_threads, device_id, seed=12 + device_id, prefetch_queue_depth=prefetch_queue) self.input = ops.MXNetReader(path=[rec_path], index_path=[idx_path], random_shuffle=False, shard_id=shard_id, num_shards=num_shards, dont_use_mmap=args.dali_dont_use_mmap) if dali_cpu: dali_device = "cpu" decoder_device = "cpu" else: dali_device = "gpu" decoder_device = "mixed" dali_kwargs_fallback = {} if Version(dali.__version__) >= Version("1.2.0"): dali_kwargs_fallback = { "preallocate_width_hint": nvjpeg_width_hint, "preallocate_height_hint": nvjpeg_height_hint } self.decode = ops.ImageDecoder(device=decoder_device, output_type=types.RGB, device_memory_padding=nvjpeg_padding, host_memory_padding=nvjpeg_padding, **dali_kwargs_fallback) self.resize = ops.Resize(device=dali_device, resize_shorter=resize_shp) if resize_shp else None self.cmnp = ops.CropMirrorNormalize(device="gpu", output_dtype=types.FLOAT16 if dtype == 'float16' else types.FLOAT, output_layout=output_layout, crop=crop_shape, pad_output=pad_output, image_type=types.RGB, mean=args.rgb_mean, std=args.rgb_std)
def __init__(self, batch_size, num_threads, device_id, data_dir, crop, size, local_rank=0, world_size=1): super(HybridValPipe, self).__init__(batch_size, num_threads, device_id, seed=12 + device_id) self.input = ops.FileReader(file_root=data_dir, shard_id=local_rank, num_shards=world_size, random_shuffle=False) self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_shorter=size, interp_type=types.INTERP_TRIANGULAR) self.cmnp = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop, crop), image_type=types.RGB, mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255])
def __init__(self, batch_size, num_threads, device_id, record_dir, crop, size, num_gpus, dali_cpu=False): super(HybridValPipe, self).__init__(batch_size, num_threads, device_id, seed=12 + device_id) self.input = ops.MXNetReader(path=[join(record_dir, "val.rec")], index_path=[join(record_dir, "val.idx")], random_shuffle=False, shard_id=device_id, num_shards=num_gpus) self.decode = ops.ImageDecoder(device="mixed", output_type=types.RGB) self.res = ops.Resize(device="gpu", resize_shorter=size, interp_type=types.INTERP_CUBIC) self.cmnp = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT, output_layout=types.NCHW, crop=(crop, crop), image_type=types.RGB, mean=[0.485 * 255, 0.456 * 255, 0.406 * 255], std=[0.229 * 255, 0.224 * 255, 0.225 * 255])