def check_gaussian_blur(batch_size, sigma, window_size, op_type="cpu"): decoder_device = "cpu" if op_type == "cpu" else "mixed" pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=0) with pipe: input, _ = fn.file_reader(file_root=images_dir, shard_id=0, num_shards=1) decoded = fn.image_decoder(input, device=decoder_device, output_type=types.RGB) blurred = fn.gaussian_blur(decoded, device=op_type, sigma=sigma, window_size=window_size) pipe.set_outputs(blurred, decoded) pipe.build() for _ in range(test_iters): result, input = pipe.run() if op_type == "gpu": result = result.as_cpu() input = input.as_cpu() input = to_batch(input, batch_size) baseline_cv = [gaussian_cv(img, sigma, window_size) for img in input] check_batch(result, baseline_cv, batch_size, max_allowed_error=1)
def check_generic_gaussian_blur( batch_size, sigma, window_size, shape, layout, axes, op_type="cpu", in_dtype=np.uint8, out_dtype=types.NO_TYPE, random_shape=True): pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=0) min_shape = None if random_shape else shape data = RandomlyShapedDataIterator(batch_size, min_shape=min_shape, max_shape=shape, dtype=in_dtype) # Extract the numpy type from DALI, we can have float32 or the same as input if out_dtype == types.NO_TYPE: result_type = in_dtype elif dali_type(in_dtype) == out_dtype: result_type = in_dtype else: result_type = np.float32 with pipe: input = fn.external_source(data, layout=layout) if op_type == "gpu": input = input.gpu() blurred = fn.gaussian_blur(input, device=op_type, sigma=sigma, window_size=window_size, dtype=out_dtype) pipe.set_outputs(blurred, input) pipe.build() for _ in range(test_iters): result, input = pipe.run() if op_type == "gpu": result = result.as_cpu() input = input.as_cpu() input = to_batch(input, batch_size) skip_axes = count_skip_axes(layout) baseline = [ gaussian_baseline(img, sigma, window_size, axes, skip_axes, dtype=result_type) for img in input] max_error = 1 if result_type != np.float32 else 1e-04 check_batch(result, baseline, batch_size, max_allowed_error=max_error, expected_layout=layout)
def check_gaussian_blur_output(batch_size, sigma, window_size, op_type="cpu"): decoder_device = "cpu" if op_type == "cpu" else "mixed" pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=0) with pipe: input, _ = fn.file_reader(file_root=images_dir, shard_id=0, num_shards=1) decoded = fn.image_decoder(input, device=decoder_device, output_type=types.RGB) blurred = fn.gaussian_blur(decoded, device=op_type, sigma=sigma, window_size=window_size) normalized = fn.crop_mirror_normalize(blurred, device=op_type, dtype=types.FLOAT, output_layout="HWC", mean=[128.0, 128.0, 128.0], std=[100.0, 100.0, 100.0]) pipe.set_outputs(normalized) pipe.build() for _ in range(3): result = pipe.run()
def pipeline(): outputs = fn.external_source( # noqa F841 source=sample_cb_source, batch=False, num_outputs=num_outputs) data = fn.random.uniform(range=(0, 255), shape=(300, 100, 3)) img = fn.reshape(data, layout="HWC") return fn.gaussian_blur(img, window_size=3)
def check_per_sample_gaussian_blur(batch_size, sigma_dim, window_size_dim, shape, layout, axes, op_type="cpu"): pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=0) data = RandomlyShapedDataIterator(batch_size, max_shape=shape) with pipe: if sigma_dim is not None: sigma = fn.random.uniform(range=[0.5, 3], shape=[sigma_dim]) sigma_arg = sigma else: # placeholder, so we can return something sigma = fn.random.coin_flip(probability=0) sigma_arg = None if window_size_dim is not None: window_radius = fn.random.uniform(range=[5, 10], shape=[window_size_dim]) window_size = fn.cast(window_radius, dtype=types.INT32) * 2 + 1 window_arg = window_size else: window_size = fn.random.coin_flip(probability=0) window_arg = None input = fn.external_source(data, layout=layout) if op_type == "gpu": input = input.gpu() blurred = fn.gaussian_blur(input, device=op_type, sigma=sigma_arg, window_size=window_arg) pipe.set_outputs(blurred, input, sigma, window_size) pipe.build() for _ in range(test_iters): result, input, sigma, window_size = pipe.run() if op_type == "gpu": result = result.as_cpu() input = input.as_cpu() input = to_batch(input, batch_size) sigma = to_batch(sigma, batch_size) window_size = to_batch(window_size, batch_size) baseline = [] for i in range(batch_size): sigma_arg = sigma[i] if sigma is not None else None window_arg = window_size[i] if window_size_dim is not None else None skip_axes = count_skip_axes(layout) baseline.append( gaussian_baseline(input[i], sigma_arg, window_arg, axes, skip_axes)) check_batch(result, baseline, batch_size, max_allowed_error=1, expected_layout=layout)
def pipeline(): outputs = fn.external_source(source=sources[source_type], num_outputs=num_outputs, batch=source_type != "sample_cb_source") assert len(outputs) == num_outputs utilized_outputs = (out for out, is_used in zip(outputs, usage_mask) if is_used) return tuple( fn.gaussian_blur(out, window_size=3) for out in utilized_outputs)
def get_gaussian_pipe(batch_size, sigma, window_size, op_type): pipe = Pipeline(batch_size=batch_size, num_threads=4, device_id=0) with pipe: input, _ = fn.readers.file(file_root=images_dir, shard_id=0, num_shards=1) decoded = fn.decoders.image(input, device="cpu", output_type=types.RGB) if op_type == "gpu": decoded = decoded.gpu() blurred = fn.gaussian_blur(decoded, device=op_type, sigma=sigma, window_size=window_size) pipe.set_outputs(blurred, decoded) return pipe
def blur_fn(self, img): img_blured = fn.gaussian_blur(img, sigma=fn.uniform(range=(0.5, 1.5))) return self.random_augmentation(0.15, img_blured, img)
labels += [index] * args.bs W, H = int(args.sz * 120), int(args.sz * 400) ImageBytes = W * H * 3 * 4 TestingPipe = Pipeline(batch_size=args.bs, num_threads=4, device_id=0) with TestingPipe: files, labels = fn.file_reader(files=DataList, labels=labels) images = fn.image_decoder(files, device='cpu', use_fast_idct=True) images = fn.resize(images.gpu(), device='gpu', bytes_per_sample_hint=ImageBytes, size=(H, W)) images = fn.gaussian_blur(images, device='gpu', bytes_per_sample_hint=ImageBytes, sigma=fn.uniform(range=(0.1, 2)), window_size=11) images = fn.color_twist(images, device='gpu', bytes_per_sample_hint=ImageBytes, brightness=fn.uniform(range=(0.5, 1.5)), contrast=fn.uniform(range=(0.5, 2.5)), saturation=fn.uniform(range=(0.1, 2))) images = fn.cast(images, device='gpu', bytes_per_sample_hint=ImageBytes, dtype=DALIDataType.FLOAT) images = fn.normalize( images, device='gpu',
def pipeline(): blob = fn.random.uniform(range=[0, 1], shape=(3, 200, 100)) image = fn.reshape(blob, layout="CHW") per_channel = np.array([3, 5, 7]) return fn.gaussian_blur(image, window_size=fn.per_frame(per_channel))
def train_pipeline(cfg: TrainLoaderConfig): jpeg, label = fn.readers.file( file_root=ROOT_DATA_DIR + "/train/", random_shuffle=True, shard_id=env_rank(), num_shards=env_world_size(), name="Reader", ) image = fn.decoders.image_random_crop( jpeg, device="mixed", random_aspect_ratio=[0.75, 1.25], random_area=[cfg.min_area, 1.0], num_attempts=100, output_type=types.RGB, ) image_tr = fn.resize(image, device="gpu", size=cfg.image_size, interp_type=types.INTERP_TRIANGULAR) if cfg.random_interpolation: image_cub = fn.resize(image, device="gpu", size=cfg.image_size, interp_type=types.INTERP_CUBIC) image = mix(fn.random.coin_flip(probability=0.5), image_cub, image_tr) else: image = image_tr if cfg.blur_prob > 0: blur_image = fn.gaussian_blur( image, device="gpu", window_size=11, sigma=fn.random.uniform(range=[0.5, 1.1])) image = mix( fn.random.coin_flip(probability=cfg.blur_prob, dtype=types.BOOL), blur_image, image) if cfg.color_twist_prob > 0: image_ct = fn.color_twist( image, device="gpu", contrast=fn.random.uniform(range=[0.7, 1.3]), brightness=fn.random.uniform(range=[0.7, 1.3]), hue=fn.random.uniform(range=[-20, 20]), # in degrees saturation=fn.random.uniform(range=[0.7, 1.3]), ) image = mix( fn.random.coin_flip(probability=cfg.color_twist_prob, dtype=types.BOOL), image_ct, image) if cfg.gray_prob > 0: grayscale_coin = fn.cast( fn.random.coin_flip(probability=cfg.gray_prob), dtype=types.FLOAT) image = fn.hsv(image, device="gpu", saturation=grayscale_coin) if cfg.re_prob: # random erasing image_re = fn.erase( image, device="gpu", anchor=fn.random.uniform(range=(0.0, 1), shape=cfg.re_count * 2), shape=fn.random.uniform(range=(0.05, 0.25), shape=cfg.re_count * 2), axis_names="HW", fill_value=DATA_MEAN, normalized_anchor=True, normalized_shape=True, ) image = mix( fn.random.coin_flip(probability=cfg.re_prob, dtype=types.BOOL), image_re, image) image = fn.crop_mirror_normalize( image, device="gpu", crop=(cfg.image_size, cfg.image_size), mirror=fn.random.coin_flip(probability=0.5), mean=DATA_MEAN, std=DATA_STD, dtype=types.FLOAT, output_layout=types.NCHW, ) label = fn.one_hot(label, num_classes=cfg.num_classes).gpu() return image, label
def blur_fn(self, img): img_blured = fn.gaussian_blur(img, sigma=fn.uniform(range=(0.5, 1.5), **self.aug_seed_kwargs),**self.aug_seed_kwargs) return self.random_augmentation(RAND_AUG_PROB, img_blured, img)