def test_3d_sequence(): rng = random.Random(42) num_batches = 4 max_batch_size = 8 max_frames_num = 32 input_layout = "FDHWC" np_rng = np.random.default_rng(42) def get_random_sample(): num_frames = rng.randint(1, max_frames_num) d, h, w = tuple(rng.randint(10, 50) for _ in range(3)) return np.int32(np_rng.uniform(0, 255, (num_frames, d, h, w, 3))) def get_random_batch(): return [get_random_sample() for _ in range(rng.randint(1, max_batch_size))] input_cases = [ ArgData(desc=ArgDesc(0, "F", "", input_layout), data=[get_random_batch() for _ in range(num_batches)]) ] def random_angle(sample_desc): return np.array(sample_desc.rng.uniform(-180., 180.), dtype=np.float32) def random_axis(sample_desc): return np.array([sample_desc.rng.uniform(-1, 1) for _ in range(3)], dtype=np.float32) test_cases = [ (dali.fn.rotate, {'angle': 45., 'axis': np.array([1, 0, 0], dtype=np.float32)}, []), (dali.fn.rotate, {'size': (50, 30, 20)}, [ArgCb("angle", random_angle, True), ArgCb("axis", random_axis, True)]), (dali.fn.rotate, {}, RotatePerFrameParamsProvider([ArgCb("angle", random_angle, True), ArgCb("axis", random_axis, True)])), ] yield from sequence_suite_helper(rng, input_cases, test_cases)
def test_per_frame(): def window_size(sample_desc): return np.array(2 * sample_desc.rng.randint(1, 15) + 1, dtype=np.int32) def per_axis_window_size(sample_desc): return np.array([window_size(sample_desc) for _ in range(2)]) def sigma(sample_desc): return np.array((sample_desc.rng.random() + 1) * 3., dtype=np.float32) def per_axis_sigma(sample_desc): return np.array([sigma(sample_desc) for _ in range(2)]) video_test_cases = [ (fn.gaussian_blur, { 'window_size': 3 }, []), (fn.gaussian_blur, {}, [ArgCb("window_size", window_size, True)]), (fn.gaussian_blur, {}, [ArgCb("window_size", per_axis_window_size, True)]), (fn.gaussian_blur, {}, [ArgCb("sigma", sigma, True)]), (fn.gaussian_blur, {}, [ ArgCb("window_size", per_axis_window_size, True), ArgCb("sigma", per_axis_sigma, True) ]), (fn.gaussian_blur, { 'dtype': types.FLOAT }, [ ArgCb("window_size", per_axis_window_size, False), ArgCb("sigma", per_axis_sigma, True) ]), ] yield from video_suite_helper(video_test_cases, expand_channels=True)
def test_video(): def small_angle(sample_desc): return np.array(sample_desc.rng.uniform(-44., 44.), dtype=np.float32) def random_angle(sample_desc): return np.array(sample_desc.rng.uniform(-180., 180.), dtype=np.float32) def random_output(sample_desc): return np.array( [sample_desc.rng.randint(300, 400), rng.randint(300, 400)]) video_test_cases = [ (dali.fn.rotate, { 'angle': 45. }, []), (dali.fn.rotate, {}, [ArgCb("angle", small_angle, False)]), (dali.fn.rotate, {}, [ArgCb("angle", random_angle, False)]), (dali.fn.rotate, {}, RotatePerFrameParamsProvider([ArgCb("angle", small_angle, True)])), (dali.fn.rotate, {}, RotatePerFrameParamsProvider([ArgCb("angle", random_angle, True)])), (dali.fn.rotate, {}, [ ArgCb("angle", small_angle, True), ArgCb("size", random_output, False) ]), ] rng = random.Random(42) video_cases = get_video_input_cases("FHWC", rng, larger_shape=(512, 287)) input_cases = [("FHWC", input_data) for input_data in video_cases] yield from sequence_suite_helper(rng, "F", input_cases, video_test_cases)
def test_per_frame(): def window_size(sample_desc): return np.array(2 * sample_desc.rng.randint(1, 15) + 1, dtype=np.int32) def per_axis_window_size(sample_desc): return np.array([window_size(sample_desc) for _ in range(2)]) def per_axis_smoothing_size(sample_desc): return np.array( [2 * sample_desc.rng.randint(0, 15) + 1 for _ in range(2)], dtype=np.int32) def per_axis_scale(sample_desc): def scale(sample_desc): k = 2 * sample_desc.rng.randint(0, 15) + 1 return np.array(2.**-k, dtype=np.float32) return np.array([scale(sample_desc) for _ in range(2)]) video_test_cases = [ (fn.laplacian, {}, []), (fn.laplacian, {}, [ArgCb("window_size", window_size, True)]), (fn.laplacian, {}, [ArgCb("window_size", per_axis_window_size, True)]), (fn.laplacian, { 'dtype': types.FLOAT }, [ArgCb("scale", per_axis_scale, True)]), (fn.laplacian, {}, [ ArgCb("window_size", per_axis_window_size, True), ArgCb("smoothing_size", per_axis_smoothing_size, True) ]), (fn.laplacian, {}, [ ArgCb("window_size", per_axis_window_size, True), ArgCb("smoothing_size", per_axis_smoothing_size, True), ArgCb("scale", per_axis_scale, True) ]), ] yield from video_suite_helper(video_test_cases, expand_channels=True)
def test_sequences(): np_rng = np.random.default_rng(12345) rng = random.Random(42) num_iters = 4 max_num_frames = 50 max_batch_size = 12 class TransformsParamsProvider(ParamsProvider): def unfold_output_layout(self, layout): unfolded = super().unfold_output_layout(layout) if unfolded == "**": return "" return unfolded def rand_range(limit): return range(rng.randint(1, limit) + 1) def mt(desc): return np.float32(np_rng.uniform(-20, 20, (2, 3))) def scale(desc): return np.array( [rng.randint(0, 5), rng.randint(-50, 20)], dtype=np.float32) def shift(desc): return np.array([rng.randint(-100, 200), rng.randint(-50, 20)], dtype=np.float32) def shear_angles(desc): return np.array( [rng.randint(-90, 90), rng.randint(-90, 90)], dtype=np.float32) def angle(desc): return np.array(rng.uniform(-180, 180), dtype=np.float32) def per_frame_input(frame_cb): return [[ np.array([frame_cb(None) for _ in rand_range(max_num_frames)], dtype=np.float32) for _ in rand_range(max_batch_size) ] for _ in range(num_iters)] test_cases = [ (fn.transforms.rotation, {}, TransformsParamsProvider([ArgCb("angle", angle, True)]), ["cpu"]), (fn.transforms.rotation, { 'reverse_order': True }, TransformsParamsProvider( [ArgCb("center", shift, True), ArgCb("angle", angle, False)]), ["cpu"]), (fn.transforms.scale, {}, TransformsParamsProvider( [ArgCb("scale", scale, True), ArgCb("center", shift, False)]), ["cpu"]), (fn.transforms.scale, { "center": np.array([-50, 100], dtype=np.float32) }, TransformsParamsProvider([ArgCb("scale", scale, True)]), ["cpu"]), (fn.transforms.translation, {}, TransformsParamsProvider([ArgCb("offset", shift, True)]), ["cpu"]), (fn.transforms.shear, {}, TransformsParamsProvider([ArgCb("angles", shear_angles, True)]), ["cpu"]), (fn.transforms.shear, {}, TransformsParamsProvider([ArgCb("shear", shift, True)]), ["cpu"]), (fn.transforms.combine, {}, TransformsParamsProvider([ArgCb(2, mt, True), ArgCb(1, mt, False)]), ["cpu"]), (fn.transforms.combine, {}, TransformsParamsProvider([ArgCb(1, mt, True)]), ["cpu"]), ] only_with_seq_input_cases = [ (fn.transforms.combine, {}, TransformsParamsProvider([ArgCb(1, mt, True), ArgCb(2, mt, True)]), ["cpu"]), (fn.transforms.combine, {}, TransformsParamsProvider([ArgCb(1, mt, False)]), ["cpu"]), (fn.transforms.translation, {}, TransformsParamsProvider([ArgCb("offset", shift, False)]), ["cpu"]), (fn.transforms.rotation, { 'reverse_order': True, "angle": 92. }, TransformsParamsProvider([]), ["cpu"]), ] seq_cases = test_cases + only_with_seq_input_cases main_input = ArgData(desc=ArgDesc(0, "F", "", "F**"), data=per_frame_input(mt)) yield from sequence_suite_helper(rng, [main_input], seq_cases, num_iters) # transform the test cases to test the transforms with per-frame args but: # 1. with the positional input that does not contain frames # 2. without the positional input for tested_fn, fixed_params, params_provider, devices in test_cases: [main_source, *rest_cbs] = params_provider.input_params if main_source.desc.expandable_prefix != "F": continue broadcast_0_pos_case_params = TransformsParamsProvider( [ArgCb(0, mt, False), *rest_cbs]) broadcast_0_pos_case = (tested_fn, fixed_params, broadcast_0_pos_case_params, devices) if any(source.desc.is_positional_arg for source in params_provider.input_params): cases = [broadcast_0_pos_case] else: no_pos_case_params = TransformsParamsProvider(rest_cbs) no_pos_input_case = (tested_fn, fixed_params, no_pos_case_params, devices) cases = [broadcast_0_pos_case, no_pos_input_case] per_frame_data = per_frame_input(main_source.cb) data_dim = len(per_frame_data[0][0].shape) assert data_dim > 0 data_layout = "F" + "*" * (data_dim - 1) main_input = ArgData(desc=ArgDesc(main_source.desc.name, "F", "", data_layout), data=per_frame_data) yield from sequence_suite_helper(rng, [main_input], cases, num_iters)
def test_video(): def brightness(sample_desc): return np.float32(2 * sample_desc.rng.random()) def brightness_shift(sample_desc): return np.float32(sample_desc.rng.random()) def contrast(sample_desc): return np.float32(2 * sample_desc.rng.random()) def contrast_center(sample_desc): return np.float32(sample_desc.rng.random()) video_test_cases = [ (fn.brightness, { 'dtype': types.INT32 }, [ArgCb("brightness", brightness, True)]), (fn.brightness, { 'dtype': types.UINT8 }, [ ArgCb("brightness_shift", brightness_shift, True), ArgCb("brightness", brightness, False) ]), (fn.contrast, { 'dtype': types.FLOAT }, [ArgCb("contrast", contrast, True)]), (fn.contrast, { 'dtype': types.FLOAT }, [ArgCb("contrast", contrast, True), ArgCb("contrast_center", contrast_center, False)]), (fn.contrast, { 'dtype': types.UINT8 }, [ArgCb("contrast_center", contrast_center, True)]), (fn.brightness_contrast, { 'dtype': types.UINT8 }, [ ArgCb("contrast", contrast, False), ArgCb("contrast_center", contrast_center, True), ArgCb("brightness", brightness, True) ]), (fn.brightness_contrast, {}, [ ArgCb("brightness", brightness, True), ArgCb("brightness_shift", brightness_shift, True), ArgCb("contrast", contrast, True), ArgCb("contrast_center", contrast_center, True) ]), ] yield from video_suite_helper(video_test_cases, test_channel_first=False)
def test_video(): rng = random.Random(42) def random_flip_mx(sample_desc): x, y = sample_desc.rng.choice([(-1, -1), (1, -1), (-1, 1)]) _, h, w, _ = sample_desc.sample.shape # assuming FHWC layout return np.array([[x, 0, 0 if x == 1 else w], [0, y, 0 if y == 1 else h], [0, 0, 1]], dtype=np.float32) def random_translate_mx(sample_desc): _, h, w, _ = sample_desc.sample.shape # assuming FHWC layout return np.array([[1, 0, sample_desc.rng.uniform(-w / 2, w / 2)], [0, 1, rng.uniform(-h / 2, h / 2)], [0, 0, 1]], dtype=np.float32) def random_scale_mx(sample_desc): def rand_scale(): return sample_desc.rng.uniform(0.25, 4) return np.array( [[rand_scale(), 0, 0], [0, rand_scale(), 0], [0, 0, 1]], dtype=np.float32) def random_rotate_mx(sample_desc): angle = math.radians(sample_desc.rng.uniform(-90, 90)) c = np.cos(angle) s = np.sin(angle) return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]], dtype=np.float32) def random_mx(sample_desc): m = np.eye(3, dtype=np.float32) for transformation in [ random_flip_mx, random_translate_mx, random_scale_mx, random_rotate_mx ]: if sample_desc.rng.choice([0, 1]): m = np.matmul(m, transformation(sample_desc)) return m[0:2, :] def output_size(sample_desc): _, h, w, _ = sample_desc.sample.shape # assuming FHWC layout rng = sample_desc.rng return np.array([h * rng.uniform(0.5, 2), w * rng.uniform(0.5, 2)], dtype=np.float32) video_test_cases = [ (fn.warp_affine, { "matrix": random_rotate_mx(SampleDesc(rng, 0, 0, 0, None))[0:2, :] }, []), (fn.warp_affine, {}, [ArgCb("matrix", random_mx, False)]), (fn.warp_affine, {}, [ArgCb("matrix", random_mx, True)]), (fn.warp_affine, {}, [ ArgCb("matrix", random_mx, False), ArgCb("size", output_size, False) ]), (fn.warp_affine, {}, [ArgCb("matrix", random_mx, True), ArgCb("size", output_size, False)]), (fn.warp_affine, {}, [ArgCb(1, random_mx, True, dest_device="cpu")]), (fn.warp_affine, {}, [ArgCb(1, random_mx, True, dest_device="gpu")], ["gpu"]), (fn.warp_affine, {}, [ArgCb(1, random_mx, False, dest_device="cpu")]), (fn.warp_affine, {}, [ArgCb(1, random_mx, False, dest_device="gpu")], ["gpu"]), ] yield from video_suite_helper(video_test_cases, test_channel_first=False, expand_channels=False, rng=rng)
def test_sequences(): rng = random.Random(42) np_rng = np.random.default_rng(12345) max_batch_size = 64 max_num_frames = 50 num_points = 30 num_iters = 4 def points(): return np.float32(np_rng.uniform(-100, 250, (num_points, 2))) def rand_range(limit): return range(rng.randint(1, limit) + 1) def m(sample_desc): angles = np_rng.uniform(-np.pi, np.pi, 2) scales = np_rng.uniform(0, 5, 2) c = np.cos(angles[0]) s = np.sin(angles[1]) return np.array([[c * scales[0], -s], [s, c * scales[1]]], dtype=np.float32) def t(sample_desc): return np.float32(np_rng.uniform(-100, 250, 2)) def mt(sample_desc): return np.append(m(sample_desc), t(sample_desc).reshape(-1, 1), axis=1) input_cases = [ (fn.coord_transform, {}, [ArgCb("M", m, True)]), (fn.coord_transform, {}, [ArgCb("T", t, True)]), (fn.coord_transform, {}, [ArgCb("MT", mt, True)]), (fn.coord_transform, {}, [ArgCb("MT", mt, False)]), (fn.coord_transform, {}, [ArgCb("M", m, True), ArgCb("T", t, True)]), (fn.coord_transform, {}, [ArgCb("M", m, False), ArgCb("T", t, True)]), ] input_seq_data = [[ np.array([points() for _ in rand_range(max_num_frames)], dtype=np.float32) for _ in rand_range(max_batch_size) ] for _ in range(num_iters)] main_input = ArgData(desc=ArgDesc(0, "F", "", "F**"), data=input_seq_data) yield from sequence_suite_helper(rng, [main_input], input_cases, num_iters) input_broadcast_cases = [ (fn.coord_transform, {}, [ArgCb(0, lambda _: points(), False, "cpu")], ["cpu"]), (fn.coord_transform, {}, [ArgCb(0, lambda _: points(), False, "gpu")], ["cpu"]), ] input_mt_data = [[ np.array([mt(None) for _ in rand_range(max_num_frames)], dtype=np.float32) for _ in rand_range(max_batch_size) ] for _ in range(num_iters)] main_input = ArgData(desc=ArgDesc("MT", "F", "", "F**"), data=input_mt_data) yield from sequence_suite_helper(rng, [main_input], input_broadcast_cases, num_iters)
def test_video(): def hue(sample_desc): return np.float32(360 * sample_desc.rng.random()) def saturation(sample_desc): return np.float32(sample_desc.rng.random()) def value(sample_desc): return np.float32(sample_desc.rng.random()) def contrast(sample_desc): return np.float32(2 * sample_desc.rng.random()) def brightness(sample_desc): return np.float32(2 * sample_desc.rng.random()) video_test_cases = [ (fn.hue, {}, [ArgCb("hue", hue, True)]), (fn.saturation, {}, [ArgCb("saturation", saturation, True)]), (fn.hsv, {}, [ ArgCb("hue", hue, True), ArgCb("saturation", saturation, True), ArgCb("value", value, True) ]), (fn.hsv, {}, [ ArgCb("hue", hue, False), ArgCb("saturation", saturation, True), ArgCb("value", value, False) ]), (fn.color_twist, {}, [ ArgCb("brightness", brightness, True), ArgCb("hue", hue, True), ArgCb("saturation", saturation, True), ArgCb("contrast", contrast, True), ]), (fn.color_twist, {}, [ArgCb("brightness", brightness, True), ArgCb("hue", hue, False)]), ] yield from video_suite_helper(video_test_cases, test_channel_first=False)