Ejemplo n.º 1
0
 def __init__(self,
              batch_size,
              output_type,
              input_type,
              use_input,
              num_threads=3,
              device_id=0,
              num_gpus=1):
     super(CVPipeline, self).__init__(batch_size,
                                      num_threads,
                                      device_id,
                                      seed=7865,
                                      exec_async=False,
                                      exec_pipelined=False)
     self.use_input = use_input
     self.name = "cv"
     self.input = ops.CaffeReader(path=caffe_db_folder,
                                  shard_id=device_id,
                                  num_shards=num_gpus)
     self.decode = ops.ImageDecoder(device="cpu", output_type=types.RGB)
     if self.use_input:
         self.transform_source = ops.ExternalSource()
         self.warp = ops.PythonFunction(
             function=CVWarp(output_type, input_type))
     else:
         self.warp = ops.PythonFunction(function=CVWarp(
             output_type, input_type, [[0.1, 0.9, 10], [0.8, -0.2, -20]]))
     self.iter = 0
Ejemplo n.º 2
0
    def __init__(self, device, batch_size, dims, axes, axis_names, batch=False,
                 out_type=None, in_type=None, shift=None, scale=None,
                 num_threads=3, device_id=0, num_gpus=1):
        super(NormalizePipeline, self).__init__(
            batch_size, num_threads, device_id, seed=7865,
            exec_async=False, exec_pipelined=False)
        common_args = {
            "device": device,
            "axes": axes,
            "axis_names": axis_names,
            "batch": batch,
            "dtype": dali_type(out_type),
            "shift": shift,
            "scale": scale
        }
        self.in_type = in_type
        self.out_type = out_type
        self.device = device
        self.input = ops.ExternalSource()
        self.add_layout = None
        if axis_names is not None:
            layout = ''
            for i in range(dims):
                layout += chr(ord('a') + i)
            self.add_layout = ops.Reshape(layout=layout)
        self.batch = batch
        self.dims = dims
        self.has_axes = axes is not None or axis_names is not None
        self.scale = scale
        self.shift = shift
        self.is_integral = out_type is not None and out_type is not np.float32

        if axis_names is not None:
            axes = []
            for a in axis_names:
                axes.append(ord(a) - ord('a'))

        self.axes = axes
        self.axis_names = axis_names
        self.ddof = 2 if axes is not None and len(axes) > 0 else 0
        self.eps = 0.25

        self.mean = ops.PythonFunction(function=custom_mean(batch, axes), batch_processing=True)
        self.stddev = ops.PythonFunction(function=custom_stddev(batch, axes), batch_processing=True)
        self.normalize = ops.Normalize(**common_args, ddof=self.ddof)
        self.scalar_mean = ops.Normalize(**common_args, mean=1, ddof=self.ddof, epsilon=self.eps)
        self.scalar_stddev = ops.Normalize(**common_args, stddev=2, epsilon=self.eps)
        self.scalar_params = ops.Normalize(**common_args, mean=1, stddev=2)
Ejemplo n.º 3
0
 def __init__(self, batch_size, num_threads, device_id, data_dir, crop):
     super(HybridTrainPipe, self).__init__(batch_size, num_threads,
                                           device_id, data_dir, crop)
     self.pad = ops.Paste(device="gpu",
                          fill_value=0,
                          ratio=1.1,
                          min_canvas_size=crop)
     self.res = ops.RandomResizedCrop(device="gpu",
                                      size=crop,
                                      random_area=[0.9, 1.1],
                                      random_aspect_ratio=1.33333)
     self.cutmix = ops.PythonFunction(function=cut_mixe_image,
                                      num_outputs=2,
                                      device='gpu')
     self.cmnp = ops.CropMirrorNormalize(
         device="gpu",
         output_dtype=types.FLOAT,
         output_layout=types.NCHW,
         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)
     self.rotated = ops.Rotate(device="gpu", keep_size=True)
     self.rotated_rng = ops.Uniform(range=(-5.0, 5.0))
     self.brightness = ops.Brightness(device="gpu")
     self.brightness_rng = ops.Uniform(range=(0.8, 1.2))
     self.reshape = ops.Reshape(device="gpu", layout="HWC")
     self.one_hot = ops.OneHot(num_classes=3,
                               dtype=types.INT32,
                               device="cpu")
     self.jitter_rng = ops.CoinFlip(probability=0.3)
     self.jittered = ops.Jitter(device="gpu")
