remove local defined mse and add missing mse/md5 validation

tests/ut/python/dataset/test_autocontrast.py

@@ -20,7 +20,7 @@ import numpy as np
 import mindspore.dataset.engine as de
 import mindspore.dataset.transforms.vision.py_transforms as F
 from mindspore import log as logger
-from util import visualize_list
+from util import visualize_list, diff_mse
 
 DATA_DIR = "../data/dataset/testImageNetData/train/"
 
@@ -75,7 +75,7 @@ def test_auto_contrast(plot=False):
     num_samples = images_original.shape[0]
     mse = np.zeros(num_samples)
     for i in range(num_samples):
-        mse[i] = np.mean((images_auto_contrast[i] - images_original[i]) ** 2)
+        mse[i] = diff_mse(images_auto_contrast[i], images_original[i])
     logger.info("MSE= {}".format(str(np.mean(mse))))
 
     if plot:

tests/ut/python/dataset/test_cut_out.py

@@ -21,11 +21,13 @@ import mindspore.dataset as ds
 import mindspore.dataset.transforms.vision.c_transforms as c
 import mindspore.dataset.transforms.vision.py_transforms as f
 from mindspore import log as logger
-from util import visualize_image, diff_mse
+from util import visualize_image, visualize_list, diff_mse, save_and_check_md5, \
+    config_get_set_seed, config_get_set_num_parallel_workers
 
 DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"]
 SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json"
 
+GENERATE_GOLDEN = False
 
 def test_cut_out_op(plot=False):
     """
@@ -34,7 +36,7 @@ def test_cut_out_op(plot=False):
     logger.info("test_cut_out")
 
     # First dataset
-    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"])
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
 
     transforms_1 = [
         f.Decode(),
@@ -45,7 +47,7 @@ def test_cut_out_op(plot=False):
     data1 = data1.map(input_columns=["image"], operations=transform_1())
 
     # Second dataset
-    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"])
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
     decode_op = c.Decode()
     cut_out_op = c.CutOut(80)
 
@@ -74,25 +76,24 @@ def test_cut_out_op(plot=False):
             visualize_image(image_1, image_2, mse)
 
 
-def test_cut_out_op_multicut():
+def test_cut_out_op_multicut(plot=False):
     """
     Test Cutout
     """
     logger.info("test_cut_out")
 
     # First dataset
-    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"])
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
 
     transforms_1 = [
         f.Decode(),
         f.ToTensor(),
-        f.RandomErasing(value='random')
     ]
     transform_1 = f.ComposeOp(transforms_1)
     data1 = data1.map(input_columns=["image"], operations=transform_1())
 
     # Second dataset
-    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"])
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
     decode_op = c.Decode()
     cut_out_op = c.CutOut(80, num_patches=10)
 
@@ -104,19 +105,107 @@ def test_cut_out_op_multicut():
     data2 = data2.map(input_columns=["image"], operations=transforms_2)
 
     num_iter = 0
+    image_list_1, image_list_2 = [], []
+    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)
+        # C image doesn't require transpose
+        image_2 = item2["image"]
+        image_list_1.append(image_1)
+        image_list_2.append(image_2)
+
+        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))
+    if plot:
+        visualize_list(image_list_1, image_list_2)
+
+
+def test_cut_out_md5():
+    """
+    Test Cutout with md5 check
+    """
+    logger.info("test_cut_out_md5")
+    original_seed = config_get_set_seed(2)
+    original_num_parallel_workers = config_get_set_num_parallel_workers(1)
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    decode_op = c.Decode()
+    cut_out_op = c.CutOut(100)
+    data1 = data1.map(input_columns=["image"], operations=decode_op)
+    data1 = data1.map(input_columns=["image"], operations=cut_out_op)
+
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        f.Decode(),
+        f.ToTensor(),
+        f.Cutout(100)
+    ]
+    transform = f.ComposeOp(transforms)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+
+    # Compare with expected md5 from images
+    filename1 = "cut_out_01_c_result.npz"
+    save_and_check_md5(data1, filename1, generate_golden=GENERATE_GOLDEN)
+    filename2 = "cut_out_01_py_result.npz"
+    save_and_check_md5(data2, filename2, generate_golden=GENERATE_GOLDEN)
+
+    # Restore config
+    ds.config.set_seed(original_seed)
+    ds.config.set_num_parallel_workers(original_num_parallel_workers)
+
+
+def test_cut_out_comp(plot=False):
+    """
+    Test Cutout with c++ and python op comparison
+    """
+    logger.info("test_cut_out_comp")
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+
+    transforms_1 = [
+        f.Decode(),
+        f.ToTensor(),
+        f.Cutout(200)
+    ]
+    transform_1 = f.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 = [
+        c.Decode(),
+        c.CutOut(200)
+    ]
+
+    data2 = data2.map(input_columns=["image"], operations=transforms_2)
+
+    num_iter = 0
+    image_list_1, image_list_2 = [], []
     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)
         # C image doesn't require transpose
         image_2 = item2["image"]
+        image_list_1.append(image_1)
+        image_list_2.append(image_2)
 
         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))
+    if plot:
+        visualize_list(image_list_1, image_list_2, visualize_mode=2)
 
 
 if __name__ == "__main__":
     test_cut_out_op(plot=True)
-    test_cut_out_op_multicut()
+    test_cut_out_op_multicut(plot=True)
+    test_cut_out_md5()
+    test_cut_out_comp(plot=True)

tests/ut/python/dataset/test_equalize.py

@@ -20,10 +20,11 @@ import numpy as np
 import mindspore.dataset.engine as de
 import mindspore.dataset.transforms.vision.py_transforms as F
 from mindspore import log as logger
-from util import visualize_list
+from util import visualize_list, diff_mse, save_and_check_md5
 
 DATA_DIR = "../data/dataset/testImageNetData/train/"
 
+GENERATE_GOLDEN = False
 
 def test_equalize(plot=False):
     """
