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)