def test_normalizepad_op_c(plot=False):
"""
Test NormalizePad in cpp transformations
"""
logger.info("Test Normalize in cpp")
mean = [121.0, 115.0, 100.0]
std = [70.0, 68.0, 71.0]
# define map operations
decode_op = c_vision.Decode()
normalizepad_op = c_vision.NormalizePad(mean, std)
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
data1 = data1.map(operations=decode_op, input_columns=["image"])
data1 = data1.map(operations=normalizepad_op, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
data2 = data2.map(operations=decode_op, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
image_de_normalized = item1["image"]
image_original = item2["image"]
image_np_normalized = normalizepad_np(image_original, mean, std)
mse = diff_mse(image_de_normalized, image_np_normalized)
logger.info("image_{}, mse: {}".format(num_iter + 1, mse))
assert mse < 0.01
if plot:
visualize_image(image_original, image_de_normalized, mse, image_np_normalized)
num_iter += 1
def test_rescale_op(plot=False):
"""
Test rescale
"""
logger.info("Test rescale")
data1 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
# define map operations
decode_op = vision.Decode()
rescale_op = vision.Rescale(1.0 / 255.0, -1.0)
# apply map operations on images
data1 = data1.map(operations=decode_op, input_columns=["image"])
data2 = data1.map(operations=rescale_op, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(
data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
image_original = item1["image"]
image_de_rescaled = item2["image"]
image_np_rescaled = get_rescaled(num_iter)
mse = diff_mse(image_de_rescaled, image_np_rescaled)
assert mse < 0.001 # rounding error
logger.info("image_{}, mse: {}".format(num_iter + 1, mse))
num_iter += 1
if plot:
visualize_image(image_original, image_de_rescaled, mse,
image_np_rescaled)
def test_random_vertical_op(plot=False):
"""
Test random_vertical with default probability
"""
logger.info("Test random_vertical")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
decode_op = c_vision.Decode()
random_vertical_op = c_vision.RandomVerticalFlip(1.0)
data1 = data1.map(input_columns=["image"], operations=decode_op)
data1 = data1.map(input_columns=["image"], operations=random_vertical_op)
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
data2 = data2.map(input_columns=["image"], operations=decode_op)
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
# with the seed value, we can only guarantee the first number generated
if num_iter > 0:
break
image_v_flipped = item1["image"]
image = item2["image"]
image_v_flipped_2 = v_flip(image)
mse = diff_mse(image_v_flipped, image_v_flipped_2)
assert mse == 0
logger.info("image_{}, mse: {}".format(num_iter + 1, mse))
num_iter += 1
if plot:
visualize_image(image, image_v_flipped, mse, image_v_flipped_2)
def test_soft_dvpp_decode_resize_jpeg_supplement(plot=False):
"""
Test SoftDvppDecodeResizeJpeg op
"""
logger.info("test_random_decode_resize_op")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
decode_op = vision.Decode()
resize_op = vision.Resize(1134)
data1 = data1.map(operations=[decode_op, resize_op], input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
soft_dvpp_decode_resize_op = vision.SoftDvppDecodeResizeJpeg(1134)
data2 = data2.map(operations=soft_dvpp_decode_resize_op, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
if num_iter > 0:
break
image1 = item1["image"]
image2 = item2["image"]
mse = diff_mse(image1, image2)
assert mse <= 0.02
logger.info("random_crop_decode_resize_op_{}, mse: {}".format(num_iter + 1, mse))
if plot:
visualize_image(image1, image2, mse)
num_iter += 1
def test_soft_dvpp_decode_random_crop_resize_jpeg(plot=False):
"""
Test SoftDvppDecodeRandomCropResizeJpeg op
"""
logger.info("test_random_decode_resize_op")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
random_crop_decode_resize_op = vision.RandomCropDecodeResize((256, 512), (1, 1), (0.5, 0.5))
data1 = data1.map(input_columns=["image"], operations=random_crop_decode_resize_op)
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
soft_dvpp_random_crop_decode_resize_op = vision.SoftDvppDecodeRandomCropResizeJpeg((256, 512), (1, 1), (0.5, 0.5))
data2 = data2.map(input_columns=["image"], operations=soft_dvpp_random_crop_decode_resize_op)
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
if num_iter > 0:
break
image1 = item1["image"]
image2 = item2["image"]
mse = diff_mse(image1, image2)
assert mse <= 0.06
logger.info("random_crop_decode_resize_op_{}, mse: {}".format(num_iter + 1, mse))
if plot:
visualize_image(image1, image2, mse)
num_iter += 1
def test_random_crop_decode_resize_op(plot=False):
"""
Test RandomCropDecodeResize op
"""
logger.info("test_random_decode_resize_op")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
decode_op = vision.Decode()
random_crop_decode_resize_op = vision.RandomCropDecodeResize((256, 512), (1, 1), (0.5, 0.5))
data1 = data1.map(operations=random_crop_decode_resize_op, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
random_crop_resize_op = vision.RandomResizedCrop((256, 512), (1, 1), (0.5, 0.5))
data2 = data2.map(operations=decode_op, input_columns=["image"])
data2 = data2.map(operations=random_crop_resize_op, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
if num_iter > 0:
break
image1 = item1["image"]
image2 = item2["image"]
mse = diff_mse(image1, image2)
assert mse == 0
logger.info("random_crop_decode_resize_op_{}, mse: {}".format(num_iter + 1, mse))
if plot:
visualize_image(image1, image2, mse)
num_iter += 1
def util_test_random_color_adjust_op(brightness=(1, 1), contrast=(1, 1), saturation=(1, 1), hue=(0, 0), plot=False):
"""
Util function that tests RandomColorAdjust for a specific argument
"""
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
decode_op = c_vision.Decode()
random_adjust_op = c_vision.RandomColorAdjust(brightness=brightness, contrast=contrast, saturation=saturation,
hue=hue)
ctrans = [decode_op,
random_adjust_op,
]
data1 = data1.map(operations=ctrans, input_columns=["image"])
# Second dataset
transforms = [
py_vision.Decode(),
py_vision.RandomColorAdjust(brightness=brightness, contrast=contrast, saturation=saturation,
hue=hue),
py_vision.ToTensor()
]
transform = mindspore.dataset.transforms.py_transforms.Compose(transforms)
data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
data2 = data2.map(operations=transform, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
num_iter += 1
c_image = item1["image"]
py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
logger.info("shape of c_image: {}".format(c_image.shape))
logger.info("shape of py_image: {}".format(py_image.shape))
logger.info("dtype of c_image: {}".format(c_image.dtype))
logger.info("dtype of py_image: {}".format(py_image.dtype))
mse = diff_mse(c_image, py_image)
logger.info("mse is {}".format(mse))
logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse))
assert mse < 0.01
if plot:
visualize_image(c_image, py_image, mse)
def test_cut_out_op(plot=False):
"""
Test Cutout
"""
logger.info("test_cut_out")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
transforms_1 = [f.Decode(), f.ToTensor(), f.RandomErasing(value='random')]
transform_1 = mindspore.dataset.transforms.py_transforms.Compose(
transforms_1)
data1 = data1.map(operations=transform_1, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
decode_op = c.Decode()
cut_out_op = c.CutOut(80)
transforms_2 = [decode_op, cut_out_op]
data2 = data2.map(operations=transforms_2, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(
data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
num_iter += 1
image_1 = (item1["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
# C image doesn't require transpose
image_2 = item2["image"]
logger.info("shape of image_1: {}".format(image_1.shape))
logger.info("shape of image_2: {}".format(image_2.shape))
logger.info("dtype of image_1: {}".format(image_1.dtype))
logger.info("dtype of image_2: {}".format(image_2.dtype))
mse = diff_mse(image_1, image_2)
if plot:
visualize_image(image_1, image_2, mse)
def test_normalize_op_py(plot=False):
"""
Test Normalize in python transformations
"""
logger.info("Test Normalize in python")
mean = [0.475, 0.45, 0.392]
std = [0.275, 0.267, 0.278]
# define map operations
transforms = [py_vision.Decode(), py_vision.ToTensor()]
transform = mindspore.dataset.transforms.py_transforms.Compose(transforms)
normalize_op = py_vision.Normalize(mean, std)
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
data1 = data1.map(operations=transform, input_columns=["image"])
data1 = data1.map(operations=normalize_op, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
data2 = data2.map(operations=transform, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(
data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
image_de_normalized = (item1["image"].transpose(1, 2, 0) * 255).astype(
np.uint8)
image_np_normalized = (
normalize_np(item2["image"].transpose(1, 2, 0), mean, std) *
255).astype(np.uint8)
image_original = (item2["image"].transpose(1, 2, 0) * 255).astype(
np.uint8)
mse = diff_mse(image_de_normalized, image_np_normalized)
logger.info("image_{}, mse: {}".format(num_iter + 1, mse))
assert mse < 0.01
if plot:
visualize_image(image_original, image_de_normalized, mse,
image_np_normalized)
num_iter += 1
def test_random_erasing_op(plot=False):
"""
Test RandomErasing and Cutout
"""
logger.info("test_random_erasing")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
transforms_1 = [
vision.Decode(),
vision.ToTensor(),
vision.RandomErasing(value='random')
]
transform_1 = vision.ComposeOp(transforms_1)
data1 = data1.map(input_columns=["image"], operations=transform_1())
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
transforms_2 = [vision.Decode(), vision.ToTensor(), vision.Cutout(80)]
transform_2 = vision.ComposeOp(transforms_2)
data2 = data2.map(input_columns=["image"], operations=transform_2())
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(),
data2.create_dict_iterator()):
num_iter += 1
image_1 = (item1["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
image_2 = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
logger.info("shape of image_1: {}".format(image_1.shape))
logger.info("shape of image_2: {}".format(image_2.shape))
logger.info("dtype of image_1: {}".format(image_1.dtype))
logger.info("dtype of image_2: {}".format(image_2.dtype))
mse = diff_mse(image_1, image_2)
if plot:
visualize_image(image_1, image_2, mse)
def test_random_rotation_op_py(plot=False):
"""
Test RandomRotation in python transformations op
"""
logger.info("test_random_rotation_op_py")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, shuffle=False)
# use [90, 90] to force rotate 90 degrees, expand is set to be True to match output size
transform1 = mindspore.dataset.transforms.py_transforms.Compose([
py_vision.Decode(),
py_vision.RandomRotation((90, 90), expand=True),
py_vision.ToTensor()
])
data1 = data1.map(operations=transform1, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
transform2 = mindspore.dataset.transforms.py_transforms.Compose(
[py_vision.Decode(), py_vision.ToTensor()])
data2 = data2.map(operations=transform2, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(
data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
if num_iter > 0:
break
rotation_de = (item1["image"].transpose(1, 2, 0) * 255).astype(
np.uint8)
original = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
logger.info("shape before rotate: {}".format(original.shape))
rotation_cv = cv2.rotate(original, cv2.ROTATE_90_COUNTERCLOCKWISE)
mse = diff_mse(rotation_de, rotation_cv)
logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse))
assert mse == 0
num_iter += 1
if plot:
visualize_image(original, rotation_de, mse, rotation_cv)
def test_random_horizontal_op(plot=False):
"""
Test RandomHorizontalFlip op
"""
logger.info("test_random_horizontal_op")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
decode_op = c_vision.Decode()
random_horizontal_op = c_vision.RandomHorizontalFlip(1.0)
data1 = data1.map(operations=decode_op, input_columns=["image"])
data1 = data1.map(operations=random_horizontal_op, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
data2 = data2.map(operations=decode_op, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(
data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
# with the seed value, we can only guarantee the first number generated
if num_iter > 0:
break
image_h_flipped = item1["image"]
image = item2["image"]
image_h_flipped_2 = h_flip(image)
mse = diff_mse(image_h_flipped, image_h_flipped_2)
assert mse == 0
logger.info("image_{}, mse: {}".format(num_iter + 1, mse))
num_iter += 1
if plot:
visualize_image(image, image_h_flipped, mse, image_h_flipped_2)
def test_random_crop_decode_resize_op(plot=False):
"""
Test RandomCropDecodeResize op
"""
logger.info("test_random_decode_resize_op")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
decode_op = vision.Decode()
random_crop_decode_resize_op = vision.RandomCropDecodeResize(
(256, 512), (1, 1), (0.5, 0.5))
data1 = data1.map(input_columns=["image"],
operations=random_crop_decode_resize_op)
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
data2 = data2.map(input_columns=["image"], operations=decode_op)
num_iter = 0
for item1, item2 in zip(data1.create_dict_iterator(),
data2.create_dict_iterator()):
if num_iter > 0:
break
crop_and_resize_de = item1["image"]
original = item2["image"]
crop_and_resize_cv = cv2.resize(original, (512, 256))
mse = diff_mse(crop_and_resize_de, crop_and_resize_cv)
logger.info("random_crop_decode_resize_op_{}, mse: {}".format(
num_iter + 1, mse))
if plot:
visualize_image(original, crop_and_resize_de, mse,
crop_and_resize_cv)
num_iter += 1
def test_random_rotation_op_c(plot=False):
"""
Test RandomRotation in c++ transformations op
"""
logger.info("test_random_rotation_op_c")
# First dataset
data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, shuffle=False)
decode_op = c_vision.Decode()
# use [90, 90] to force rotate 90 degrees, expand is set to be True to match output size
random_rotation_op = c_vision.RandomRotation((90, 90), expand=True)
data1 = data1.map(operations=decode_op, input_columns=["image"])
data1 = data1.map(operations=random_rotation_op, input_columns=["image"])
# Second dataset
data2 = ds.TFRecordDataset(DATA_DIR,
SCHEMA_DIR,
columns_list=["image"],
shuffle=False)
data2 = data2.map(operations=decode_op, input_columns=["image"])
num_iter = 0
for item1, item2 in zip(
data1.create_dict_iterator(num_epochs=1, output_numpy=True),
data2.create_dict_iterator(num_epochs=1, output_numpy=True)):
if num_iter > 0:
break
rotation_de = item1["image"]
original = item2["image"]
logger.info("shape before rotate: {}".format(original.shape))
rotation_cv = cv2.rotate(original, cv2.ROTATE_90_COUNTERCLOCKWISE)
mse = diff_mse(rotation_de, rotation_cv)
logger.info("random_rotation_op_{}, mse: {}".format(num_iter + 1, mse))
assert mse == 0
num_iter += 1
if plot:
visualize_image(original, rotation_de, mse, rotation_cv)