Ejemplo n.º 4
0
    def __init__(self,
                 batch_size,
                 layout,
                 iterator,
                 pos_size_iter,
                 num_threads=1,
                 device_id=0,
                 num_gpus=1,
                 axes=None,
                 axis_names=None,
                 normalized_anchor=True,
                 normalized_shape=True):
        super(SliceSynthDataPipelinePythonOp,
              self).__init__(batch_size,
                             num_threads,
                             device_id,
                             seed=12345,
                             exec_async=False,
                             exec_pipelined=False)
        self.device = "cpu"
        self.layout = layout
        self.iterator = iterator
        self.pos_size_iter = pos_size_iter
        self.inputs = ops.ExternalSource()
        self.input_crop_pos = ops.ExternalSource()
        self.input_crop_size = ops.ExternalSource()

        function = partial(slice_func_helper, axes, axis_names, self.layout,
                           normalized_anchor, normalized_shape)
        self.slice = ops.PythonFunction(function=function)
Ejemplo n.º 5
0
 def __init__(self,
              batch_size,
              layout,
              iterator,
              pos_size_iter,
              num_threads=1,
              device_id=0,
              num_gpus=1,
              axes=None,
              axis_names=None,
              normalized_anchor=True,
              normalized_shape=True,
              input_type=types.FLOAT,
              output_type=None):
     super().__init__(batch_size,
                      num_threads,
                      device_id,
                      seed=12345,
                      exec_async=False,
                      exec_pipelined=False)
     self.device = "cpu"
     self.layout = layout
     self.iterator = iterator
     self.pos_size_iter = pos_size_iter
     self.inputs = ops.ExternalSource()
     self.input_crop_pos = ops.ExternalSource()
     self.input_crop_size = ops.ExternalSource()
     self.cast_in = ops.Cast(dtype=input_type)
     function = partial(slice_func_helper, axes, axis_names, self.layout,
                        normalized_anchor, normalized_shape)
     self.slice = ops.PythonFunction(function=function,
                                     output_layouts=layout)
     self.output_type = output_type
     if self.output_type is not None:
         self.cast_out = ops.Cast(dtype=output_type)
Ejemplo n.º 6
0
    def __init__(self,
                 batch_size,
                 pos_size_iter,
                 num_threads=1,
                 device_id=0,
                 num_gpus=1,
                 axes=None,
                 axis_names=None,
                 normalized_anchor=True,
                 normalized_shape=True):
        super(SlicePythonOp, self).__init__(batch_size,
                                            num_threads,
                                            device_id,
                                            seed=12345,
                                            exec_async=False,
                                            exec_pipelined=False)
        self.device = "cpu"
        self.layout = "HWC"
        self.pos_size_iter = pos_size_iter

        self.input = ops.CaffeReader(path=caffe_db_folder,
                                     random_shuffle=False)
        self.decode = ops.ImageDecoder(device='cpu', output_type=types.RGB)

        self.input_crop_pos = ops.ExternalSource()
        self.input_crop_size = ops.ExternalSource()

        function = partial(slice_func_helper, axes, axis_names, self.layout,
                           normalized_anchor, normalized_shape)
        self.slice = ops.PythonFunction(function=function)
        self.set_layout = ops.Reshape(layout="HWC")
Ejemplo n.º 7
0
 def __init__(self,
              batch_size,
              output_type,
              input_type,
              fixed_size,
              num_threads=3,
              device_id=0,
              num_gpus=1):
     super(CVPipeline, self).__init__(batch_size,
                                      num_threads,
                                      device_id,
                                      seed=7865,
                                      exec_async=False,
                                      exec_pipelined=False)
     self.name = "cv"
     self.input = ops.CaffeReader(path=caffe_db_folder,
                                  shard_id=device_id,
                                  num_shards=num_gpus)
     self.decode = ops.ImageDecoder(device="cpu", output_type=types.RGB)
     self.rotate = ops.PythonFunction(
         function=CVRotate(output_type, input_type, 30, fixed_size))
     # TODO(michalz): When we move from Support to CPU operators, replace hardcoded angle
     #                with one taken from the distribution below
     # self.uniform = ops.Uniform(range = (-180.0, 180.0), seed = 42);
     self.iter = 0
 def __init__(self, batch_size, num_threads, device_id, seed, image_dir,
              function):
     super(TwoOutputsPythonOperatorPipeline,
           self).__init__(batch_size, num_threads, device_id, seed,
                          image_dir)
     self.python_function = ops.PythonFunction(function=function,
                                               num_outputs=2)
