def test_ten_crop_invalid_size_error_msg(): """ Tests TenCrop error message when the size arg is not positive """ logger.info("test_ten_crop_invalid_size_error_msg") with pytest.raises(ValueError) as info: _ = [ vision.Decode(), vision.TenCrop(0), lambda images: np.stack( [vision.ToTensor()(image) for image in images]) # 4D stack of 10 images ] error_msg = "Input is not within the required interval of (1 to 16777216)." assert error_msg == str(info.value) with pytest.raises(ValueError) as info: _ = [ vision.Decode(), vision.TenCrop(-10), lambda images: np.stack( [vision.ToTensor()(image) for image in images]) # 4D stack of 10 images ] assert error_msg == str(info.value)
def test_random_crop_op_py(plot=False): """ Test RandomCrop op in py transforms """ logger.info("test_random_crop_op_py") # First dataset data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms1 = [ py_vision.Decode(), py_vision.RandomCrop([512, 512], [200, 200, 200, 200]), py_vision.ToTensor() ] transform1 = mindspore.dataset.transforms.py_transforms.Compose(transforms1) data1 = data1.map(operations=transform1, input_columns=["image"]) # Second dataset # Second dataset for comparison data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms2 = [ py_vision.Decode(), py_vision.ToTensor() ] transform2 = mindspore.dataset.transforms.py_transforms.Compose(transforms2) data2 = data2.map(operations=transform2, input_columns=["image"]) crop_images = [] original_images = [] 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)): crop = (item1["image"].transpose(1, 2, 0) * 255).astype(np.uint8) original = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) crop_images.append(crop) original_images.append(original) if plot: visualize_list(original_images, crop_images)
def test_auto_contrast_invalid_cutoff_param_py(): """ Test AutoContrast python Op with invalid cutoff parameter """ logger.info("Test AutoContrast python Op with invalid cutoff parameter") try: data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) data_set = data_set.map(operations=[ mindspore.dataset.transforms.py_transforms.Compose([ F.Decode(), F.Resize((224, 224)), F.AutoContrast(cutoff=-10.0), F.ToTensor() ]) ], input_columns=["image"]) except ValueError as error: logger.info("Got an exception in DE: {}".format(str(error))) assert "Input cutoff is not within the required interval of [0, 50)." in str( error) try: data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) data_set = data_set.map(operations=[ mindspore.dataset.transforms.py_transforms.Compose([ F.Decode(), F.Resize((224, 224)), F.AutoContrast(cutoff=120.0), F.ToTensor() ]) ], input_columns=["image"]) except ValueError as error: logger.info("Got an exception in DE: {}".format(str(error))) assert "Input cutoff is not within the required interval of [0, 50)." in str( error)
def test_auto_contrast_invalid_ignore_param_py(): """ Test AutoContrast python Op with invalid ignore parameter """ logger.info("Test AutoContrast python Op with invalid ignore parameter") try: data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) data_set = data_set.map(operations=[ mindspore.dataset.transforms.py_transforms.Compose([ F.Decode(), F.Resize((224, 224)), F.AutoContrast(ignore=255.5), F.ToTensor() ]) ], input_columns=["image"]) except TypeError as error: logger.info("Got an exception in DE: {}".format(str(error))) assert "Argument ignore with value 255.5 is not of type" in str(error) try: data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) data_set = data_set.map(operations=[ mindspore.dataset.transforms.py_transforms.Compose([ F.Decode(), F.Resize((224, 224)), F.AutoContrast(ignore=(10, 100)), F.ToTensor() ]) ], input_columns=["image"]) except TypeError as error: logger.info("Got an exception in DE: {}".format(str(error))) assert "Argument ignore with value (10,100) is not of type" in str( error)
def test_random_color_py(degrees=(0.1, 1.9), plot=False): """ Test Python RandomColor """ logger.info("Test RandomColor") # Original Images data = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_original = mindspore.dataset.transforms.py_transforms.Compose( [F.Decode(), F.Resize((224, 224)), F.ToTensor()]) ds_original = data.map(operations=transforms_original, input_columns="image") ds_original = ds_original.batch(512) for idx, (image, _) in enumerate(ds_original): if idx == 0: images_original = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_original = np.append(images_original, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) # Random Color Adjusted Images data = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_random_color = mindspore.dataset.transforms.py_transforms.Compose( [ F.Decode(), F.Resize((224, 224)), F.RandomColor(degrees=degrees), F.ToTensor() ]) ds_random_color = data.map(operations=transforms_random_color, input_columns="image") ds_random_color = ds_random_color.batch(512) for idx, (image, _) in enumerate(ds_random_color): if idx == 0: images_random_color = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_random_color = np.append(images_random_color, np.transpose( image.asnumpy(), (0, 2, 3, 1)), axis=0) num_samples = images_original.shape[0] mse = np.zeros(num_samples) for i in range(num_samples): 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_equalize_py(plot=False): """ Test Equalize py op """ logger.info("Test Equalize") # Original Images data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_original = mindspore.dataset.transforms.py_transforms.Compose( [F.Decode(), F.Resize((224, 224)), F.ToTensor()]) ds_original = data_set.map(operations=transforms_original, input_columns="image") ds_original = ds_original.batch(512) for idx, (image, _) in enumerate(ds_original): if idx == 0: images_original = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_original = np.append(images_original, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) # Color Equalized Images data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_equalize = mindspore.dataset.transforms.py_transforms.Compose( [F.Decode(), F.Resize((224, 224)), F.Equalize(), F.ToTensor()]) ds_equalize = data_set.map(operations=transforms_equalize, input_columns="image") ds_equalize = ds_equalize.batch(512) for idx, (image, _) in enumerate(ds_equalize): if idx == 0: images_equalize = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_equalize = np.append(images_equalize, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) num_samples = images_original.shape[0] mse = np.zeros(num_samples) for i in range(num_samples): 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_auto_contrast_py(plot=False): """ Test AutoContrast """ logger.info("Test AutoContrast Python Op") # Original Images data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_original = mindspore.dataset.transforms.py_transforms.Compose([F.Decode(), F.Resize((224, 224)), F.ToTensor()]) ds_original = data_set.map(operations=transforms_original, input_columns="image") ds_original = ds_original.batch(512) for idx, (image, _) in enumerate(ds_original): if idx == 0: images_original = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_original = np.append(images_original, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) # AutoContrast Images data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_auto_contrast = \ mindspore.dataset.transforms.py_transforms.Compose([F.Decode(), F.Resize((224, 224)), F.AutoContrast(cutoff=10.0, ignore=[10, 20]), F.ToTensor()]) ds_auto_contrast = data_set.map(operations=transforms_auto_contrast, input_columns="image") ds_auto_contrast = ds_auto_contrast.batch(512) for idx, (image, _) in enumerate(ds_auto_contrast): if idx == 0: images_auto_contrast = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_auto_contrast = np.append(images_auto_contrast, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) num_samples = images_original.shape[0] mse = np.zeros(num_samples) for i in range(num_samples): mse[i] = diff_mse(images_auto_contrast[i], images_original[i]) logger.info("MSE= {}".format(str(np.mean(mse)))) # Compare with expected md5 from images filename = "autocontrast_01_result_py.npz" save_and_check_md5(ds_auto_contrast, filename, generate_golden=GENERATE_GOLDEN) if plot: visualize_list(images_original, images_auto_contrast)
def test_cpp_uniform_augment(plot=False, num_ops=2): """ Test UniformAugment """ logger.info("Test CPP UniformAugment") # Original Images data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_original = [C.Decode(), C.Resize(size=[224, 224]), F.ToTensor()] ds_original = data_set.map(operations=transforms_original, input_columns="image") ds_original = ds_original.batch(512) for idx, (image, _) in enumerate(ds_original): if idx == 0: images_original = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_original = np.append(images_original, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) # UniformAugment Images data_set = ds.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_ua = [C.RandomCrop(size=[224, 224], padding=[32, 32, 32, 32]), C.RandomHorizontalFlip(), C.RandomVerticalFlip(), C.RandomColorAdjust(), C.RandomRotation(degrees=45)] uni_aug = C.UniformAugment(transforms=transforms_ua, num_ops=num_ops) transforms_all = [C.Decode(), C.Resize(size=[224, 224]), uni_aug, F.ToTensor()] ds_ua = data_set.map(operations=transforms_all, input_columns="image", num_parallel_workers=1) ds_ua = ds_ua.batch(512) for idx, (image, _) in enumerate(ds_ua): if idx == 0: images_ua = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_ua = np.append(images_ua, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) if plot: visualize_list(images_original, images_ua) num_samples = images_original.shape[0] mse = np.zeros(num_samples) for i in range(num_samples): mse[i] = diff_mse(images_ua[i], images_original[i]) logger.info("MSE= {}".format(str(np.mean(mse))))
def test_invert_py(plot=False): """ Test Invert python op """ logger.info("Test Invert Python op") # Original Images ds = de.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_original = mindspore.dataset.transforms.py_transforms.Compose( [F.Decode(), F.Resize((224, 224)), F.ToTensor()]) ds_original = ds.map(operations=transforms_original, input_columns="image") ds_original = ds_original.batch(512) for idx, (image, _) in enumerate(ds_original): if idx == 0: images_original = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_original = np.append(images_original, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) # Color Inverted Images ds = de.ImageFolderDataset(dataset_dir=DATA_DIR, shuffle=False) transforms_invert = mindspore.dataset.transforms.py_transforms.Compose( [F.Decode(), F.Resize((224, 224)), F.Invert(), F.ToTensor()]) ds_invert = ds.map(operations=transforms_invert, input_columns="image") ds_invert = ds_invert.batch(512) for idx, (image, _) in enumerate(ds_invert): if idx == 0: images_invert = np.transpose(image.asnumpy(), (0, 2, 3, 1)) else: images_invert = np.append(images_invert, np.transpose(image.asnumpy(), (0, 2, 3, 1)), axis=0) num_samples = images_original.shape[0] mse = np.zeros(num_samples) for i in range(num_samples): mse[i] = np.mean((images_invert[i] - images_original[i])**2) logger.info("MSE= {}".format(str(np.mean(mse)))) if plot: visualize_list(images_original, images_invert)
def test_five_crop_op(plot=False): """ Test FiveCrop """ logger.info("test_five_crop") # First dataset data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms_1 = [ vision.Decode(), vision.ToTensor(), ] 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) transforms_2 = [ vision.Decode(), vision.FiveCrop(200), lambda images: np.stack([vision.ToTensor()(image) for image in images]) # 4D stack of 5 images ] transform_2 = mindspore.dataset.transforms.py_transforms.Compose( transforms_2) data2 = data2.map(operations=transform_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) 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)) if plot: 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 assert image_2.shape[0] == 5
def __init__(self, data_dir, training=True, use_third_trsfm=False, use_auto_augment=False, num_parallel_workers=8, device_num=1, device_id=0): if not training: trsfm = Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) else: if not use_third_trsfm: trsfm = Compose([ transforms.ToPIL(), transforms.RandomResizedCrop(size=32, scale=(0.2, 1.)), transforms.RandomColorAdjust(0.4, 0.4, 0.4, 0.4), transforms.RandomGrayscale(prob=0.2), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) else: if use_auto_augment: trsfm = Compose([ transforms.ToPIL(), transforms.RandomResizedCrop(size=32, scale=(0.2, 1.)), transforms.RandomHorizontalFlip(), CIFAR10Policy(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) else: rand_augment = RandAugment(n=2, m=10) trsfm = Compose([ transforms.ToPIL(), transforms.RandomResizedCrop(size=32, scale=(0.2, 1.)), transforms.RandomHorizontalFlip(), rand_augment, transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) self.trsfm = trsfm self.data_dir = data_dir self.num_parallel_workers = num_parallel_workers self.device_num = device_num self.device_id = device_id
def util_test_ten_crop(crop_size, vertical_flip=False, plot=False): """ Utility function for testing TenCrop. Input arguments are given by other tests """ data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms_1 = [ vision.Decode(), vision.ToTensor(), ] 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) transforms_2 = [ vision.Decode(), vision.TenCrop(crop_size, use_vertical_flip=vertical_flip), lambda *images: np.stack( [vision.ToTensor()(image) for image in images]) # 4D stack of 10 images ] transform_2 = mindspore.dataset.transforms.py_transforms.Compose( transforms_2) data2 = data2.map(operations=transform_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) 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)) if plot: visualize_list(np.array([image_1] * 10), (image_2 * 255).astype(np.uint8).transpose( 0, 2, 3, 1)) # The output data should be of a 4D tensor shape, a stack of 10 images. assert len(image_2.shape) == 4 assert image_2.shape[0] == 10
def test_random_grayscale_input_grayscale_images(): """ Test RandomGrayscale Op: valid parameter with grayscale images as input, expect to pass """ logger.info("test_random_grayscale_input_grayscale_images") original_seed = config_get_set_seed(0) 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) transforms1 = [ py_vision.Decode(), py_vision.Grayscale(1), # Note: If the input images is grayscale image with 1 channel. py_vision.RandomGrayscale(0.5), py_vision.ToTensor() ] transform1 = mindspore.dataset.transforms.py_transforms.Compose( transforms1) data1 = data1.map(operations=transform1, input_columns=["image"]) # Second dataset data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms2 = [py_vision.Decode(), py_vision.ToTensor()] transform2 = mindspore.dataset.transforms.py_transforms.Compose( transforms2) data2 = data2.map(operations=transform2, input_columns=["image"]) image_gray = [] image = [] 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)): image1 = (item1["image"].transpose(1, 2, 0) * 255).astype(np.uint8) image2 = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) image_gray.append(image1) image.append(image2) assert len(image1.shape) == 3 assert image1.shape[2] == 1 assert len(image2.shape) == 3 assert image2.shape[2] == 3 # Restore config ds.config.set_seed(original_seed) ds.config.set_num_parallel_workers(original_num_parallel_workers)
def test_random_crop_and_resize_op_py(plot=False): """ Test RandomCropAndResize op in py transforms """ logger.info("test_random_crop_and_resize_op_py") # First dataset data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # With these inputs we expect the code to crop the whole image transforms1 = [ py_vision.Decode(), py_vision.RandomResizedCrop((256, 512), (2, 2), (1, 3)), py_vision.ToTensor() ] transform1 = mindspore.dataset.transforms.py_transforms.Compose( transforms1) data1 = data1.map(operations=transform1, input_columns=["image"]) # Second dataset # Second dataset for comparison data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms2 = [py_vision.Decode(), py_vision.ToTensor()] transform2 = mindspore.dataset.transforms.py_transforms.Compose( transforms2) data2 = data2.map(operations=transform2, input_columns=["image"]) num_iter = 0 crop_and_resize_images = [] original_images = [] 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)): crop_and_resize = (item1["image"].transpose(1, 2, 0) * 255).astype( np.uint8) original = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) original = cv2.resize(original, (512, 256)) mse = diff_mse(crop_and_resize, original) # Due to rounding error the mse for Python is not exactly 0 assert mse <= 0.05 logger.info("random_crop_and_resize_op_{}, mse: {}".format( num_iter + 1, mse)) num_iter += 1 crop_and_resize_images.append(crop_and_resize) original_images.append(original) if plot: visualize_list(original_images, crop_and_resize_images)
def util_test_normalize(mean, std, op_type): """ Utility function for testing Normalize. Input arguments are given by other tests """ if op_type == "cpp": # define map operations decode_op = c_vision.Decode() normalize_op = c_vision.Normalize(mean, std) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) data = data.map(operations=decode_op, input_columns=["image"]) data = data.map(operations=normalize_op, input_columns=["image"]) elif op_type == "python": # define map operations transforms = [ py_vision.Decode(), py_vision.ToTensor(), py_vision.Normalize(mean, std) ] transform = mindspore.dataset.transforms.py_transforms.Compose( transforms) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) data = data.map(operations=transform, input_columns=["image"]) else: raise ValueError("Wrong parameter value") return data
def test_serdes_pyvision(remove_json_files=True): """ Test serdes on py_transform pipeline. """ data_dir = [ "../data/dataset/test_tf_file_3_images/train-0000-of-0001.data" ] schema_file = "../data/dataset/test_tf_file_3_images/datasetSchema.json" data1 = ds.TFRecordDataset(data_dir, schema_file, columns_list=["image", "label"], shuffle=False) transforms = [ py_vision.Decode(), py_vision.CenterCrop([32, 32]), py_vision.ToTensor() ] data1 = data1.map(operations=py.Compose(transforms), input_columns=["image"]) # Current python function derialization will be failed for pickle, so we disable this testcase # as an exception testcase. try: util_check_serialize_deserialize_file(data1, "pyvision_dataset_pipeline", remove_json_files) assert False except NotImplementedError as e: assert "python function is not yet supported" in str(e)
def __getitem__(self, index): img_path = self.all_img_paths[index] gt_path = self.all_gt_paths[index] img = get_img(img_path) bboxes, tags = get_bboxes(img, gt_path) # multi-scale training if self.is_transform: img = random_scale(img, min_size=self.img_size[0]) # get gt_text and training_mask img_h, img_w = img.shape[0: 2] gt_text = np.zeros((img_h, img_w), dtype=np.float32) training_mask = np.ones((img_h, img_w), dtype=np.float32) if bboxes.shape[0] > 0: bboxes = np.reshape(bboxes * ([img_w, img_h] * 4), (bboxes.shape[0], -1, 2)).astype('int32') for i in range(bboxes.shape[0]): cv2.drawContours(gt_text, [bboxes[i]], 0, i + 1, -1) if not tags[i]: cv2.drawContours(training_mask, [bboxes[i]], 0, 0, -1) # get gt_kernels gt_kernels = [] for i in range(1, self.kernel_num): rate = 1.0 - (1.0 - self.min_scale) / (self.kernel_num - 1) * i gt_kernel = np.zeros(img.shape[0:2], dtype=np.float32) kernel_bboxes = shrink(bboxes, rate) for j in range(kernel_bboxes.shape[0]): cv2.drawContours(gt_kernel, [kernel_bboxes[j]], 0, 1, -1) gt_kernels.append(gt_kernel) # data augmentation if self.is_transform: imgs = [img, gt_text, training_mask] imgs.extend(gt_kernels) imgs = random_horizontal_flip(imgs) imgs = random_rotate(imgs) imgs = random_crop(imgs, self.img_size) img, gt_text, training_mask, gt_kernels = imgs[0], imgs[1], imgs[2], imgs[3:] gt_text[gt_text > 0] = 1 gt_kernels = np.array(gt_kernels) if self.is_transform: img = Image.fromarray(img) img = img.convert('RGB') img = py_transforms.RandomColorAdjust(brightness=32.0 / 255, saturation=0.5)(img) else: img = Image.fromarray(img) img = img.convert('RGB') img = py_transforms.ToTensor()(img) img = py_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])(img) gt_text = gt_text.astype(np.float32) gt_kernels = gt_kernels.astype(np.float32) training_mask = training_mask.astype(np.float32) return img, gt_text, gt_kernels, training_mask
def test_random_apply_md5(): """ Test RandomApply op with md5 check """ logger.info("test_random_apply_md5") original_seed = config_get_set_seed(10) original_num_parallel_workers = config_get_set_num_parallel_workers(1) # define map operations transforms_list = [py_vision.CenterCrop(64), py_vision.RandomRotation(30)] transforms = [ py_vision.Decode(), # Note: using default value "prob=0.5" py_transforms.RandomApply(transforms_list), py_vision.ToTensor() ] transform = py_transforms.Compose(transforms) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) data = data.map(operations=transform, input_columns=["image"]) # check results with md5 comparison filename = "random_apply_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))
def test_random_crop_and_resize_op_py_ANTIALIAS(): """ Test RandomCropAndResize op in py transforms """ logger.info("test_random_crop_and_resize_op_py_ANTIALIAS") # First dataset data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # With these inputs we expect the code to crop the whole image transforms1 = [ py_vision.Decode(), py_vision.RandomResizedCrop((256, 512), (2, 2), (1, 3), Inter.ANTIALIAS), py_vision.ToTensor() ] transform1 = mindspore.dataset.transforms.py_transforms.Compose( transforms1) data1 = data1.map(operations=transform1, input_columns=["image"]) num_iter = 0 for _ in data1.create_dict_iterator(num_epochs=1, output_numpy=True): num_iter += 1 logger.info( "use RandomResizedCrop by Inter.ANTIALIAS process {} images.".format( num_iter))
def test_random_crop_comp(plot=False): """ Test RandomCrop and compare between python and c image augmentation """ logger.info("Test RandomCrop with c_transform and py_transform comparison") cropped_size = 512 # First dataset data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) random_crop_op = c_vision.RandomCrop(cropped_size) decode_op = c_vision.Decode() data1 = data1.map(operations=decode_op, input_columns=["image"]) data1 = data1.map(operations=random_crop_op, input_columns=["image"]) # Second dataset data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms = [ py_vision.Decode(), py_vision.RandomCrop(cropped_size), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data2 = data2.map(operations=transform, input_columns=["image"]) image_c_cropped = [] image_py_cropped = [] 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)): c_image = item1["image"] py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) image_c_cropped.append(c_image) image_py_cropped.append(py_image) if plot: visualize_list(image_c_cropped, image_py_cropped, visualize_mode=2)
def test_random_crop_06_py(): """ Test RandomCrop op with py_transforms: invalid size, expected to raise TypeError """ logger.info("test_random_crop_06_py") # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) try: # Note: if size is neither an int nor a list of length 2, an exception will raise transforms = [ py_vision.Decode(), py_vision.RandomCrop([512, 512, 375]), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose( transforms) data = data.map(operations=transform, input_columns=["image"]) except TypeError as e: logger.info("Got an exception in DE: {}".format(str(e))) assert "Size should be a single integer" in str(e)
def test_random_crop_05_py(): """ Test RandomCrop op with py_transforms: input image size < crop size but pad_if_needed is enabled, expected to pass """ logger.info("test_random_crop_05_py") original_seed = config_get_set_seed(0) original_num_parallel_workers = config_get_set_num_parallel_workers(1) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # Note: The size of the image is 4032*2268 transforms = [ py_vision.Decode(), py_vision.RandomCrop([2268, 4033], [200, 200, 200, 200], pad_if_needed=True), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data = data.map(operations=transform, input_columns=["image"]) filename = "random_crop_05_py_result.npz" save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) # Restore config setting ds.config.set_seed(original_seed) ds.config.set_num_parallel_workers(original_num_parallel_workers)
def test_random_crop_02_py(): """ Test RandomCrop op with py_transforms: size is a list/tuple with length 2, expected to pass """ logger.info("test_random_crop_02_py") original_seed = config_get_set_seed(0) original_num_parallel_workers = config_get_set_num_parallel_workers(1) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # Note: If size is a sequence of length 2, it should be (height, width). transforms = [ py_vision.Decode(), py_vision.RandomCrop([512, 375]), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data = data.map(operations=transform, input_columns=["image"]) filename = "random_crop_02_py_result.npz" save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) # Restore config setting ds.config.set_seed(original_seed) ds.config.set_num_parallel_workers(original_num_parallel_workers)
def test_random_crop_01_py(): """ Test RandomCrop op with py_transforms: size is a single integer, expected to pass """ logger.info("test_random_crop_01_py") original_seed = config_get_set_seed(0) original_num_parallel_workers = config_get_set_num_parallel_workers(1) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # Note: If size is an int, a square crop of size (size, size) is returned. transforms = [ py_vision.Decode(), py_vision.RandomCrop(512), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data = data.map(operations=transform, input_columns=["image"]) filename = "random_crop_01_py_result.npz" save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) # Restore config setting ds.config.set_seed(original_seed) ds.config.set_num_parallel_workers(original_num_parallel_workers)
def test_random_crop_and_resize_05_py(): """ Test RandomCropAndResize with py_transforms: invalid range of ratio (max<min), expected to raise ValueError """ logger.info("test_random_crop_and_resize_05_py") # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) try: transforms = [ py_vision.Decode(), # If input range of ratio is not in the order of (min, max), ValueError will be raised. py_vision.RandomResizedCrop((256, 512), (1, 1), (1, 0.5)), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose( transforms) data = data.map(operations=transform, input_columns=["image"]) except ValueError as e: logger.info("Got an exception in DE: {}".format(str(e))) assert "ratio should be in (min,max) format. Got (max,min)." in str(e)
def __call__(self, imgs, ann, image_names, image_size, batch_info): size = self.resize decode = P.Decode() resize_letter_box_op = ResizeLetterbox(input_dim=size) to_tensor = P.ToTensor() ret_imgs = [] ret_anno = [] for i, image in enumerate(imgs): img_pil = decode(image) input_data = img_pil, ann[i] input_data = resize_letter_box_op(*input_data) image_arr = to_tensor(input_data[0]) ret_imgs.append(image_arr) ret_anno.append(input_data[1]) for i, anno in enumerate(ret_anno): anno_count = anno.shape[0] if anno_count < self.max_anno_count: ret_anno[i] = np.concatenate( (ret_anno[i], np.zeros( (self.max_anno_count - anno_count, 6), dtype=float)), axis=0) else: ret_anno[i] = ret_anno[i][:self.max_anno_count] return np.array(ret_imgs), np.array(ret_anno), image_names, image_size
def test_crop_grayscale(height=375, width=375): """ Test that centercrop works with pad and grayscale images """ # Note: image.transpose performs channel swap to allow py transforms to # work with c transforms transforms = [ py_vision.Decode(), py_vision.Grayscale(1), py_vision.ToTensor(), (lambda image: (image.transpose(1, 2, 0) * 255).astype(np.uint8)) ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) data1 = data1.map(operations=transform, input_columns=["image"]) # If input is grayscale, the output dimensions should be single channel crop_gray = vision.CenterCrop([height, width]) data1 = data1.map(operations=crop_gray, input_columns=["image"]) for item1 in data1.create_dict_iterator(num_epochs=1, output_numpy=True): c_image = item1["image"] # Check that the image is grayscale assert (c_image.ndim == 3 and c_image.shape[2] == 1)
def test_random_crop_08_py(): """ Test RandomCrop op with py_transforms: padding_mode is Border.EDGE, expected to pass """ logger.info("test_random_crop_08_py") original_seed = config_get_set_seed(0) original_num_parallel_workers = config_get_set_num_parallel_workers(1) # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # Note: The padding_mode is Border.EDGE. transforms = [ py_vision.Decode(), py_vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=mode.Border.EDGE), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data = data.map(operations=transform, input_columns=["image"]) filename = "random_crop_08_py_result.npz" save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) # Restore config setting ds.config.set_seed(original_seed) ds.config.set_num_parallel_workers(original_num_parallel_workers)
def test_center_crop_comp(height=375, width=375, plot=False): """ Test CenterCrop between python and c image augmentation """ logger.info("Test CenterCrop") # First dataset data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) decode_op = vision.Decode() center_crop_op = vision.CenterCrop([height, width]) data1 = data1.map(operations=decode_op, input_columns=["image"]) data1 = data1.map(operations=center_crop_op, input_columns=["image"]) # Second dataset data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) transforms = [ py_vision.Decode(), py_vision.CenterCrop([height, width]), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data2 = data2.map(operations=transform, input_columns=["image"]) image_c_cropped = [] image_py_cropped = [] 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)): c_image = item1["image"] py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) # Note: The images aren't exactly the same due to rounding error assert diff_mse(py_image, c_image) < 0.001 image_c_cropped.append(c_image.copy()) image_py_cropped.append(py_image.copy()) if plot: visualize_list(image_c_cropped, image_py_cropped, visualize_mode=2)
def test_random_crop_04_py(): """ Test RandomCrop op with py_transforms: input image size < crop size, expected to fail """ logger.info("test_random_crop_04_py") # Generate dataset data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) # Note: The size of the image is 4032*2268 transforms = [ py_vision.Decode(), py_vision.RandomCrop([2268, 4033]), py_vision.ToTensor() ] transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) data = data.map(operations=transform, input_columns=["image"]) try: data.create_dict_iterator(num_epochs=1).__next__() except RuntimeError as e: logger.info("Got an exception in DE: {}".format(str(e))) assert "Crop size" in str(e)