@@ -75,12 +76,31 @@ def test_equalize(plot=False):
     num_samples = images_original.shape[0]
     mse = np.zeros(num_samples)
     for i in range(num_samples):
-        mse[i] = np.mean((images_equalize[i] - images_original[i]) ** 2)
+        mse[i] = diff_mse(images_equalize[i], images_original[i])
     logger.info("MSE= {}".format(str(np.mean(mse))))
 
     if plot:
         visualize_list(images_original, images_equalize)
 
 
+def test_equalize_md5():
+    """
+    Test Equalize with md5 check
+    """
+    logger.info("Test Equalize")
+
+    # First dataset
+    data1 = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
+    transforms = F.ComposeOp([F.Decode(),
+                              F.Equalize(),
+                              F.ToTensor()])
+
+    data1 = data1.map(input_columns="image", operations=transforms())
+    # Compare with expected md5 from images
+    filename = "equalize_01_result.npz"
+    save_and_check_md5(data1, filename, generate_golden=GENERATE_GOLDEN)
+
+
 if __name__ == "__main__":
     test_equalize(plot=True)
+    test_equalize_md5()

tests/ut/python/dataset/test_five_crop.py

@@ -20,11 +20,12 @@ import numpy as np
 import mindspore.dataset as ds
 import mindspore.dataset.transforms.vision.py_transforms as vision
 from mindspore import log as logger
-from util import visualize_list
+from util import visualize_list, save_and_check_md5
 
 DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"]
 SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json"
 
+GENERATE_GOLDEN = False
 
 def test_five_crop_op(plot=False):
     """
@@ -63,7 +64,7 @@ def test_five_crop_op(plot=False):
         logger.info("dtype of image_1: {}".format(image_1.dtype))
         logger.info("dtype of image_2: {}".format(image_2.dtype))
         if plot:
-            visualize_list(np.array([image_1]*10), (image_2 * 255).astype(np.uint8).transpose(0, 2, 3, 1))
+            visualize_list(np.array([image_1]*5), (image_2 * 255).astype(np.uint8).transpose(0, 2, 3, 1))
 
         # The output data should be of a 4D tensor shape, a stack of 5 images.
         assert len(image_2.shape) == 4
@@ -93,6 +94,27 @@ def test_five_crop_error_msg():
     assert error_msg in str(info.value)
 
 
+def test_five_crop_md5():
+    """
+    Test FiveCrop with md5 check
+    """
+    logger.info("test_five_crop_md5")
+
+    # First dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        vision.Decode(),
+        vision.FiveCrop(100),
+        lambda images: np.stack([vision.ToTensor()(image) for image in images])  # 4D stack of 5 images
+    ]
+    transform = vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+    # Compare with expected md5 from images
+    filename = "five_crop_01_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+
 if __name__ == "__main__":
     test_five_crop_op(plot=True)
     test_five_crop_error_msg()
+    test_five_crop_md5()

tests/ut/python/dataset/test_invert.py

@@ -20,10 +20,11 @@ import numpy as np
 import mindspore.dataset.engine as de
 import mindspore.dataset.transforms.vision.py_transforms as F
 from mindspore import log as logger
-from util import visualize_list
+from util import visualize_list, save_and_check_md5
 
 DATA_DIR = "../data/dataset/testImageNetData/train/"
 
+GENERATE_GOLDEN = False
 
 def test_invert(plot=False):
     """
