def __init__(self, batch_size, data, shuffle=False, stride=1, step=-1, device_id=0, num_shards=1, interleave_size=0, interleave_mode="shorten", dtype=types.FLOAT, sequence_length=COUNT): super(LabeledVideoPipe, self).__init__(batch_size, num_threads=2, device_id=device_id, seed=12) self.input = ops.VideoReader(device="gpu", filenames=data, sequence_length=sequence_length, interleave_size=interleave_size, interleave_mode=interleave_mode, labels=[k for k in range(len(data))], enable_frame_num=True, shard_id=0, num_shards=num_shards, random_shuffle=shuffle, normalized=True, image_type=types.YCbCr, dtype=dtype, step=step, stride=stride)
def __init__(self, batch_size, sequence_length, num_threads, device_id, files, \ crop_size, random_shuffle=True, step=-1, gray_mode=False): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) #Define VideoReader, output shape [N, F, H, W, C] (N being the batch size and F the number of frames) self.reader = ops.VideoReader(device="gpu", \ filenames=files, \ sequence_length=sequence_length, \ normalized=False, \ random_shuffle=random_shuffle, \ image_type=types.RGB, \ dtype=types.UINT8, \ step=step, \ initial_fill=16) # Define crop and permute operations to apply to every sequence self.crop = ops.CropCastPermute(device="gpu", \ crop=crop_size, \ output_layout=types.NCHW, \ output_dtype=types.FLOAT) # crop and permute (from [N,H,W,C] to [N,C,H,W]) # self.crop = ops.Crop(device="gpu", \ # crop=crop_size, \ # output_dtype=types.FLOAT) # # permute from [N,F,H,W,C] to [N,F,C,H,W] # self.permute = ops.Transpose(device="gpu", perm=[0,1,4,2,3]) self.uniform = ops.Uniform(range=(0.0, 1.0)) # used for random crop
def __init__(self, batch_size, data, shuffle=False, stride=1, step=-1, device_id=0, num_shards=1, dtype=types.FLOAT, sequence_length=COUNT): super(VideoPipe, self).__init__(batch_size, num_threads=2, device_id=device_id, seed=12) self.input = ops.VideoReader(device="gpu", filenames=data, sequence_length=sequence_length, shard_id=0, num_shards=num_shards, random_shuffle=shuffle, normalized=True, image_type=types.YCbCr, dtype=dtype, step=step, stride=stride)
def __init__(self, batch_size, data, device_id=0, sequence_length=COUNT): super(VideoPipeList, self).__init__(batch_size, num_threads=2, device_id=device_id) self.input = ops.VideoReader(device="gpu", file_list=data, sequence_length=sequence_length)
def __init__( self, batch_size: int, num_threads: int, device_id: int, file_list: Path, shuffle: bool, initial_prefetch_size: int, clip_length_in_frames: int, seed: int, ): super().__init__( batch_size=batch_size, num_threads=num_threads, device_id=device_id, seed=seed, ) self.input = ops.VideoReader( device="gpu", shard_id=0, num_shards=1, file_list=file_list, enable_frame_num=True, enable_timestamps=True, random_shuffle=shuffle, initial_fill=initial_prefetch_size, sequence_length=clip_length_in_frames, )
def __init__( self, args, file_list, batch_size=16, num_threads=1, device_id=0, shuffle=False, ): """ Args: step: The frame interval between each sequence. stride: The distance between consecutive frames in each sequence. """ shard_id = 0 num_shards = 1 super(ActivityNetVideoPipe, self).__init__(batch_size, num_threads, device_id, seed=args['seed']) print(shuffle, args['dist_videoframes'], args['skip_videoframes'], args['num_videoframes'], file_list) self.input = ops.VideoReader( device="gpu", file_list=file_list, sequence_length=args['num_videoframes'], shard_id=shard_id, num_shards=num_shards, random_shuffle=shuffle, initial_fill=args['initial_prefetch_size'], step=args['dist_videoframes'], stride=args['skip_videoframes'], skip_vfr_check=False)
def __init__(self, batch_size, num_threads=6, device_id=0, file_root='', shuffle=False, sequence_length=30, step=-1, stride=1, initial_fill=1024, seed=0, channels=3): super(VideoPipeFileRoot, self).__init__(batch_size, num_threads, device_id, seed=seed) self.input = ops.VideoReader(device='gpu', file_root=file_root, sequence_length=sequence_length, step=step, stride=stride, shard_id=0, num_shards=1, random_shuffle=shuffle, initial_fill=initial_fill, channels=channels) self.normalize = ops.Normalize(device='gpu')
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, batch_size, sequence_length, num_threads, device_id, file_root, crop_size, transforms=None): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) self.reader = ops.VideoReader( device='gpu', file_root=file_root, sequence_length=sequence_length, normalized=False, random_shuffle=True, image_type=types.RGB, dtype=types.UINT8, initial_fill=16 ) self.crop = ops.Crop(device="gpu", crop=crop_size, output_dtype=types.FLOAT) self.transpose = ops.Transpose(device="gpu", perm=[3, 0, 1, 2]) self.uniform = ops.Uniform(range=(0.0, 1.0)) self.flip = ops.Flip(device="gpu", horizontal=1, vertical=0) # self.normalize = ops.NormalizePermute( # device="gpu", # mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225], # width=224, # height=224 # ) self.cmn = ops.CropMirrorNormalize( device="gpu", output_dtype=types.FLOAT, # # output_layout=types.NCHW, crop=(224, 224), image_type=types.RGB, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] )
def __init__(self, device, batch_size, num_threads=1, device_id=0, num_gpus=1, is_old_crop=True): super(CropSequencePipeline, self).__init__(batch_size, num_threads, device_id) self.device = device VIDEO_FILES = [ test_data_video + '/' + file for file in ['sintel_trailer_short.mp4'] ] self.input = ops.VideoReader(device='gpu', filenames=VIDEO_FILES, sequence_length=10, shard_id=0, num_shards=1, random_shuffle=False, normalized=True, image_type=types.RGB, dtype=types.UINT8) if is_old_crop: self.crop = ops.Crop(device=device, crop=(224, 224), crop_pos_x=0.3, crop_pos_y=0.2, image_type=types.RGB) else: self.crop = ops.NewCrop(device=device, crop=(224, 224), crop_pos_x=0.3, crop_pos_y=0.2, image_type=types.RGB)
def __init__(self, batch_size, sequence_length, num_threads, device_id, file_list, crop_size): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) self.reader = ops.VideoReader(device="gpu", file_list=file_list, sequence_length=sequence_length, normalized=True, random_shuffle=True, image_type=types.RGB, dtype=types.FLOAT, initial_fill=16, enable_frame_num=True, stride=1, step=-1) self.uniform = ops.Uniform(range=(0.0, 1.0)) self.coin = ops.CoinFlip(probability=0.5) # self.crop = ops.Crop(device="gpu", crop=crop_size, output_dtype=types.FLOAT) # self.transpose = ops.Transpose(device="gpu", perm=[3, 0, 1, 2]) self.cropmirrornorm = ops.CropMirrorNormalize( device="gpu", crop=crop_size, output_dtype=types.FLOAT, mean=[0.45, 0.45, 0.45], std=[0.225, 0.225, 0.225], output_layout="CFHW")
def __init__(self, batch_size, num_threads, device_id, data): super(VideoPipe, self).__init__(batch_size, num_threads, device_id, seed=12) self.input = ops.VideoReader(device="gpu", file_root = data, sequence_length=COUNT, # instead of file_root, path to text file with pairs video_filepath label_value can be provided # self.input = ops.VideoReader(device="gpu", file_list = "file_list.txt", sequence_length=COUNT, shard_id=0, num_shards=1, random_shuffle=False, normalized=True, image_type=types.YCbCr, dtype=types.FLOAT)
def __init__(self, batch_size, data, device_id=0, sequence_length=COUNT): super(VideoPipeRoot, self).__init__(batch_size, num_threads=2, device_id=device_id) self.input = ops.VideoReader(device="gpu", file_root=data, sequence_length=sequence_length, random_shuffle=True)
def __init__(self, batch_size, num_threads, device_id, data, seq_len, step): super(OFPipeline, self).__init__(batch_size, num_threads, device_id) self.input = ops.VideoReader(device="gpu", file_list=data, sequence_length=seq_len, step=step) self.of_op = ops.OpticalFlow(device="gpu", output_format=4)
def __init__(self, batch_size, num_threads, device_id, file_list, sequence_length, seg_num, seg_length, resize_shorter_scale, crop_target_size, is_training=False, initial_prefetch_size=10, num_shards=1, shard_id=0, dali_mean=0., dali_std=1.0): super(VideoPipe, self).__init__(batch_size, num_threads, device_id) self.input = ops.VideoReader(device="gpu", file_list=file_list, sequence_length=sequence_length, seg_num=seg_num, seg_length=seg_length, is_training=is_training, num_shards=num_shards, shard_id=shard_id, random_shuffle=is_training, initial_fill=initial_prefetch_size) # the sequece data read by ops.VideoReader is of shape [F, H, W, C] # Because the ops.Resize does not support sequence data, # it will be transposed into [H, W, F, C], # then reshaped to [H, W, FC], and then resized like a 2-D image. self.transpose = ops.Transpose(device="gpu", perm=[1, 2, 0, 3]) self.reshape = ops.Reshape(device="gpu", rel_shape=[1.0, 1.0, -1], layout='HWC') self.resize = ops.Resize(device="gpu", resize_shorter=resize_shorter_scale) # crops and mirror are applied by ops.CropMirrorNormalize. # Normalization will be implemented in paddle due to the difficulty of dimension broadcast, # It is not sure whether dimension broadcast can be implemented correctly by dali, just take the Paddle Op instead. self.pos_rng_x = ops.Uniform(range=(0.0, 1.0)) self.pos_rng_y = ops.Uniform(range=(0.0, 1.0)) self.mirror_generator = ops.Uniform(range=(0.0, 1.0)) self.cast_mirror = ops.Cast(dtype=types.DALIDataType.INT32) self.crop_mirror_norm = ops.CropMirrorNormalize( device="gpu", crop=[crop_target_size, crop_target_size], mean=dali_mean, std=dali_std) self.reshape_back = ops.Reshape(device="gpu", shape=[ seg_num, seg_length * 3, crop_target_size, crop_target_size ], layout='FCHW') self.cast_label = ops.Cast(device="gpu", dtype=types.DALIDataType.INT64)
def __init__(self, image_dir, batch_size, num_threads, device_id, num_gpus, shuffle, cfg): super(VideoPipe, self).__init__(batch_size, num_threads, device_id, num_gpus, cfg) self.input = ops.VideoReader(device="gpu", file_root=image_dir, sequence_length=sequence_length, shard_id=0, num_shards=1, random_shuffle=shuffle, initial_fill=initial_prefetch_size)
def __init__(self, batch_size, num_threads, device_id, data): super(VideoPipe, self).__init__(batch_size, num_threads, device_id, seed=120) self.input = ops.VideoReader(device="gpu", filenames=data, sequence_length=1, shard_id=0, num_shards=1, random_shuffle=False, initial_fill=10)
def __init__(self, batch_size, num_threads=6, device_id=0, file_list="", shuffle=False, sequence_length=30, step=-1, stride=1, initial_fill=1024, seed=0): # super(VideoPipe, self).__init__(batch_size, num_threads, device_id, seed=seed) super(VideoPipe, self).__init__(batch_size, num_threads, device_id, seed=seed) # filenames assumes the selection of which files to load has already been made # TODO: does it load in order specified? # self.input = ops.VideoReader(device="gpu", filenames=filenames, self.input = ops.VideoReader(device="gpu", file_list=file_list, sequence_length=sequence_length, step=step, stride=stride, shard_id=0, num_shards=1, random_shuffle=shuffle, initial_fill=initial_fill)
def __init__(self, batch_size, num_threads, device_id, data): super(VideoPipe, self).__init__(batch_size, num_threads, device_id, seed=12) self.input = ops.VideoReader(device="gpu", filenames=data, sequence_length=COUNT, shard_id=0, num_shards=1, random_shuffle=False, normalized=True, image_type=types.YCbCr)
def __init__(self, batch_size, sequence_length, num_threads, device_id, files): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) self.reader = ops.VideoReader(device="gpu", filenames=files, sequence_length=sequence_length, normalized=False, image_type=types.RGB, dtype=types.UINT8) self.transpose = ops.Transpose(device="gpu", perm=[0, 3, 1, 2])
def __init__(self, video_files, sequence_length=8, target_size=224, stride=30): super(VideoPipe, self).__init__(1, 4, 0, seed=42) self.input = ops.VideoReader( device="gpu", filenames=video_files, sequence_length=sequence_length, stride=stride, shard_id=0, num_shards=1, random_shuffle=False, pad_last_batch=True) self.cmnp = ops.CropMirrorNormalize( device="gpu", dtype=types.FLOAT, output_layout=types.NFCHW, crop=(target_size, target_size), 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, sequence_length, num_threads, files, gt_files, \ crop_size, random_shuffle=True, step=-1, device_id=-1, seed=12): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=seed) #Define VideoReader self.reader = ops.VideoReader(device="gpu", \ filenames=files, \ sequence_length=sequence_length, \ normalized=False, \ random_shuffle=random_shuffle, \ image_type=types.RGB, \ dtype=types.UINT8, \ step=step, \ initial_fill=16, seed=seed) self.gt_reader = ops.VideoReader(device="gpu", \ filenames=gt_files, \ sequence_length=sequence_length, \ normalized=False, \ random_shuffle=random_shuffle, \ image_type=types.RGB, \ dtype=types.UINT8, \ step=step, \ initial_fill=16, seed=seed) # Define crop and permute operations to apply to every sequence self.crop = ops.Crop(device="gpu", \ crop=[crop_size, crop_size], \ output_dtype=types.FLOAT) self.uniform = ops.Uniform(range=(0.0, 1.0)) # used for random crop self.transpose = ops.Transpose(device="gpu", perm=[3, 0, 1, 2])
def __init__(self, batch_size, data, device_id=0, sequence_length=COUNT, step=-1, stride=1): super(VideoPipeList, self).__init__(batch_size, num_threads=2, device_id=device_id) self.input = ops.VideoReader(device="gpu", file_list=data, sequence_length=sequence_length, step=step, stride=stride, file_list_frame_num=True)
def __init__(self, batch_size, sequence_length, num_threads, device_id, files, crop_size): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) self.reader = ops.VideoReader(device="gpu", filenames=files, sequence_length=sequence_length, normalized=False, random_shuffle=True, image_type=types.RGB, dtype=types.UINT8, initial_fill=16) # self.crop = ops.Crop(device="gpu", crop=crop_size, output_dtype=types.FLOAT) self.uniform = ops.Uniform(range=(0.0, 1.0)) self.transpose = ops.Transpose(device="gpu", perm=[3, 0, 1, 2])
def __init__(self, batch_size, sequence_length, num_threads, device_id, files, crop_size, random_shuffle=True, step=-1): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) # Define VideoReader self.reader = ops.VideoReader(device="gpu", filenames=files, sequence_length=sequence_length, normalized=False, random_shuffle=random_shuffle, image_type=types.DALIImageType.RGB, dtype=types.DALIDataType.UINT8, step=step, initial_fill=16) # Define crop and permute operations to apply to every sequence self.crop = ops.CropMirrorNormalize(device="gpu", crop_w=crop_size, crop_h=crop_size, output_layout='FCHW', dtype=types.DALIDataType.FLOAT) self.uniform = ops.Uniform(range=(0.0, 1.0)) # used for random crop
def __init__( self, file_names: List[str], batch_size: int, num_workers: int, device_id: int, sequence_length: int, seed: int = -1, stride: int = 1, read_ahead: bool = False, shuffle: bool = False, ): super().__init__(batch_size, num_workers, device_id, seed) self.input = ops.VideoReader(device='gpu', sequence_length=sequence_length, enable_frame_num=True, filenames=file_names, labels=[], shard_id=0, num_shards=1, random_shuffle=shuffle, read_ahead=read_ahead, stride=stride)
def __init__(self, batch_size, sequence_length, num_threads, device_id, files, \ crop_size, random_shuffle=True, step=-1): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) #Define VideoReader self.reader = ops.VideoReader(device="gpu", \ filenames=files, \ sequence_length=sequence_length, \ normalized=False, \ random_shuffle=random_shuffle, \ image_type=types.RGB, \ dtype=types.UINT8, \ step=step, \ initial_fill=16) # Define crop and permute operations to apply to every sequence self.crop = ops.CropCastPermute(device="gpu", \ crop=crop_size, \ output_layout=types.NCHW, \ output_dtype=types.FLOAT) self.uniform = ops.Uniform(range=(0.0, 1.0)) # used for random crop
def __init__(self, file_list, batch_size, sequence_length, num_threads, device_id, crop_size, step=-1, stride=1, random_shuffle=True): super(VideoReaderPipeline, self).__init__(batch_size, num_threads, device_id, seed=12) # Define VideoReader self.reader = ops.VideoReader(device="gpu", file_list=file_list, sequence_length=sequence_length, normalized=False, random_shuffle=random_shuffle, image_type=types.RGB, dtype=types.UINT8, step=step, stride=stride, initial_fill=16) # Define crop, mirror and normalisation operations to apply to every sequence self.crop = ops.Crop(device="gpu", crop=crop_size, output_dtype=types.FLOAT) self.transpose = ops.Transpose(device="gpu", perm=[0, 3, 1, 2]) # [N F C H W] self.uniform = ops.Uniform(range=(0.2, 1.0)) # used for random crop
def __init__(self, batch_size, num_threads, device_id, data): super(VideoPipe, self).__init__(batch_size, num_threads, device_id, seed=12) self.input = ops.VideoReader(device="gpu", filenames=data, count=COUNT, shard_id=0, num_shards=1, random_shuffle=False)
def __init__(self, directory, supervised: bool = True, sequence_length: int = 11, batch_size: int = 1, num_workers: int = 1, gpu_id: int = 0, shuffle: bool = True, crop_size: tuple = (256, 256), resize: tuple = None, brightness: float = 0.25, contrast: float = 0.1, mean: list = [0.5, 0.5, 0.5], std: list = [0.5, 0.5, 0.5], conv_mode='3d', image_shape=(256, 256), validate: bool = False): super().__init__(batch_size, num_workers, gpu_id, prefetch_queue_depth=1) self.input = ops.VideoReader(additional_decode_surfaces=1, channels=3, device="gpu", dtype=types.FLOAT, enable_frame_num=False, enable_timestamps=False, file_root=directory, image_type=types.RGB, initial_fill=1, lazy_init=False, normalized=True, num_shards=1, pad_last_batch=False, prefetch_queue_depth=1, random_shuffle=shuffle, sequence_length=sequence_length, skip_vfr_check=True, step=-1, shard_id=0, stick_to_shard=False, stride=1) self.uniform = ops.Uniform(range=(0.0, 1.0)) self.cmn = ops.CropMirrorNormalize(device='gpu', crop=crop_size, mean=mean, std=std, output_layout=types.NFHWC) self.coin = ops.CoinFlip(probability=0.5) self.brightness_val = ops.Uniform( range=[1 - brightness, 1 + brightness]) self.contrast_val = ops.Uniform(range=[1 - contrast, 1 + contrast]) self.supervised = supervised self.half = ops.Constant(fdata=0.5) self.zero = ops.Constant(idata=0) self.cast_to_long = ops.Cast(device='gpu', dtype=types.INT64) if crop_size is not None: H, W = crop_size else: # default H, W = image_shape # print('CONV MODE!!! {}'.format(conv_mode)) if conv_mode == '3d': self.transpose = ops.Transpose(device="gpu", perm=[3, 0, 1, 2]) self.reshape = None elif conv_mode == '2d': self.transpose = ops.Transpose(device='gpu', perm=[0, 3, 1, 2]) self.reshape = ops.Reshape(device='gpu', shape=[-1, H, W]) self.validate = validate