Ejemplo n.º 9
0
    def __init__(self,
                 function,
                 batch_size,
                 iterator,
                 data_shape,
                 data_layout,
                 num_threads=1,
                 device_id=0):
        super(Crop3dPythonOpPipeline, self).__init__(batch_size,
                                                     num_threads,
                                                     device_id,
                                                     exec_async=False,
                                                     exec_pipelined=False)
        self.iterator = iterator
        self.inputs = ops.ExternalSource()
        self.data_shape = data_shape
        self.data_layout = data_layout

        def crop_func(image):
            return function(image,
                            layout=self.data_layout,
                            shape=self.data_shape)

        self.crop = ops.PythonFunction(function=crop_func,
                                       output_layouts=data_layout)
Ejemplo n.º 10
0
    def __init__(self,
                 function,
                 batch_size,
                 data_layout,
                 iterator,
                 anchor,
                 shape,
                 axis_names,
                 axes,
                 fill_value,
                 erase_func=erase_func,
                 num_threads=1,
                 device_id=0):
        super(ErasePythonPipeline, self).__init__(batch_size,
                                                  num_threads,
                                                  device_id,
                                                  exec_async=False,
                                                  exec_pipelined=False)
        self.iterator = iterator
        self.inputs = ops.ExternalSource()
        self.data_layout = data_layout

        function = partial(erase_func, anchor, shape, axis_names, axes,
                           data_layout, fill_value)

        self.erase = ops.PythonFunction(function=function,
                                        output_layouts=data_layout)
 def __init__(self, batch_size, num_threads, device_id, seed, image_dir,
              function):
     super(MultiInputMultiOutputPipeline,
           self).__init__(batch_size, num_threads, device_id, seed,
                          image_dir)
     self.python_function = ops.PythonFunction(function=function,
                                               num_outputs=3)
Ejemplo n.º 12
0
    def __init__(self,
                 device,
                 batch_size,
                 iterator,
                 nfft,
                 window_length,
                 window_step,
                 window=None,
                 center=None,
                 num_threads=1,
                 device_id=0,
                 spectrogram_func=spectrogram_func_librosa):
        super(SpectrogramPythonPipeline, self).__init__(batch_size,
                                                        num_threads,
                                                        device_id,
                                                        seed=12345,
                                                        exec_async=False,
                                                        exec_pipelined=False)
        self.device = "cpu"
        self.iterator = iterator
        self.inputs = ops.ExternalSource()

        function = partial(spectrogram_func, nfft, window_length, window_step,
                           window, center)
        self.spectrogram = ops.PythonFunction(function=function,
                                              output_layouts=["ft"])
Ejemplo n.º 13
0
    def __init__(self,
                 batch_size,
                 nfft,
                 window_length,
                 window_step,
                 center,
                 layout="ft",
                 num_threads=1,
                 device_id=0,
                 spectrogram_func=spectrogram_func_librosa):
        super(AudioSpectrogramPythonPipeline,
              self).__init__(batch_size,
                             num_threads,
                             device_id,
                             seed=12345,
                             exec_async=False,
                             exec_pipelined=False)

        self.input = ops.readers.File(device="cpu", files=audio_files)
        self.decode = ops.decoders.Audio(device="cpu",
                                         dtype=types.FLOAT,
                                         downmix=True)

        function = partial(spectrogram_func, nfft, window_length, window_step,
                           None, center)
        self.spectrogram = ops.PythonFunction(function=function,
                                              output_layouts=["ft"])
        self.layout = layout
Ejemplo n.º 14
0
 def __init__(self, iterator, batch_size):
     super().__init__(iterator,
                      batch_size,
                      exec_async=False,
                      exec_pipelined=False)
     function = partial(log_tensor)
     self.log = ops.PythonFunction(function=function)
Ejemplo n.º 15
0
    def __init__(self,
                 function,
                 batch_size,
                 iterator,
                 data_shape,
                 data_layout,
                 num_threads=1,
                 device_id=0,
                 dictionary={},
                 default_value=0.0):
        super(LookupTablePythonOpPipeline, self).__init__(batch_size,
                                                          num_threads,
                                                          device_id,
                                                          exec_async=False,
                                                          exec_pipelined=False)
        self.iterator = iterator
        self.inputs = ops.ExternalSource()
        self.data_shape = data_shape
        self.data_layout = data_layout

        def lookup_table_func(input_data):
            return function(input_data,
                            shape=data_shape,
                            dictionary=dictionary,
                            default_value=default_value)

        self.lookup = ops.PythonFunction(function=lookup_table_func)
        self.set_layout = ops.Reshape(layout=data_layout)
