1# Copyright 2019 Huawei Technologies Co., Ltd 2# 3# Licensed under the Apache License, Version 2.0 (the "License"); 4# you may not use this file except in compliance with the License. 5# You may obtain a copy of the License at 6# 7# http://www.apache.org/licenses/LICENSE-2.0 8# 9# Unless required by applicable law or agreed to in writing, software 10# distributed under the License is distributed on an "AS IS" BASIS, 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12# See the License for the specific language governing permissions and 13# limitations under the License. 14# ============================================================================== 15""" 16Testing RandomCrop op in DE 17""" 18import numpy as np 19 20import mindspore.dataset.transforms.py_transforms 21import mindspore.dataset.transforms.c_transforms as ops 22import mindspore.dataset.vision.c_transforms as c_vision 23import mindspore.dataset.vision.py_transforms as py_vision 24import mindspore.dataset.vision.utils as mode 25import mindspore.dataset as ds 26from mindspore import log as logger 27from util import save_and_check_md5, visualize_list, config_get_set_seed, \ 28 config_get_set_num_parallel_workers, diff_mse 29 30 31GENERATE_GOLDEN = False 32 33DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"] 34SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json" 35 36 37def test_random_crop_op_c(plot=False): 38 """ 39 Test RandomCrop Op in c transforms 40 """ 41 logger.info("test_random_crop_op_c") 42 43 # First dataset 44 data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 45 random_crop_op = c_vision.RandomCrop([512, 512], [200, 200, 200, 200]) 46 decode_op = c_vision.Decode() 47 48 data1 = data1.map(operations=decode_op, input_columns=["image"]) 49 data1 = data1.map(operations=random_crop_op, input_columns=["image"]) 50 51 # Second dataset 52 data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 53 data2 = data2.map(operations=decode_op, input_columns=["image"]) 54 55 image_cropped = [] 56 image = [] 57 for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True), 58 data2.create_dict_iterator(num_epochs=1, output_numpy=True)): 59 image1 = item1["image"] 60 image2 = item2["image"] 61 image_cropped.append(image1) 62 image.append(image2) 63 if plot: 64 visualize_list(image, image_cropped) 65 66def test_random_crop_op_py(plot=False): 67 """ 68 Test RandomCrop op in py transforms 69 """ 70 logger.info("test_random_crop_op_py") 71 # First dataset 72 data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 73 transforms1 = [ 74 py_vision.Decode(), 75 py_vision.RandomCrop([512, 512], [200, 200, 200, 200]), 76 py_vision.ToTensor() 77 ] 78 transform1 = mindspore.dataset.transforms.py_transforms.Compose(transforms1) 79 data1 = data1.map(operations=transform1, input_columns=["image"]) 80 # Second dataset 81 # Second dataset for comparison 82 data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 83 transforms2 = [ 84 py_vision.Decode(), 85 py_vision.ToTensor() 86 ] 87 transform2 = mindspore.dataset.transforms.py_transforms.Compose(transforms2) 88 data2 = data2.map(operations=transform2, input_columns=["image"]) 89 90 crop_images = [] 91 original_images = [] 92 for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True), 93 data2.create_dict_iterator(num_epochs=1, output_numpy=True)): 94 crop = (item1["image"].transpose(1, 2, 0) * 255).astype(np.uint8) 95 original = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) 96 crop_images.append(crop) 97 original_images.append(original) 98 if plot: 99 visualize_list(original_images, crop_images) 100 101def test_random_crop_01_c(): 102 """ 103 Test RandomCrop op with c_transforms: size is a single integer, expected to pass 104 """ 105 logger.info("test_random_crop_01_c") 106 original_seed = config_get_set_seed(0) 107 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 108 109 # Generate dataset 110 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 111 # Note: If size is an int, a square crop of size (size, size) is returned. 112 random_crop_op = c_vision.RandomCrop(512) 113 decode_op = c_vision.Decode() 114 data = data.map(operations=decode_op, input_columns=["image"]) 115 data = data.map(operations=random_crop_op, input_columns=["image"]) 116 117 filename = "random_crop_01_c_result.npz" 118 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 119 120 # Restore config setting 121 ds.config.set_seed(original_seed) 122 ds.config.set_num_parallel_workers(original_num_parallel_workers) 123 124def test_random_crop_01_py(): 125 """ 126 Test RandomCrop op with py_transforms: size is a single integer, expected to pass 127 """ 128 logger.info("test_random_crop_01_py") 129 original_seed = config_get_set_seed(0) 130 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 131 132 # Generate dataset 133 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 134 # Note: If size is an int, a square crop of size (size, size) is returned. 135 transforms = [ 136 py_vision.Decode(), 137 py_vision.RandomCrop(512), 138 py_vision.ToTensor() 139 ] 140 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 141 data = data.map(operations=transform, input_columns=["image"]) 142 143 filename = "random_crop_01_py_result.npz" 144 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 145 146 # Restore config setting 147 ds.config.set_seed(original_seed) 148 ds.config.set_num_parallel_workers(original_num_parallel_workers) 149 150def test_random_crop_02_c(): 151 """ 152 Test RandomCrop op with c_transforms: size is a list/tuple with length 2, expected to pass 153 """ 154 logger.info("test_random_crop_02_c") 155 original_seed = config_get_set_seed(0) 156 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 157 158 # Generate dataset 159 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 160 # Note: If size is a sequence of length 2, it should be (height, width). 161 random_crop_op = c_vision.RandomCrop([512, 375]) 162 decode_op = c_vision.Decode() 163 data = data.map(operations=decode_op, input_columns=["image"]) 164 data = data.map(operations=random_crop_op, input_columns=["image"]) 165 166 filename = "random_crop_02_c_result.npz" 167 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 168 169 # Restore config setting 170 ds.config.set_seed(original_seed) 171 ds.config.set_num_parallel_workers(original_num_parallel_workers) 172 173def test_random_crop_02_py(): 174 """ 175 Test RandomCrop op with py_transforms: size is a list/tuple with length 2, expected to pass 176 """ 177 logger.info("test_random_crop_02_py") 178 original_seed = config_get_set_seed(0) 179 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 180 181 # Generate dataset 182 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 183 # Note: If size is a sequence of length 2, it should be (height, width). 184 transforms = [ 185 py_vision.Decode(), 186 py_vision.RandomCrop([512, 375]), 187 py_vision.ToTensor() 188 ] 189 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 190 data = data.map(operations=transform, input_columns=["image"]) 191 192 filename = "random_crop_02_py_result.npz" 193 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 194 195 # Restore config setting 196 ds.config.set_seed(original_seed) 197 ds.config.set_num_parallel_workers(original_num_parallel_workers) 198 199def test_random_crop_03_c(): 200 """ 201 Test RandomCrop op with c_transforms: input image size == crop size, expected to pass 202 """ 203 logger.info("test_random_crop_03_c") 204 original_seed = config_get_set_seed(0) 205 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 206 207 # Generate dataset 208 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 209 # Note: The size of the image is 4032*2268 210 random_crop_op = c_vision.RandomCrop([2268, 4032]) 211 decode_op = c_vision.Decode() 212 data = data.map(operations=decode_op, input_columns=["image"]) 213 data = data.map(operations=random_crop_op, input_columns=["image"]) 214 215 filename = "random_crop_03_c_result.npz" 216 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 217 218 # Restore config setting 219 ds.config.set_seed(original_seed) 220 ds.config.set_num_parallel_workers(original_num_parallel_workers) 221 222def test_random_crop_03_py(): 223 """ 224 Test RandomCrop op with py_transforms: input image size == crop size, expected to pass 225 """ 226 logger.info("test_random_crop_03_py") 227 original_seed = config_get_set_seed(0) 228 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 229 230 # Generate dataset 231 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 232 # Note: The size of the image is 4032*2268 233 transforms = [ 234 py_vision.Decode(), 235 py_vision.RandomCrop([2268, 4032]), 236 py_vision.ToTensor() 237 ] 238 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 239 data = data.map(operations=transform, input_columns=["image"]) 240 241 filename = "random_crop_03_py_result.npz" 242 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 243 244 # Restore config setting 245 ds.config.set_seed(original_seed) 246 ds.config.set_num_parallel_workers(original_num_parallel_workers) 247 248def test_random_crop_04_c(): 249 """ 250 Test RandomCrop op with c_transforms: input image size < crop size, expected to fail 251 """ 252 logger.info("test_random_crop_04_c") 253 254 # Generate dataset 255 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 256 # Note: The size of the image is 4032*2268 257 random_crop_op = c_vision.RandomCrop([2268, 4033]) 258 decode_op = c_vision.Decode() 259 data = data.map(operations=decode_op, input_columns=["image"]) 260 data = data.map(operations=random_crop_op, input_columns=["image"]) 261 try: 262 data.create_dict_iterator(num_epochs=1).__next__() 263 except RuntimeError as e: 264 logger.info("Got an exception in DE: {}".format(str(e))) 265 assert "crop size is bigger than the image dimensions" in str(e) 266 267def test_random_crop_04_py(): 268 """ 269 Test RandomCrop op with py_transforms: 270 input image size < crop size, expected to fail 271 """ 272 logger.info("test_random_crop_04_py") 273 274 # Generate dataset 275 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 276 # Note: The size of the image is 4032*2268 277 transforms = [ 278 py_vision.Decode(), 279 py_vision.RandomCrop([2268, 4033]), 280 py_vision.ToTensor() 281 ] 282 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 283 data = data.map(operations=transform, input_columns=["image"]) 284 try: 285 data.create_dict_iterator(num_epochs=1).__next__() 286 except RuntimeError as e: 287 logger.info("Got an exception in DE: {}".format(str(e))) 288 assert "Crop size" in str(e) 289 290def test_random_crop_05_c(): 291 """ 292 Test RandomCrop op with c_transforms: 293 input image size < crop size but pad_if_needed is enabled, 294 expected to pass 295 """ 296 logger.info("test_random_crop_05_c") 297 original_seed = config_get_set_seed(0) 298 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 299 300 # Generate dataset 301 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 302 # Note: The size of the image is 4032*2268 303 random_crop_op = c_vision.RandomCrop([2268, 4033], [200, 200, 200, 200], pad_if_needed=True) 304 decode_op = c_vision.Decode() 305 data = data.map(operations=decode_op, input_columns=["image"]) 306 data = data.map(operations=random_crop_op, input_columns=["image"]) 307 308 filename = "random_crop_05_c_result.npz" 309 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 310 311 # Restore config setting 312 ds.config.set_seed(original_seed) 313 ds.config.set_num_parallel_workers(original_num_parallel_workers) 314 315def test_random_crop_05_py(): 316 """ 317 Test RandomCrop op with py_transforms: 318 input image size < crop size but pad_if_needed is enabled, 319 expected to pass 320 """ 321 logger.info("test_random_crop_05_py") 322 original_seed = config_get_set_seed(0) 323 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 324 325 # Generate dataset 326 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 327 # Note: The size of the image is 4032*2268 328 transforms = [ 329 py_vision.Decode(), 330 py_vision.RandomCrop([2268, 4033], [200, 200, 200, 200], pad_if_needed=True), 331 py_vision.ToTensor() 332 ] 333 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 334 data = data.map(operations=transform, input_columns=["image"]) 335 336 filename = "random_crop_05_py_result.npz" 337 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 338 339 # Restore config setting 340 ds.config.set_seed(original_seed) 341 ds.config.set_num_parallel_workers(original_num_parallel_workers) 342 343def test_random_crop_06_c(): 344 """ 345 Test RandomCrop op with c_transforms: 346 invalid size, expected to raise TypeError 347 """ 348 logger.info("test_random_crop_06_c") 349 350 # Generate dataset 351 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 352 try: 353 # Note: if size is neither an int nor a list of length 2, an exception will raise 354 random_crop_op = c_vision.RandomCrop([512, 512, 375]) 355 decode_op = c_vision.Decode() 356 data = data.map(operations=decode_op, input_columns=["image"]) 357 data = data.map(operations=random_crop_op, input_columns=["image"]) 358 except TypeError as e: 359 logger.info("Got an exception in DE: {}".format(str(e))) 360 assert "Size should be a single integer" in str(e) 361 362def test_random_crop_06_py(): 363 """ 364 Test RandomCrop op with py_transforms: 365 invalid size, expected to raise TypeError 366 """ 367 logger.info("test_random_crop_06_py") 368 369 # Generate dataset 370 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 371 try: 372 # Note: if size is neither an int nor a list of length 2, an exception will raise 373 transforms = [ 374 py_vision.Decode(), 375 py_vision.RandomCrop([512, 512, 375]), 376 py_vision.ToTensor() 377 ] 378 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 379 data = data.map(operations=transform, input_columns=["image"]) 380 except TypeError as e: 381 logger.info("Got an exception in DE: {}".format(str(e))) 382 assert "Size should be a single integer" in str(e) 383 384def test_random_crop_07_c(): 385 """ 386 Test RandomCrop op with c_transforms: 387 padding_mode is Border.CONSTANT and fill_value is 255 (White), 388 expected to pass 389 """ 390 logger.info("test_random_crop_07_c") 391 original_seed = config_get_set_seed(0) 392 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 393 394 # Generate dataset 395 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 396 # Note: The padding_mode is default as Border.CONSTANT and set filling color to be white. 397 random_crop_op = c_vision.RandomCrop(512, [200, 200, 200, 200], fill_value=(255, 255, 255)) 398 decode_op = c_vision.Decode() 399 data = data.map(operations=decode_op, input_columns=["image"]) 400 data = data.map(operations=random_crop_op, input_columns=["image"]) 401 402 filename = "random_crop_07_c_result.npz" 403 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 404 405 # Restore config setting 406 ds.config.set_seed(original_seed) 407 ds.config.set_num_parallel_workers(original_num_parallel_workers) 408 409def test_random_crop_07_py(): 410 """ 411 Test RandomCrop op with py_transforms: 412 padding_mode is Border.CONSTANT and fill_value is 255 (White), 413 expected to pass 414 """ 415 logger.info("test_random_crop_07_py") 416 original_seed = config_get_set_seed(0) 417 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 418 419 # Generate dataset 420 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 421 # Note: The padding_mode is default as Border.CONSTANT and set filling color to be white. 422 transforms = [ 423 py_vision.Decode(), 424 py_vision.RandomCrop(512, [200, 200, 200, 200], fill_value=(255, 255, 255)), 425 py_vision.ToTensor() 426 ] 427 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 428 data = data.map(operations=transform, input_columns=["image"]) 429 430 filename = "random_crop_07_py_result.npz" 431 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 432 433 # Restore config setting 434 ds.config.set_seed(original_seed) 435 ds.config.set_num_parallel_workers(original_num_parallel_workers) 436 437def test_random_crop_08_c(): 438 """ 439 Test RandomCrop op with c_transforms: padding_mode is Border.EDGE, 440 expected to pass 441 """ 442 logger.info("test_random_crop_08_c") 443 original_seed = config_get_set_seed(0) 444 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 445 446 # Generate dataset 447 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 448 # Note: The padding_mode is Border.EDGE. 449 random_crop_op = c_vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=mode.Border.EDGE) 450 decode_op = c_vision.Decode() 451 data = data.map(operations=decode_op, input_columns=["image"]) 452 data = data.map(operations=random_crop_op, input_columns=["image"]) 453 454 filename = "random_crop_08_c_result.npz" 455 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 456 457 # Restore config setting 458 ds.config.set_seed(original_seed) 459 ds.config.set_num_parallel_workers(original_num_parallel_workers) 460 461def test_random_crop_08_py(): 462 """ 463 Test RandomCrop op with py_transforms: padding_mode is Border.EDGE, 464 expected to pass 465 """ 466 logger.info("test_random_crop_08_py") 467 original_seed = config_get_set_seed(0) 468 original_num_parallel_workers = config_get_set_num_parallel_workers(1) 469 470 # Generate dataset 471 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 472 # Note: The padding_mode is Border.EDGE. 473 transforms = [ 474 py_vision.Decode(), 475 py_vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=mode.Border.EDGE), 476 py_vision.ToTensor() 477 ] 478 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 479 data = data.map(operations=transform, input_columns=["image"]) 480 481 filename = "random_crop_08_py_result.npz" 482 save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN) 483 484 # Restore config setting 485 ds.config.set_seed(original_seed) 486 ds.config.set_num_parallel_workers(original_num_parallel_workers) 487 488def test_random_crop_09(): 489 """ 490 Test RandomCrop op: invalid type of input image (not PIL), expected to raise TypeError 491 """ 492 logger.info("test_random_crop_09") 493 494 # Generate dataset 495 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 496 transforms = [ 497 py_vision.Decode(), 498 py_vision.ToTensor(), 499 # Note: if input is not PIL image, TypeError will raise 500 py_vision.RandomCrop(512) 501 ] 502 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 503 data = data.map(operations=transform, input_columns=["image"]) 504 try: 505 data.create_dict_iterator(num_epochs=1).__next__() 506 except RuntimeError as e: 507 logger.info("Got an exception in DE: {}".format(str(e))) 508 assert "should be PIL image" in str(e) 509 510def test_random_crop_comp(plot=False): 511 """ 512 Test RandomCrop and compare between python and c image augmentation 513 """ 514 logger.info("Test RandomCrop with c_transform and py_transform comparison") 515 cropped_size = 512 516 517 # First dataset 518 data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 519 random_crop_op = c_vision.RandomCrop(cropped_size) 520 decode_op = c_vision.Decode() 521 data1 = data1.map(operations=decode_op, input_columns=["image"]) 522 data1 = data1.map(operations=random_crop_op, input_columns=["image"]) 523 524 # Second dataset 525 data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 526 transforms = [ 527 py_vision.Decode(), 528 py_vision.RandomCrop(cropped_size), 529 py_vision.ToTensor() 530 ] 531 transform = mindspore.dataset.transforms.py_transforms.Compose(transforms) 532 data2 = data2.map(operations=transform, input_columns=["image"]) 533 534 image_c_cropped = [] 535 image_py_cropped = [] 536 for item1, item2 in zip(data1.create_dict_iterator(num_epochs=1, output_numpy=True), 537 data2.create_dict_iterator(num_epochs=1, output_numpy=True)): 538 c_image = item1["image"] 539 py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8) 540 image_c_cropped.append(c_image) 541 image_py_cropped.append(py_image) 542 if plot: 543 visualize_list(image_c_cropped, image_py_cropped, visualize_mode=2) 544 545def test_random_crop_09_c(): 546 """ 547 Test RandomCrop with different fields. 548 """ 549 logger.info("Test RandomCrop with different fields.") 550 551 data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False) 552 data = data.map(operations=ops.Duplicate(), input_columns=["image"], 553 output_columns=["image", "image_copy"], column_order=["image", "image_copy"]) 554 random_crop_op = c_vision.RandomCrop([512, 512], [200, 200, 200, 200]) 555 decode_op = c_vision.Decode() 556 557 data = data.map(operations=decode_op, input_columns=["image"]) 558 data = data.map(operations=decode_op, input_columns=["image_copy"]) 559 data = data.map(operations=random_crop_op, input_columns=["image", "image_copy"]) 560 561 num_iter = 0 562 for data1 in data.create_dict_iterator(num_epochs=1, output_numpy=True): 563 image = data1["image"] 564 image_copy = data1["image_copy"] 565 mse = diff_mse(image, image_copy) 566 assert mse == 0 567 num_iter += 1 568 569 570if __name__ == "__main__": 571 test_random_crop_01_c() 572 test_random_crop_02_c() 573 test_random_crop_03_c() 574 test_random_crop_04_c() 575 test_random_crop_05_c() 576 test_random_crop_06_c() 577 test_random_crop_07_c() 578 test_random_crop_08_c() 579 test_random_crop_01_py() 580 test_random_crop_02_py() 581 test_random_crop_03_py() 582 test_random_crop_04_py() 583 test_random_crop_05_py() 584 test_random_crop_06_py() 585 test_random_crop_07_py() 586 test_random_crop_08_py() 587 test_random_crop_09() 588 test_random_crop_op_c(True) 589 test_random_crop_op_py(True) 590 test_random_crop_comp(True) 591 test_random_crop_09_c() 592