@@ -82,5 +83,25 @@ def test_invert(plot=False):
         visualize_list(images_original, images_invert)
 
 
+def test_invert_md5():
+    """
+    Test Invert with md5 check
+    """
+    logger.info("Test Invert with md5 check")
+
+    # Generate dataset
+    ds = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
+
+    transforms_invert = F.ComposeOp([F.Decode(),
+                                     F.Invert(),
+                                     F.ToTensor()])
+
+    data = ds.map(input_columns="image", operations=transforms_invert())
+    # Compare with expected md5 from images
+    filename = "invert_01_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+
 if __name__ == "__main__":
     test_invert(plot=True)
+    test_invert_md5()

tests/ut/python/dataset/test_linear_transformation.py

@@ -73,12 +73,12 @@ def test_linear_transformation_op(plot=False):
     if plot:
         visualize_list(image, image_transformed)
 
-def test_linear_transformation_md5_01():
+def test_linear_transformation_md5():
     """
     Test LinearTransformation op: valid params (transformation_matrix, mean_vector)
     Expected to pass
     """
-    logger.info("test_linear_transformation_md5_01")
+    logger.info("test_linear_transformation_md5")
 
     # Initialize parameters
     height = 50
@@ -102,12 +102,12 @@ def test_linear_transformation_md5_01():
     filename = "linear_transformation_01_result.npz"
     save_and_check_md5(data1, filename, generate_golden=GENERATE_GOLDEN)
 
-def test_linear_transformation_md5_02():
+def test_linear_transformation_exception_01():
     """
     Test LinearTransformation op: transformation_matrix is not provided
     Expected to raise ValueError
     """
-    logger.info("test_linear_transformation_md5_02")
+    logger.info("test_linear_transformation_exception_01")
 
     # Initialize parameters
     height = 50
@@ -130,12 +130,12 @@ def test_linear_transformation_md5_02():
         logger.info("Got an exception in DE: {}".format(str(e)))
         assert "not provided" in str(e)
 
-def test_linear_transformation_md5_03():
+def test_linear_transformation_exception_02():
     """
     Test LinearTransformation op: mean_vector is not provided
     Expected to raise ValueError
     """
-    logger.info("test_linear_transformation_md5_03")
+    logger.info("test_linear_transformation_exception_02")
 
     # Initialize parameters
     height = 50
@@ -158,12 +158,12 @@ def test_linear_transformation_md5_03():
         logger.info("Got an exception in DE: {}".format(str(e)))
         assert "not provided" in str(e)
 
-def test_linear_transformation_md5_04():
+def test_linear_transformation_exception_03():
     """
     Test LinearTransformation op: transformation_matrix is not a square matrix
     Expected to raise ValueError
     """
-    logger.info("test_linear_transformation_md5_04")
+    logger.info("test_linear_transformation_exception_03")
 
     # Initialize parameters
     height = 50
@@ -187,12 +187,12 @@ def test_linear_transformation_md5_04():
         logger.info("Got an exception in DE: {}".format(str(e)))
         assert "square matrix" in str(e)
 
-def test_linear_transformation_md5_05():
+def test_linear_transformation_exception_04():
     """
     Test LinearTransformation op: mean_vector does not match dimension of transformation_matrix
     Expected to raise ValueError
     """
-    logger.info("test_linear_transformation_md5_05")
+    logger.info("test_linear_transformation_exception_04")
 
     # Initialize parameters
     height = 50
@@ -217,9 +217,9 @@ def test_linear_transformation_md5_05():
         assert "should match" in str(e)
 
 if __name__ == '__main__':
-    test_linear_transformation_op(True)
-    test_linear_transformation_md5_01()
-    test_linear_transformation_md5_02()
-    test_linear_transformation_md5_03()
-    test_linear_transformation_md5_04()
-    test_linear_transformation_md5_05()
+    test_linear_transformation_op(plot=True)
+    test_linear_transformation_md5()
+    test_linear_transformation_exception_01()
+    test_linear_transformation_exception_02()
+    test_linear_transformation_exception_03()
+    test_linear_transformation_exception_04()

tests/ut/python/dataset/test_pad.py

@@ -21,11 +21,12 @@ import mindspore.dataset as ds
 import mindspore.dataset.transforms.vision.c_transforms as c_vision
 import mindspore.dataset.transforms.vision.py_transforms as py_vision
 from mindspore import log as logger
-from util import diff_mse
+from util import diff_mse, save_and_check_md5
 
 DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"]
 SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json"
 