Ejemplo n.º 16
0
    def __init__(self,
                 device,
                 batch_size,
                 iterator,
                 nfilter,
                 sample_rate,
                 freq_low,
                 freq_high,
                 normalize,
                 mel_formula,
                 num_threads=1,
                 device_id=0,
                 func=mel_fbank_func):
        super(MelFilterBankPythonPipeline, self).__init__(batch_size,
                                                          num_threads,
                                                          device_id,
                                                          seed=12345,
                                                          exec_async=False,
                                                          exec_pipelined=False)
        self.device = "cpu"
        self.iterator = iterator
        self.inputs = ops.ExternalSource()

        function = partial(func, nfilter, sample_rate, freq_low, freq_high,
                           normalize, mel_formula)
        self.mel_fbank = ops.PythonFunction(function=function)
 def __init__(self, batch_size, num_threads, device_id, _seed, image_dir):
     super(CommonPipeline, self).__init__(batch_size, num_threads, device_id, seed=_seed, exec_async=False,
                                          exec_pipelined=False)
     self.input = ops.FileReader(file_root=image_dir)
     self.decode = ops.ImageDecoder(device = 'cpu', output_type=types.RGB)
     self.resize = ops.PythonFunction(function=resize)
     self.set_layout = ops.Reshape(layout="HWC")
Ejemplo n.º 18
0
 def __init__(self, batch_size, cutoff_value, window_size, reference_power, reset_interval):
     super(NonsilenceRosaPipeline, self).__init__(batch_size, num_threads=1,
                                                  exec_async=False, exec_pipelined=False)
     hop_length = 1
     function = partial(trim_ref, cutoff_value,
                        np.max if not reference_power else reference_power,
                        window_size, hop_length)
     self.nonsilence = ops.PythonFunction(function=function, num_outputs=2)
Ejemplo n.º 19
0
 def __init__(self, device, batch_size, use_wildcard, num_threads=3, device_id=0, num_gpus=1):
     super(ReshapeWithInput, self).__init__(batch_size, num_threads, device_id, seed=7865, exec_async=False, exec_pipelined=False)
     self.device = device
     self.input = ops.CaffeReader(path = caffe_db_folder, shard_id = device_id, num_shards = num_gpus)
     self.decode = ops.ImageDecoder(device = "cpu", output_type = types.RGB)
     fn = CollapseChannelsWildcard if use_wildcard else CollapseChannels
     self.gen_shapes = ops.PythonFunction(function=fn)
     self.reshape = ops.Reshape(device = device, layout = "ab");
Ejemplo n.º 20
0
 def __init__(self, batch_size, output_type, input_type, fixed_size, num_threads=3, device_id=0, num_gpus=1):
     super(CVPipeline, self).__init__(batch_size, num_threads, device_id, seed=7865, exec_async=False, exec_pipelined=False)
     self.name = "cv"
     self.input = ops.CaffeReader(path = caffe_db_folder, shard_id = device_id, num_shards = num_gpus)
     self.decode = ops.ImageDecoder(device = "cpu", output_type = types.RGB)
     self.rotate = ops.PythonFunction(function=CVRotate(output_type, input_type, fixed_size))
     self.uniform = ops.Uniform(range = (-180.0, 180.0), seed = 42);
     self.iter = 0
Ejemplo n.º 21
0
 def __init__(self, function, batch_size, num_threads=1, device_id=0):
     super(PythonOperatorPipeline, self).__init__(batch_size, num_threads, device_id,
                                                  exec_async=False,
                                                  exec_pipelined=False,
                                                  seed=1234)
     self.input = ops.CaffeReader(path = caffe_db_folder, random_shuffle=False)
     self.decode = ops.HostDecoder(device = 'cpu', output_type = types.RGB)
     self.python_function = ops.PythonFunction(function=function)
Ejemplo n.º 22
0
 def __init__(self, batch_size, num_threads, device_id, _seed):
     super(AsyncPipeline, self).__init__(batch_size,
                                         num_threads,
                                         device_id,
                                         seed=_seed,
                                         exec_async=True,
                                         exec_pipelined=True)
     self.op = ops.PythonFunction(function=lambda: numpy.zeros([2, 2, 2]))
Ejemplo n.º 23
0
 def __init__(self, function, batch_size, num_threads=1, device_id=0):
     super(MultichannelPythonOpPipeline, self).__init__(batch_size,
                                                        num_threads,
                                                        device_id,
                                                        exec_async=False,
                                                        exec_pipelined=False)
     self.reader = ops.readers.File(file_root=multichannel_tiff_root)
     self.decoder = ops.decoders.Image(device = 'cpu', output_type = types.ANY_DATA)
     self.oper = ops.PythonFunction(function=function, output_layouts="HWC")