+GENERATE_GOLDEN = False
 
 def test_pad_op():
     """
@@ -116,6 +117,39 @@ def test_pad_grayscale():
         assert shape1[0:1] == shape2[0:1]
 
 
+def test_pad_md5():
+    """
+    Test Pad with md5 check
+    """
+    logger.info("test_pad_md5")
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    decode_op = c_vision.Decode()
+    pad_op = c_vision.Pad(150)
+    ctrans = [decode_op,
+              pad_op,
+              ]
+
+    data1 = data1.map(input_columns=["image"], operations=ctrans)
+
+    # Second dataset
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    pytrans = [
+        py_vision.Decode(),
+        py_vision.Pad(150),
+        py_vision.ToTensor(),
+    ]
+    transform = py_vision.ComposeOp(pytrans)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+    # Compare with expected md5 from images
+    filename1 = "pad_01_c_result.npz"
+    save_and_check_md5(data1, filename1, generate_golden=GENERATE_GOLDEN)
+    filename2 = "pad_01_py_result.npz"
+    save_and_check_md5(data2, filename2, generate_golden=GENERATE_GOLDEN)
+
+
 if __name__ == "__main__":
     test_pad_op()
     test_pad_grayscale()
+    test_pad_md5()

tests/ut/python/dataset/test_random_color.py

@@ -17,13 +17,16 @@ Testing RandomColor op in DE
 """
 import numpy as np
 
+import mindspore.dataset as ds
 import mindspore.dataset.engine as de
 import mindspore.dataset.transforms.vision.py_transforms as F
 from mindspore import log as logger
-from util import visualize_list
+from util import visualize_list, diff_mse, save_and_check_md5, \
+    config_get_set_seed, config_get_set_num_parallel_workers
 
 DATA_DIR = "../data/dataset/testImageNetData/train/"
 
+GENERATE_GOLDEN = False
 
 def test_random_color(degrees=(0.1, 1.9), plot=False):
     """
@@ -32,14 +35,14 @@ def test_random_color(degrees=(0.1, 1.9), plot=False):
     logger.info("Test RandomColor")
 
     # Original Images
-    ds = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
+    data = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
 
     transforms_original = F.ComposeOp([F.Decode(),
                                        F.Resize((224, 224)),
                                        F.ToTensor()])
 
-    ds_original = ds.map(input_columns="image",
-                         operations=transforms_original())
+    ds_original = data.map(input_columns="image",
+                           operations=transforms_original())
 
     ds_original = ds_original.batch(512)
 
@@ -52,15 +55,15 @@ def test_random_color(degrees=(0.1, 1.9), plot=False):
                                         axis=0)
 
             # Random Color Adjusted Images
-    ds = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
+    data = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
 
     transforms_random_color = F.ComposeOp([F.Decode(),
                                            F.Resize((224, 224)),
                                            F.RandomColor(degrees=degrees),
                                            F.ToTensor()])
 
-    ds_random_color = ds.map(input_columns="image",
-                             operations=transforms_random_color())
+    ds_random_color = data.map(input_columns="image",
+                               operations=transforms_random_color())
 
     ds_random_color = ds_random_color.batch(512)
 
@@ -75,14 +78,40 @@ def test_random_color(degrees=(0.1, 1.9), plot=False):
     num_samples = images_original.shape[0]
     mse = np.zeros(num_samples)
     for i in range(num_samples):
-        mse[i] = np.mean((images_random_color[i] - images_original[i]) ** 2)
+        mse[i] = diff_mse(images_random_color[i], images_original[i])
     logger.info("MSE= {}".format(str(np.mean(mse))))
 
     if plot:
         visualize_list(images_original, images_random_color)
 
 
+def test_random_color_md5():
+    """
+    Test RandomColor with md5 check
+    """
+    logger.info("Test RandomColor with md5 check")
+    original_seed = config_get_set_seed(10)
+    original_num_parallel_workers = config_get_set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = de.ImageFolderDatasetV2(dataset_dir=DATA_DIR, shuffle=False)
+
+    transforms = F.ComposeOp([F.Decode(),
+                              F.RandomColor((0.5, 1.5)),
+                              F.ToTensor()])
+
+    data = data.map(input_columns="image", operations=transforms())
+    # Compare with expected md5 from images
+    filename = "random_color_01_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+    # Restore configuration
+    ds.config.set_seed(original_seed)
+    ds.config.set_num_parallel_workers((original_num_parallel_workers))
+
+
 if __name__ == "__main__":
     test_random_color()
     test_random_color(plot=True)
     test_random_color(degrees=(0.5, 1.5), plot=True)
+    test_random_color_md5()