Ejemplo n.º 24
0
 def __init__(self,  batch_size,function,  num_threads=1, device_id=0, num_gpus=1 ):
     super(WaterPythonPipeline, self).__init__(batch_size,
                                        num_threads,
                                        device_id,
                                        exec_async=False,
                                        exec_pipelined=False)
     self.input = ops.CaffeReader(path = caffe_db_folder, shard_id = device_id, num_shards = num_gpus)
     self.decode = ops.HostDecoder(device = "cpu", output_type = types.RGB)
     self.water = ops.PythonFunction(function=function)
Ejemplo n.º 25
0
 def __init__(self, device, batch_size, relative, use_wildcard, num_threads=3, device_id=0, num_gpus=1):
     super(ReshapeWithArgInput, self).__init__(batch_size, num_threads, device_id, seed=7865, exec_async=False, exec_pipelined=False)
     self.device = device
     self.input = ops.CaffeReader(path = caffe_db_folder, shard_id = device_id, num_shards = num_gpus)
     self.resize = ops.Resize(device = "cpu");
     self.decode = ops.ImageDecoder(device = "cpu", output_type = types.RGB)
     self.gen_shapes = ops.PythonFunction(function=MakeTallFunc(relative, use_wildcard))
     self.reshape = ops.Reshape(device = device);
     self.relative = relative
Ejemplo n.º 26
0
 def __init__(self, function, batch_size, layout, iterator, num_threads=1, device_id=0):
     super(PythonOpPipeline, self).__init__(batch_size,
                                            num_threads,
                                            device_id,
                                            exec_async=False,
                                            exec_pipelined=False)
     self.layout = layout
     self.iterator = iterator
     self.inputs = ops.ExternalSource()
     self.oper = ops.PythonFunction(function=function)
 def __init__(self, function, device, num_outputs=1):
     super(PythonFunctionPipeline, self).__init__(BATCH_SIZE, NUM_WORKERS, DEVICE_ID,
                                                  seed=SEED,
                                                  exec_async=False, exec_pipelined=False)
     self.device = device
     self.reader = ops.readers.File(file_root=images_dir)
     self.decode = ops.decoders.Image(device='cpu',
                                      output_type=types.RGB)
     self.norm = ops.CropMirrorNormalize(std=255., mean=0., device=device, output_layout="HWC")
     self.func = ops.PythonFunction(device=device, function=function, num_outputs=num_outputs)
Ejemplo n.º 28
0
    def __init__(self, device, batch_size, iterator, axis=0, dct_type=2, lifter=1.0, n_mfcc=20,
                 norm=None, num_threads=1, device_id=0, func=mfcc_func):
        super(MFCCPythonPipeline, self).__init__(
              batch_size, num_threads, device_id,
              seed=12345, exec_async=False, exec_pipelined=False)
        self.device = "cpu"
        self.iterator = iterator
        self.inputs = ops.ExternalSource()

        function = partial(func, axis, dct_type, lifter, n_mfcc, norm)
        self.mfcc = ops.PythonFunction(function=function)
Ejemplo n.º 29
0
    def __init__(self, batch_size, nfft, window_length, window_step,
                 num_threads=1, device_id=0, spectrogram_func=spectrogram_func_librosa):
        super(AudioSpectrogramPythonPipeline, self).__init__(
            batch_size, num_threads, device_id,
            seed=12345, exec_async=False, exec_pipelined=False)

        self.input = ops.FileReader(device="cpu", file_root=audio_files)
        self.decode = ops.AudioDecoder(device="cpu", dtype=types.FLOAT, downmix=True)

        function = partial(spectrogram_func, nfft, window_length, window_step)
        self.spectrogram = ops.PythonFunction(function=function)
Ejemplo n.º 30
0
    def __init__(self, device, batch_size, iterator, multiplier, reference, cutoff_db,
                 num_threads=1, device_id=0, func=to_db_func):
        super(ToDecibelsPythonPipeline, self).__init__(
              batch_size, num_threads, device_id,
              seed=12345, exec_async=False, exec_pipelined=False)
        self.device = "cpu"
        self.iterator = iterator
        self.inputs = ops.ExternalSource()

        function = partial(func, multiplier, reference, cutoff_db)
        self.dB = ops.PythonFunction(function=function)