1 /**
2 * Copyright 2020-2021 Huawei Technologies Co., Ltd
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "common/common.h"
17 #include "minddata/dataset/include/dataset/config.h"
18 #include "minddata/dataset/include/dataset/datasets.h"
19 #include "minddata/dataset/include/dataset/transforms.h"
20 #include "minddata/dataset/include/dataset/vision.h"
21
22 using namespace mindspore::dataset;
23 using mindspore::dataset::InterpolationMode;
24
25 class MindDataTestPipeline : public UT::DatasetOpTesting {
26 protected:
27 };
28
29 // Tests for vision C++ API Random* TensorTransform Operations (in alphabetical order)
30
TEST_F(MindDataTestPipeline,TestRandomAffineFail)31 TEST_F(MindDataTestPipeline, TestRandomAffineFail) {
32 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomAffineFail with invalid parameters.";
33 // Create an ImageFolder Dataset
34 std::string folder_path = datasets_root_path_ + "/testPK/data/";
35 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
36 EXPECT_NE(ds, nullptr);
37
38 // Case 1: Empty input for translate
39 // Create objects for the tensor ops
40 std::shared_ptr<TensorTransform> affine1(new vision::RandomAffine({0.0, 0.0}, {}));
41 auto ds1 = ds->Map({affine1});
42 EXPECT_NE(ds1, nullptr);
43 // Create an iterator over the result of the above dataset
44 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
45 // Expect failure: invalid input for RandomAffine
46 EXPECT_EQ(iter1, nullptr);
47
48 // Case 2: Invalid number of values for translate
49 // Create objects for the tensor ops
50 std::shared_ptr<TensorTransform> affine2(new vision::RandomAffine({0.0, 0.0}, {1, 1, 1, 1, 1}));
51 auto ds2 = ds->Map({affine2});
52 EXPECT_NE(ds2, nullptr);
53 // Create an iterator over the result of the above dataset
54 std::shared_ptr<Iterator> iter2 = ds2->CreateIterator();
55 // Expect failure: invalid input for RandomAffine
56 EXPECT_EQ(iter2, nullptr);
57
58 // Case 3: Invalid number of values for shear
59 // Create objects for the tensor ops
60 std::shared_ptr<TensorTransform> affine3(new vision::RandomAffine({30.0, 30.0}, {0.0, 0.0}, {2.0, 2.0}, {10.0}));
61 auto ds3 = ds->Map({affine3});
62 EXPECT_NE(ds3, nullptr);
63 // Create an iterator over the result of the above dataset
64 std::shared_ptr<Iterator> iter3 = ds3->CreateIterator();
65 // Expect failure: invalid input for RandomAffine
66 EXPECT_EQ(iter3, nullptr);
67 }
68
TEST_F(MindDataTestPipeline,TestRandomAffineSuccess1)69 TEST_F(MindDataTestPipeline, TestRandomAffineSuccess1) {
70 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomAffineSuccess1 with non-default parameters.";
71
72 // Create an ImageFolder Dataset
73 std::string folder_path = datasets_root_path_ + "/testPK/data/";
74 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
75 EXPECT_NE(ds, nullptr);
76
77 // Create a Repeat operation on ds
78 int32_t repeat_num = 2;
79 ds = ds->Repeat(repeat_num);
80 EXPECT_NE(ds, nullptr);
81
82 // Create objects for the tensor ops
83 std::shared_ptr<TensorTransform> affine(
84 new vision::RandomAffine({30.0, 30.0}, {-1.0, 1.0, -1.0, 1.0}, {2.0, 2.0}, {10.0, 10.0, 20.0, 20.0}));
85
86 // Create a Map operation on ds
87 ds = ds->Map({affine});
88 EXPECT_NE(ds, nullptr);
89
90 // Create a Batch operation on ds
91 int32_t batch_size = 1;
92 ds = ds->Batch(batch_size);
93 EXPECT_NE(ds, nullptr);
94
95 // Create an iterator over the result of the above dataset
96 // This will trigger the creation of the Execution Tree and launch it.
97 std::shared_ptr<Iterator> iter = ds->CreateIterator();
98 EXPECT_NE(iter, nullptr);
99
100 // Iterate the dataset and get each row
101 std::unordered_map<std::string, mindspore::MSTensor> row;
102 ASSERT_OK(iter->GetNextRow(&row));
103
104 uint64_t i = 0;
105 while (row.size() != 0) {
106 i++;
107 auto image = row["image"];
108 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
109 ASSERT_OK(iter->GetNextRow(&row));
110 }
111
112 EXPECT_EQ(i, 20);
113
114 // Manually terminate the pipeline
115 iter->Stop();
116 }
117
TEST_F(MindDataTestPipeline,TestRandomAffineSuccess2)118 TEST_F(MindDataTestPipeline, TestRandomAffineSuccess2) {
119 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomAffineSuccess2 with default parameters.";
120
121 // Create an ImageFolder Dataset
122 std::string folder_path = datasets_root_path_ + "/testPK/data/";
123 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
124 EXPECT_NE(ds, nullptr);
125
126 // Create a Repeat operation on ds
127 int32_t repeat_num = 2;
128 ds = ds->Repeat(repeat_num);
129 EXPECT_NE(ds, nullptr);
130
131 // Create objects for the tensor ops
132 std::shared_ptr<TensorTransform> affine(new vision::RandomAffine({0.0, 0.0}));
133
134 // Create a Map operation on ds
135 ds = ds->Map({affine});
136 EXPECT_NE(ds, nullptr);
137
138 // Create a Batch operation on ds
139 int32_t batch_size = 1;
140 ds = ds->Batch(batch_size);
141 EXPECT_NE(ds, nullptr);
142
143 // Create an iterator over the result of the above dataset
144 // This will trigger the creation of the Execution Tree and launch it.
145 std::shared_ptr<Iterator> iter = ds->CreateIterator();
146 EXPECT_NE(iter, nullptr);
147
148 // Iterate the dataset and get each row
149 std::unordered_map<std::string, mindspore::MSTensor> row;
150 ASSERT_OK(iter->GetNextRow(&row));
151
152 uint64_t i = 0;
153 while (row.size() != 0) {
154 i++;
155 auto image = row["image"];
156 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
157 ASSERT_OK(iter->GetNextRow(&row));
158 }
159
160 EXPECT_EQ(i, 20);
161
162 // Manually terminate the pipeline
163 iter->Stop();
164 }
165
TEST_F(MindDataTestPipeline,TestRandomColor)166 TEST_F(MindDataTestPipeline, TestRandomColor) {
167 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomColor with non-default parameters.";
168
169 // Create an ImageFolder Dataset
170 std::string folder_path = datasets_root_path_ + "/testPK/data/";
171 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
172 EXPECT_NE(ds, nullptr);
173
174 // Create a Repeat operation on ds
175 int32_t repeat_num = 2;
176 ds = ds->Repeat(repeat_num);
177 EXPECT_NE(ds, nullptr);
178
179 // Create objects for the tensor ops
180 // Valid case: Set lower bound and upper bound to be the same value zero
181 std::shared_ptr<TensorTransform> random_color_op_1 = std::make_shared<vision::RandomColor>(0.0, 0.0);
182
183 // Valid case: Set lower bound as zero and less than upper bound
184 std::shared_ptr<TensorTransform> random_color_op_2 = std::make_shared<vision::RandomColor>(0.0, 1.1);
185
186 // Create a Map operation on ds
187 ds = ds->Map({random_color_op_1, random_color_op_2});
188 EXPECT_NE(ds, nullptr);
189
190 // Create a Batch operation on ds
191 int32_t batch_size = 1;
192 ds = ds->Batch(batch_size);
193 EXPECT_NE(ds, nullptr);
194
195 // Create an iterator over the result of the above dataset
196 // This will trigger the creation of the Execution Tree and launch it.
197 std::shared_ptr<Iterator> iter = ds->CreateIterator();
198 EXPECT_NE(iter, nullptr);
199
200 // Iterate the dataset and get each row
201 std::unordered_map<std::string, mindspore::MSTensor> row;
202 ASSERT_OK(iter->GetNextRow(&row));
203
204 uint64_t i = 0;
205 while (row.size() != 0) {
206 i++;
207 auto image = row["image"];
208 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
209 ASSERT_OK(iter->GetNextRow(&row));
210 }
211
212 EXPECT_EQ(i, 20);
213
214 // Manually terminate the pipeline
215 iter->Stop();
216 }
217
TEST_F(MindDataTestPipeline,TestRandomColorAdjust)218 TEST_F(MindDataTestPipeline, TestRandomColorAdjust) {
219 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomColorAdjust.";
220
221 // Create an ImageFolder Dataset
222 std::string folder_path = datasets_root_path_ + "/testPK/data/";
223 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
224 EXPECT_NE(ds, nullptr);
225
226 // Create a Repeat operation on ds
227 int32_t repeat_num = 2;
228 ds = ds->Repeat(repeat_num);
229 EXPECT_NE(ds, nullptr);
230
231 // Create objects for the tensor ops
232 // Use single value for vectors
233 std::shared_ptr<TensorTransform> random_color_adjust1(new vision::RandomColorAdjust({1.0}, {0.0}, {0.5}, {0.5}));
234
235 // Use same 2 values for vectors
236 std::shared_ptr<TensorTransform> random_color_adjust2(
237 new vision::RandomColorAdjust({1.0, 1.0}, {0.0, 0.0}, {0.5, 0.5}, {0.5, 0.5}));
238
239 // Use different 2 value for vectors
240 std::shared_ptr<TensorTransform> random_color_adjust3(
241 new vision::RandomColorAdjust({0.5, 1.0}, {0.0, 0.5}, {0.25, 0.5}, {0.25, 0.5}));
242
243 // Use default input values
244 std::shared_ptr<TensorTransform> random_color_adjust4(new vision::RandomColorAdjust());
245
246 // Use subset of explicitly set parameters
247 std::shared_ptr<TensorTransform> random_color_adjust5(new vision::RandomColorAdjust({0.0, 0.5}, {0.25}));
248
249 // Create a Map operation on ds
250 ds = ds->Map(
251 {random_color_adjust1, random_color_adjust2, random_color_adjust3, random_color_adjust4, random_color_adjust5});
252 EXPECT_NE(ds, nullptr);
253
254 // Create a Batch operation on ds
255 int32_t batch_size = 1;
256 ds = ds->Batch(batch_size);
257 EXPECT_NE(ds, nullptr);
258
259 // Create an iterator over the result of the above dataset
260 // This will trigger the creation of the Execution Tree and launch it.
261 std::shared_ptr<Iterator> iter = ds->CreateIterator();
262 EXPECT_NE(iter, nullptr);
263
264 // Iterate the dataset and get each row
265 std::unordered_map<std::string, mindspore::MSTensor> row;
266 ASSERT_OK(iter->GetNextRow(&row));
267
268 uint64_t i = 0;
269 while (row.size() != 0) {
270 i++;
271 auto image = row["image"];
272 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
273 ASSERT_OK(iter->GetNextRow(&row));
274 }
275
276 EXPECT_EQ(i, 20);
277
278 // Manually terminate the pipeline
279 iter->Stop();
280 }
281
TEST_F(MindDataTestPipeline,TestRandomCropSuccess)282 TEST_F(MindDataTestPipeline, TestRandomCropSuccess) {
283 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropSuccess.";
284 // Create an VOC Dataset
285 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
286 std::shared_ptr<Dataset> ds =
287 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 10));
288 EXPECT_NE(ds, nullptr);
289
290 // Create objects for the tensor ops
291 // Testing size of size vector is 1
292 std::shared_ptr<TensorTransform> random_crop(new vision::RandomCrop({20}));
293
294 // Testing size of size vector is 2
295 std::shared_ptr<TensorTransform> random_crop1(new vision::RandomCrop({20, 20}));
296
297 // Testing size of paddiing vector is 1
298 std::shared_ptr<TensorTransform> random_crop2(new vision::RandomCrop({20, 20}, {10}));
299
300 // Testing size of paddiing vector is 2
301 std::shared_ptr<TensorTransform> random_crop3(new vision::RandomCrop({20, 20}, {10, 20}));
302
303 // Testing size of paddiing vector is 2
304 std::shared_ptr<TensorTransform> random_crop4(new vision::RandomCrop({20, 20}, {10, 10, 10, 10}));
305
306 // Testing size of fill_value vector is 1
307 std::shared_ptr<TensorTransform> random_crop5(new vision::RandomCrop({20, 20}, {10, 10, 10, 10}, false, {5}));
308
309 // Testing size of fill_value vector is 3
310 std::shared_ptr<TensorTransform> random_crop6(new vision::RandomCrop({20, 20}, {10, 10, 10, 10}, false, {4, 4, 4}));
311
312 // Create a Map operation on ds
313 ds = ds->Map({random_crop, random_crop1, random_crop2, random_crop3, random_crop4, random_crop5, random_crop6},
314 {"image"});
315 EXPECT_NE(ds, nullptr);
316
317 // Create an iterator over the result of the above dataset
318 // This will trigger the creation of the Execution Tree and launch it.
319 std::shared_ptr<Iterator> iter = ds->CreateIterator();
320 EXPECT_NE(iter, nullptr);
321
322 // Iterate the dataset and get each row
323 std::unordered_map<std::string, mindspore::MSTensor> row;
324 ASSERT_OK(iter->GetNextRow(&row));
325
326 uint64_t i = 0;
327 while (row.size() != 0) {
328 i++;
329 auto image = row["image"];
330 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
331 ASSERT_OK(iter->GetNextRow(&row));
332 }
333
334 EXPECT_EQ(i, 10);
335 // Manually terminate the pipeline
336 iter->Stop();
337 }
338
TEST_F(MindDataTestPipeline,TestRandomCropWithMultiField)339 TEST_F(MindDataTestPipeline, TestRandomCropWithMultiField) {
340 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropWithMultiField.";
341 // Create an VOC Dataset
342 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
343 std::shared_ptr<Dataset> ds =
344 VOC(folder_path, "Segmentation", "train", {}, true, std::make_shared<SequentialSampler>(0, 1));
345 EXPECT_NE(ds, nullptr);
346
347 // Create objects for the tensor ops
348 transforms::Duplicate duplicate = transforms::Duplicate();
349 std::shared_ptr<TensorTransform> random_crop(new mindspore::dataset::vision::RandomCrop({500, 500}));
350
351 // Create a Map operation on ds
352 ds = ds->Map({duplicate}, {"image"}, {"image", "image_copy"});
353 EXPECT_NE(ds, nullptr);
354
355 ds = ds->Map({random_crop}, {"image", "image_copy"}, {"image", "image_copy"});
356 EXPECT_NE(ds, nullptr);
357
358 // Create an iterator over the result of the above dataset
359 // This will trigger the creation of the Execution Tree and launch it.
360 std::shared_ptr<Iterator> iter = ds->CreateIterator();
361 EXPECT_NE(iter, nullptr);
362
363 // Iterate the dataset and get each row
364 std::unordered_map<std::string, mindspore::MSTensor> row;
365 ASSERT_OK(iter->GetNextRow(&row));
366
367 uint64_t i = 0;
368 while (row.size() != 0) {
369 i++;
370 auto image = row["image"];
371 auto image_copy = row["image_copy"];
372 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
373 MS_LOG(INFO) << "Tensor image_copy shape: " << image_copy.Shape();
374 ASSERT_OK(iter->GetNextRow(&row));
375 }
376
377 EXPECT_EQ(i, 1);
378 // Manually terminate the pipeline
379 iter->Stop();
380 }
381
TEST_F(MindDataTestPipeline,TestRandomCropFail)382 TEST_F(MindDataTestPipeline, TestRandomCropFail) {
383 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropFail with invalid parameters.";
384 // Create an VOC Dataset
385 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
386 std::shared_ptr<Dataset> ds =
387 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
388 EXPECT_NE(ds, nullptr);
389
390 // Case 1: Testing the size parameter is negative.
391 // Create objects for the tensor ops
392 std::shared_ptr<TensorTransform> random_crop1(new vision::RandomCrop({-28, 28}));
393 auto ds1 = ds->Map({random_crop1});
394 EXPECT_NE(ds1, nullptr);
395 // Create an iterator over the result of the above dataset
396 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
397 // Expect failure: invalid input for RandomCrop
398 EXPECT_EQ(iter1, nullptr);
399
400 // Case 2: Testing the size parameter is None.
401 // Create objects for the tensor ops
402 std::shared_ptr<TensorTransform> random_crop2(new vision::RandomCrop({}));
403 auto ds2 = ds->Map({random_crop2});
404 EXPECT_NE(ds2, nullptr);
405 // Create an iterator over the result of the above dataset
406 std::shared_ptr<Iterator> iter2 = ds2->CreateIterator();
407 // Expect failure: invalid input for RandomCrop
408 EXPECT_EQ(iter2, nullptr);
409
410 // Case 3: Testing the size of size vector is 3.
411 // Create objects for the tensor ops
412 std::shared_ptr<TensorTransform> random_crop3(new vision::RandomCrop({28, 28, 28}));
413 auto ds3 = ds->Map({random_crop3});
414 EXPECT_NE(ds3, nullptr);
415 // Create an iterator over the result of the above dataset
416 std::shared_ptr<Iterator> iter3 = ds3->CreateIterator();
417 // Expect failure: invalid input for RandomCrop
418 EXPECT_EQ(iter3, nullptr);
419
420 // Case 4: Testing the padding parameter is negative.
421 // Create objects for the tensor ops
422 std::shared_ptr<TensorTransform> random_crop4(new vision::RandomCrop({28, 28}, {-5}));
423 auto ds4 = ds->Map({random_crop4});
424 EXPECT_NE(ds4, nullptr);
425 // Create an iterator over the result of the above dataset
426 std::shared_ptr<Iterator> iter4 = ds4->CreateIterator();
427 // Expect failure: invalid input for RandomCrop
428 EXPECT_EQ(iter4, nullptr);
429
430 // Case 5: Testing the size of padding vector is empty.
431 // Create objects for the tensor ops
432 std::shared_ptr<TensorTransform> random_crop5(new vision::RandomCrop({28, 28}, {}));
433 auto ds5 = ds->Map({random_crop5});
434 EXPECT_NE(ds5, nullptr);
435 // Create an iterator over the result of the above dataset
436 std::shared_ptr<Iterator> iter5 = ds5->CreateIterator();
437 // Expect failure: invalid input for RandomCrop
438 EXPECT_EQ(iter5, nullptr);
439
440 // Case 6: Testing the size of padding vector is 3.
441 // Create objects for the tensor ops
442 std::shared_ptr<TensorTransform> random_crop6(new vision::RandomCrop({28, 28}, {5, 5, 5}));
443 auto ds6 = ds->Map({random_crop6});
444 EXPECT_NE(ds6, nullptr);
445 // Create an iterator over the result of the above dataset
446 std::shared_ptr<Iterator> iter6 = ds6->CreateIterator();
447 // Expect failure: invalid input for RandomCrop
448 EXPECT_EQ(iter6, nullptr);
449
450 // Case 7: Testing the size of padding vector is 5.
451 // Create objects for the tensor ops
452 std::shared_ptr<TensorTransform> random_crop7(new vision::RandomCrop({28, 28}, {5, 5, 5, 5, 5}));
453 auto ds7 = ds->Map({random_crop7});
454 EXPECT_NE(ds7, nullptr);
455 // Create an iterator over the result of the above dataset
456 std::shared_ptr<Iterator> iter7 = ds7->CreateIterator();
457 // Expect failure: invalid input for RandomCrop
458 EXPECT_EQ(iter7, nullptr);
459
460 // Case 8: Testing the size of fill_value vector is empty.
461 // Create objects for the tensor ops
462 std::shared_ptr<TensorTransform> random_crop8(new vision::RandomCrop({28, 28}, {0, 0, 0, 0}, false, {}));
463 auto ds8 = ds->Map({random_crop8});
464 EXPECT_NE(ds8, nullptr);
465 // Create an iterator over the result of the above dataset
466 std::shared_ptr<Iterator> iter8 = ds8->CreateIterator();
467 // Expect failure: invalid input for RandomCrop
468 EXPECT_EQ(iter8, nullptr);
469
470 // Case 9: Testing the size of fill_value vector is 2.
471 // Create objects for the tensor ops
472 std::shared_ptr<TensorTransform> random_crop9(new vision::RandomCrop({28, 28}, {0, 0, 0, 0}, false, {0, 0}));
473 auto ds9 = ds->Map({random_crop9});
474 EXPECT_NE(ds9, nullptr);
475 // Create an iterator over the result of the above dataset
476 std::shared_ptr<Iterator> iter9 = ds9->CreateIterator();
477 // Expect failure: invalid input for RandomCrop
478 EXPECT_EQ(iter9, nullptr);
479
480 // Case 10: Testing the size of fill_value vector is 4.
481 // Create objects for the tensor ops
482 std::shared_ptr<TensorTransform> random_crop10(new vision::RandomCrop({28, 28}, {0, 0, 0, 0}, false, {0, 0, 0, 0}));
483 auto ds10 = ds->Map({random_crop10});
484 EXPECT_NE(ds10, nullptr);
485 // Create an iterator over the result of the above dataset
486 std::shared_ptr<Iterator> iter10 = ds10->CreateIterator();
487 // Expect failure: invalid input for RandomCrop
488 EXPECT_EQ(iter10, nullptr);
489 }
490
TEST_F(MindDataTestPipeline,TestRandomCropWithBboxSuccess)491 TEST_F(MindDataTestPipeline, TestRandomCropWithBboxSuccess) {
492 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropWithBboxSuccess.";
493 // Create an VOC Dataset
494 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
495 std::shared_ptr<Dataset> ds =
496 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
497 EXPECT_NE(ds, nullptr);
498
499 // Create objects for the tensor ops
500 std::shared_ptr<TensorTransform> random_crop(new mindspore::dataset::vision::RandomCropWithBBox({128, 128}));
501
502 // Create a Map operation on ds
503 ds = ds->Map({random_crop}, {"image", "bbox"}, {"image", "bbox"}, {"image", "bbox"});
504 EXPECT_NE(ds, nullptr);
505
506 // Create an iterator over the result of the above dataset
507 // This will trigger the creation of the Execution Tree and launch it.
508 std::shared_ptr<Iterator> iter = ds->CreateIterator();
509 EXPECT_NE(iter, nullptr);
510
511 // Iterate the dataset and get each row
512 std::unordered_map<std::string, mindspore::MSTensor> row;
513 ASSERT_OK(iter->GetNextRow(&row));
514
515 uint64_t i = 0;
516 while (row.size() != 0) {
517 i++;
518 auto image = row["image"];
519 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
520 EXPECT_EQ(image.Shape()[0], 128);
521 EXPECT_EQ(image.Shape()[1], 128);
522 ASSERT_OK(iter->GetNextRow(&row));
523 }
524
525 EXPECT_EQ(i, 3);
526 // Manually terminate the pipeline
527 iter->Stop();
528 }
529
TEST_F(MindDataTestPipeline,TestRandomCropWithBboxFail)530 TEST_F(MindDataTestPipeline, TestRandomCropWithBboxFail) {
531 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropWithBboxFail with invalid parameters.";
532 // Create an VOC Dataset
533 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
534 std::shared_ptr<Dataset> ds =
535 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
536 EXPECT_NE(ds, nullptr);
537
538 // Case 1: The size parameter is negative.
539 // Create objects for the tensor ops
540 std::shared_ptr<TensorTransform> random_crop1(new vision::RandomCropWithBBox({-10}));
541 auto ds1 = ds->Map({random_crop1});
542 EXPECT_NE(ds1, nullptr);
543 // Create an iterator over the result of the above dataset
544 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
545 // Expect failure: invalid input for RandomCropWithBBox
546 EXPECT_EQ(iter1, nullptr);
547
548 // Case 2: The parameter in the padding vector is negative.
549 // Create objects for the tensor ops
550 std::shared_ptr<TensorTransform> random_crop2(new vision::RandomCropWithBBox({10, 10}, {-2, 2, 2, 2}));
551 auto ds2 = ds->Map({random_crop2});
552 EXPECT_NE(ds2, nullptr);
553 // Create an iterator over the result of the above dataset
554 std::shared_ptr<Iterator> iter2 = ds2->CreateIterator();
555 // Expect failure: invalid input for RandomCropWithBBox
556 EXPECT_EQ(iter2, nullptr);
557
558 // Case 3: The size container is empty.
559 // Create objects for the tensor ops
560 std::shared_ptr<TensorTransform> random_crop3(new vision::RandomCropWithBBox({}));
561 auto ds3 = ds->Map({random_crop3});
562 EXPECT_NE(ds3, nullptr);
563 // Create an iterator over the result of the above dataset
564 std::shared_ptr<Iterator> iter3 = ds3->CreateIterator();
565 // Expect failure: invalid input for RandomCropWithBBox
566 EXPECT_EQ(iter3, nullptr);
567
568 // Case 4: The size of the size container is too large.
569 // Create objects for the tensor ops
570 std::shared_ptr<TensorTransform> random_crop4(new vision::RandomCropWithBBox({10, 10, 10}));
571 auto ds4 = ds->Map({random_crop4});
572 EXPECT_NE(ds4, nullptr);
573 // Create an iterator over the result of the above dataset
574 std::shared_ptr<Iterator> iter4 = ds4->CreateIterator();
575 // Expect failure: invalid input for RandomCropWithBBox
576 EXPECT_EQ(iter4, nullptr);
577
578 // Case 5: The padding container is empty.
579 // Create objects for the tensor ops
580 std::shared_ptr<TensorTransform> random_crop5(new vision::RandomCropWithBBox({10, 10}, {}));
581 auto ds5 = ds->Map({random_crop5});
582 EXPECT_NE(ds5, nullptr);
583 // Create an iterator over the result of the above dataset
584 std::shared_ptr<Iterator> iter5 = ds5->CreateIterator();
585 // Expect failure: invalid input for RandomCropWithBBox
586 EXPECT_EQ(iter5, nullptr);
587
588 // Case 6: The size of the padding container is too large.
589 // Create objects for the tensor ops
590 std::shared_ptr<TensorTransform> random_crop6(new vision::RandomCropWithBBox({10, 10}, {5, 5, 5, 5, 5}));
591 auto ds6 = ds->Map({random_crop6});
592 EXPECT_NE(ds6, nullptr);
593 // Create an iterator over the result of the above dataset
594 std::shared_ptr<Iterator> iter6 = ds6->CreateIterator();
595 // Expect failure: invalid input for RandomCropWithBBox
596 EXPECT_EQ(iter6, nullptr);
597
598 // Case 7: The fill_value container is empty.
599 // Create objects for the tensor ops
600 std::shared_ptr<TensorTransform> random_crop7(new vision::RandomCropWithBBox({10, 10}, {5, 5, 5, 5}, false, {}));
601 auto ds7 = ds->Map({random_crop7});
602 EXPECT_NE(ds7, nullptr);
603 // Create an iterator over the result of the above dataset
604 std::shared_ptr<Iterator> iter7 = ds7->CreateIterator();
605 // Expect failure: invalid input for RandomCropWithBBox
606 EXPECT_EQ(iter7, nullptr);
607
608 // Case 8: The size of the fill_value container is too large.
609 // Create objects for the tensor ops
610 std::shared_ptr<TensorTransform> random_crop8(
611 new vision::RandomCropWithBBox({10, 10}, {5, 5, 5, 5}, false, {3, 3, 3, 3}));
612 auto ds8 = ds->Map({random_crop8});
613 EXPECT_NE(ds8, nullptr);
614 // Create an iterator over the result of the above dataset
615 std::shared_ptr<Iterator> iter8 = ds8->CreateIterator();
616 // Expect failure: invalid input for RandomCropWithBBox
617 EXPECT_EQ(iter8, nullptr);
618 }
619
TEST_F(MindDataTestPipeline,TestRandomHorizontalFlipWithBBoxSuccess)620 TEST_F(MindDataTestPipeline, TestRandomHorizontalFlipWithBBoxSuccess) {
621 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomHorizontalFlipWithBBoxSuccess.";
622 // Create an VOC Dataset
623 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
624 std::shared_ptr<Dataset> ds =
625 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
626 EXPECT_NE(ds, nullptr);
627
628 // Create objects for the tensor ops
629 std::shared_ptr<TensorTransform> random_horizontal_flip_op =
630 std::make_shared<vision::RandomHorizontalFlipWithBBox>(0.5);
631
632 // Create a Map operation on ds
633 ds = ds->Map({random_horizontal_flip_op}, {"image", "bbox"}, {"image", "bbox"}, {"image", "bbox"});
634 EXPECT_NE(ds, nullptr);
635
636 // Create an iterator over the result of the above dataset
637 // This will trigger the creation of the Execution Tree and launch it.
638 std::shared_ptr<Iterator> iter = ds->CreateIterator();
639 EXPECT_NE(iter, nullptr);
640
641 // Iterate the dataset and get each row
642 std::unordered_map<std::string, mindspore::MSTensor> row;
643 ASSERT_OK(iter->GetNextRow(&row));
644
645 uint64_t i = 0;
646 while (row.size() != 0) {
647 i++;
648 auto image = row["image"];
649 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
650 ASSERT_OK(iter->GetNextRow(&row));
651 }
652
653 EXPECT_EQ(i, 3);
654 // Manually terminate the pipeline
655 iter->Stop();
656 }
657
TEST_F(MindDataTestPipeline,TestRandomHorizontalAndVerticalFlip)658 TEST_F(MindDataTestPipeline, TestRandomHorizontalAndVerticalFlip) {
659 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomHorizontalAndVerticalFlip for horizontal and vertical flips.";
660
661 // Create an ImageFolder Dataset
662 std::string folder_path = datasets_root_path_ + "/testPK/data/";
663 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
664 EXPECT_NE(ds, nullptr);
665
666 // Create a Repeat operation on ds
667 int32_t repeat_num = 2;
668 ds = ds->Repeat(repeat_num);
669 EXPECT_NE(ds, nullptr);
670
671 // Create objects for the tensor ops
672 std::shared_ptr<TensorTransform> random_vertical_flip_op = std::make_shared<vision::RandomVerticalFlip>(0.75);
673 std::shared_ptr<TensorTransform> random_horizontal_flip_op = std::make_shared<vision::RandomHorizontalFlip>(0.5);
674
675 // Create a Map operation on ds
676 ds = ds->Map({random_vertical_flip_op, random_horizontal_flip_op});
677 EXPECT_NE(ds, nullptr);
678
679 // Create a Batch operation on ds
680 int32_t batch_size = 1;
681 ds = ds->Batch(batch_size);
682 EXPECT_NE(ds, nullptr);
683
684 // Create an iterator over the result of the above dataset
685 // This will trigger the creation of the Execution Tree and launch it.
686 std::shared_ptr<Iterator> iter = ds->CreateIterator();
687 EXPECT_NE(iter, nullptr);
688
689 // Iterate the dataset and get each row
690 std::unordered_map<std::string, mindspore::MSTensor> row;
691 ASSERT_OK(iter->GetNextRow(&row));
692
693 uint64_t i = 0;
694 while (row.size() != 0) {
695 i++;
696 auto image = row["image"];
697 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
698 ASSERT_OK(iter->GetNextRow(&row));
699 }
700
701 EXPECT_EQ(i, 20);
702
703 // Manually terminate the pipeline
704 iter->Stop();
705 }
706
TEST_F(MindDataTestPipeline,TestRandomResizeWithMultiField)707 TEST_F(MindDataTestPipeline, TestRandomResizeWithMultiField) {
708 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizeWithMultiField with single integer input.";
709
710 // Create an ImageFolder Dataset
711 std::string folder_path = datasets_root_path_ + "/testPK/data/";
712 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 1));
713 EXPECT_NE(ds, nullptr);
714
715 // Create objects for the tensor ops
716 transforms::Duplicate duplicate = transforms::Duplicate();
717 std::shared_ptr<TensorTransform> random_resize(new vision::RandomResize({100}));
718
719 // Create a Map operation on ds
720 ds = ds->Map({duplicate}, {"image"}, {"image", "image_copy"});
721 EXPECT_NE(ds, nullptr);
722
723 ds = ds->Map({random_resize}, {"image", "image_copy"}, {"image", "image_copy"});
724 EXPECT_NE(ds, nullptr);
725
726 // Create an iterator over the result of the above dataset
727 // This will trigger the creation of the Execution Tree and launch it.
728 std::shared_ptr<Iterator> iter = ds->CreateIterator();
729 EXPECT_NE(iter, nullptr);
730
731 // Iterate the dataset and get each row
732 std::unordered_map<std::string, mindspore::MSTensor> row;
733 ASSERT_OK(iter->GetNextRow(&row));
734
735 uint64_t i = 0;
736 while (row.size() != 0) {
737 i++;
738 auto image = row["image"];
739 auto image_copy = row["image_copy"];
740 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
741 MS_LOG(INFO) << "Tensor image_copy shape: " << image_copy.Shape();
742 ASSERT_OK(iter->GetNextRow(&row));
743 }
744
745 EXPECT_EQ(i, 1);
746
747 // Manually terminate the pipeline
748 iter->Stop();
749 }
750
TEST_F(MindDataTestPipeline,TestRandomPosterizeSuccess1)751 TEST_F(MindDataTestPipeline, TestRandomPosterizeSuccess1) {
752 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomPosterizeSuccess1 with non-default parameters.";
753
754 // Create an ImageFolder Dataset
755 std::string folder_path = datasets_root_path_ + "/testPK/data/";
756 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
757 EXPECT_NE(ds, nullptr);
758
759 // Create a Repeat operation on ds
760 int32_t repeat_num = 2;
761 ds = ds->Repeat(repeat_num);
762 EXPECT_NE(ds, nullptr);
763
764 // Create objects for the tensor ops
765 std::shared_ptr<TensorTransform> posterize(new vision::RandomPosterize({1, 4}));
766
767 // Create a Map operation on ds
768 ds = ds->Map({posterize});
769 EXPECT_NE(ds, nullptr);
770
771 // Create a Batch operation on ds
772 int32_t batch_size = 1;
773 ds = ds->Batch(batch_size);
774 EXPECT_NE(ds, nullptr);
775
776 // Create an iterator over the result of the above dataset
777 // This will trigger the creation of the Execution Tree and launch it.
778 std::shared_ptr<Iterator> iter = ds->CreateIterator();
779 EXPECT_NE(iter, nullptr);
780
781 // Iterate the dataset and get each row
782 std::unordered_map<std::string, mindspore::MSTensor> row;
783 ASSERT_OK(iter->GetNextRow(&row));
784
785 uint64_t i = 0;
786 while (row.size() != 0) {
787 i++;
788 auto image = row["image"];
789 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
790 ASSERT_OK(iter->GetNextRow(&row));
791 }
792
793 EXPECT_EQ(i, 20);
794
795 // Manually terminate the pipeline
796 iter->Stop();
797 }
798
TEST_F(MindDataTestPipeline,TestRandomPosterizeSuccess2)799 TEST_F(MindDataTestPipeline, TestRandomPosterizeSuccess2) {
800 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomPosterizeSuccess2 with default parameters.";
801
802 // Create an ImageFolder Dataset
803 std::string folder_path = datasets_root_path_ + "/testPK/data/";
804 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
805 EXPECT_NE(ds, nullptr);
806
807 // Create a Repeat operation on ds
808 int32_t repeat_num = 2;
809 ds = ds->Repeat(repeat_num);
810 EXPECT_NE(ds, nullptr);
811
812 // Create objects for the tensor ops
813 std::shared_ptr<TensorTransform> posterize(new vision::RandomPosterize());
814
815 // Create a Map operation on ds
816 ds = ds->Map({posterize});
817 EXPECT_NE(ds, nullptr);
818
819 // Create a Batch operation on ds
820 int32_t batch_size = 1;
821 ds = ds->Batch(batch_size);
822 EXPECT_NE(ds, nullptr);
823
824 // Create an iterator over the result of the above dataset
825 // This will trigger the creation of the Execution Tree and launch it.
826 std::shared_ptr<Iterator> iter = ds->CreateIterator();
827 EXPECT_NE(iter, nullptr);
828
829 // Iterate the dataset and get each row
830 std::unordered_map<std::string, mindspore::MSTensor> row;
831 ASSERT_OK(iter->GetNextRow(&row));
832
833 uint64_t i = 0;
834 while (row.size() != 0) {
835 i++;
836 auto image = row["image"];
837 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
838 ASSERT_OK(iter->GetNextRow(&row));
839 }
840
841 EXPECT_EQ(i, 20);
842
843 // Manually terminate the pipeline
844 iter->Stop();
845 }
846
TEST_F(MindDataTestPipeline,TestRandomResizeSuccess1)847 TEST_F(MindDataTestPipeline, TestRandomResizeSuccess1) {
848 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizeSuccess1 with single integer input.";
849
850 // Create an ImageFolder Dataset
851 std::string folder_path = datasets_root_path_ + "/testPK/data/";
852 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 5));
853 EXPECT_NE(ds, nullptr);
854
855 // Create objects for the tensor ops
856 std::shared_ptr<TensorTransform> random_resize(new vision::RandomResize({66}));
857
858 // Create a Map operation on ds
859 ds = ds->Map({random_resize}, {"image"});
860 EXPECT_NE(ds, nullptr);
861
862 // Create an iterator over the result of the above dataset
863 // This will trigger the creation of the Execution Tree and launch it.
864 std::shared_ptr<Iterator> iter = ds->CreateIterator();
865 EXPECT_NE(iter, nullptr);
866
867 // Iterate the dataset and get each row
868 std::unordered_map<std::string, mindspore::MSTensor> row;
869 ASSERT_OK(iter->GetNextRow(&row));
870
871 uint64_t i = 0;
872 while (row.size() != 0) {
873 i++;
874 auto image = row["image"];
875 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
876 EXPECT_EQ(image.Shape()[0] == 66, true);
877 ASSERT_OK(iter->GetNextRow(&row));
878 }
879
880 EXPECT_EQ(i, 5);
881
882 // Manually terminate the pipeline
883 iter->Stop();
884 }
885
TEST_F(MindDataTestPipeline,TestRandomResizeSuccess2)886 TEST_F(MindDataTestPipeline, TestRandomResizeSuccess2) {
887 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizeSuccess2 with (height, width) input.";
888
889 // Create an ImageFolder Dataset
890 std::string folder_path = datasets_root_path_ + "/testPK/data/";
891 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 3));
892 EXPECT_NE(ds, nullptr);
893
894 // Create a Repeat operation on ds
895 int32_t repeat_num = 2;
896 ds = ds->Repeat(repeat_num);
897 EXPECT_NE(ds, nullptr);
898
899 // Create objects for the tensor ops
900 std::shared_ptr<TensorTransform> random_resize(new vision::RandomResize({66, 77}));
901
902 // Create a Map operation on ds
903 ds = ds->Map({random_resize}, {"image"});
904 EXPECT_NE(ds, nullptr);
905
906 // Create an iterator over the result of the above dataset
907 // This will trigger the creation of the Execution Tree and launch it.
908 std::shared_ptr<Iterator> iter = ds->CreateIterator();
909 EXPECT_NE(iter, nullptr);
910
911 // Iterate the dataset and get each row
912 std::unordered_map<std::string, mindspore::MSTensor> row;
913 ASSERT_OK(iter->GetNextRow(&row));
914
915 uint64_t i = 0;
916 while (row.size() != 0) {
917 i++;
918 auto image = row["image"];
919 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
920 EXPECT_EQ(image.Shape()[0] == 66 && image.Shape()[1] == 77, true);
921 ASSERT_OK(iter->GetNextRow(&row));
922 }
923
924 EXPECT_EQ(i, 6);
925
926 // Manually terminate the pipeline
927 iter->Stop();
928 }
929
TEST_F(MindDataTestPipeline,TestRandomResizeWithBBoxSuccess1)930 TEST_F(MindDataTestPipeline, TestRandomResizeWithBBoxSuccess1) {
931 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizeWithBBoxSuccess1 with single integer input.";
932 // setting seed here to prevent random core dump
933 uint32_t current_seed = config::get_seed();
934 config::set_seed(327362);
935
936 // Create an VOC Dataset
937 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
938 std::shared_ptr<Dataset> ds =
939 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
940 EXPECT_NE(ds, nullptr);
941
942 // Create objects for the tensor ops
943 std::shared_ptr<TensorTransform> random_resize(new vision::RandomResizeWithBBox({88}));
944
945 // Create a Map operation on ds
946 ds = ds->Map({random_resize}, {"image", "bbox"});
947 EXPECT_NE(ds, nullptr);
948
949 // Create an iterator over the result of the above dataset
950 // This will trigger the creation of the Execution Tree and launch it.
951 std::shared_ptr<Iterator> iter = ds->CreateIterator();
952 EXPECT_NE(iter, nullptr);
953
954 // Iterate the dataset and get each row
955 std::unordered_map<std::string, mindspore::MSTensor> row;
956 ASSERT_OK(iter->GetNextRow(&row));
957
958 uint64_t i = 0;
959 while (row.size() != 0) {
960 i++;
961 auto image = row["image"];
962 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
963 EXPECT_EQ(image.Shape()[0] == 88, true);
964 ASSERT_OK(iter->GetNextRow(&row));
965 }
966
967 EXPECT_EQ(i, 3);
968
969 // Manually terminate the pipeline
970 iter->Stop();
971 config::set_seed(current_seed);
972 }
973
TEST_F(MindDataTestPipeline,TestRandomResizeWithBBoxSuccess2)974 TEST_F(MindDataTestPipeline, TestRandomResizeWithBBoxSuccess2) {
975 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizeWithBBoxSuccess2 with (height, width) input.";
976 uint32_t current_seed = config::get_seed();
977 config::set_seed(327362);
978 // Create an VOC Dataset
979 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
980 std::shared_ptr<Dataset> ds =
981 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 4));
982 EXPECT_NE(ds, nullptr);
983
984 // Create a Repeat operation on ds
985 int32_t repeat_num = 2;
986 ds = ds->Repeat(repeat_num);
987 EXPECT_NE(ds, nullptr);
988
989 // Create objects for the tensor ops
990 std::shared_ptr<TensorTransform> random_resize(new vision::RandomResizeWithBBox({88, 99}));
991
992 // Create a Map operation on ds
993 ds = ds->Map({random_resize}, {"image", "bbox"});
994 EXPECT_NE(ds, nullptr);
995
996 // Create an iterator over the result of the above dataset
997 // This will trigger the creation of the Execution Tree and launch it.
998 std::shared_ptr<Iterator> iter = ds->CreateIterator();
999 EXPECT_NE(iter, nullptr);
1000
1001 // Iterate the dataset and get each row
1002 std::unordered_map<std::string, mindspore::MSTensor> row;
1003 ASSERT_OK(iter->GetNextRow(&row));
1004
1005 uint64_t i = 0;
1006 while (row.size() != 0) {
1007 i++;
1008 auto image = row["image"];
1009 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1010 EXPECT_EQ(image.Shape()[0] == 88 && image.Shape()[1] == 99, true);
1011 ASSERT_OK(iter->GetNextRow(&row));
1012 }
1013
1014 EXPECT_EQ(i, 8);
1015
1016 // Manually terminate the pipeline
1017 iter->Stop();
1018 config::set_seed(current_seed);
1019 }
1020
TEST_F(MindDataTestPipeline,TestRandomResizedCropSuccess1)1021 TEST_F(MindDataTestPipeline, TestRandomResizedCropSuccess1) {
1022 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropSuccess1.";
1023 // Testing RandomResizedCrop with default values
1024 // Create a Cifar10 Dataset
1025 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1026 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1027 EXPECT_NE(ds, nullptr);
1028
1029 // Create objects for the tensor ops
1030 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCrop({5}));
1031
1032 // Create a Map operation on ds
1033 ds = ds->Map({random_resized_crop}, {"image"});
1034 EXPECT_NE(ds, nullptr);
1035
1036 // Create an iterator over the result of the above dataset
1037 // This will trigger the creation of the Execution Tree and launch it.
1038 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1039 EXPECT_NE(iter, nullptr);
1040
1041 // Iterate the dataset and get each row
1042 std::unordered_map<std::string, mindspore::MSTensor> row;
1043 ASSERT_OK(iter->GetNextRow(&row));
1044
1045 uint64_t i = 0;
1046 while (row.size() != 0) {
1047 i++;
1048 auto image = row["image"];
1049 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1050 EXPECT_EQ(image.Shape()[0] == 5 && image.Shape()[1] == 5, true);
1051 ASSERT_OK(iter->GetNextRow(&row));
1052 }
1053
1054 EXPECT_EQ(i, 10);
1055
1056 // Manually terminate the pipeline
1057 iter->Stop();
1058 }
1059
TEST_F(MindDataTestPipeline,TestRandomResizedCropSuccess2)1060 TEST_F(MindDataTestPipeline, TestRandomResizedCropSuccess2) {
1061 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropSuccess2.";
1062 // Testing RandomResizedCrop with non-default values
1063 // Create a Cifar10 Dataset
1064 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1065 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1066 EXPECT_NE(ds, nullptr);
1067
1068 // Create objects for the tensor ops
1069 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCrop(
1070 {5, 10}, {0.25, 0.75}, {0.5, 1.25}, mindspore::dataset::InterpolationMode::kArea, 20));
1071
1072 // Create a Map operation on ds
1073 ds = ds->Map({random_resized_crop}, {"image"});
1074 EXPECT_NE(ds, nullptr);
1075
1076 // Create an iterator over the result of the above dataset
1077 // This will trigger the creation of the Execution Tree and launch it.
1078 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1079 EXPECT_NE(iter, nullptr);
1080
1081 // Iterate the dataset and get each row
1082 std::unordered_map<std::string, mindspore::MSTensor> row;
1083 ASSERT_OK(iter->GetNextRow(&row));
1084
1085 uint64_t i = 0;
1086 while (row.size() != 0) {
1087 i++;
1088 auto image = row["image"];
1089 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1090 EXPECT_EQ(image.Shape()[0] == 5 && image.Shape()[1] == 10, true);
1091 ASSERT_OK(iter->GetNextRow(&row));
1092 }
1093
1094 EXPECT_EQ(i, 10);
1095
1096 // Manually terminate the pipeline
1097 iter->Stop();
1098 }
1099
TEST_F(MindDataTestPipeline,TestRandomResizedCropFail1)1100 TEST_F(MindDataTestPipeline, TestRandomResizedCropFail1) {
1101 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropFail1 with negative size.";
1102 // This should fail because size has negative value
1103 // Create a Cifar10 Dataset
1104 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1105 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1106 EXPECT_NE(ds, nullptr);
1107
1108 // Create objects for the tensor ops
1109 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCrop({5, -10}));
1110
1111 // Create a Map operation on ds
1112 ds = ds->Map({random_resized_crop});
1113 EXPECT_NE(ds, nullptr);
1114
1115 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1116 // Expect failure: Invalid RandomResizedCrop input
1117 EXPECT_EQ(iter, nullptr);
1118 }
1119
TEST_F(MindDataTestPipeline,TestRandomResizedCropFail2)1120 TEST_F(MindDataTestPipeline, TestRandomResizedCropFail2) {
1121 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropFail1 with invalid scale input.";
1122 // This should fail because scale isn't in {min, max} format
1123 // Create a Cifar10 Dataset
1124 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1125 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1126 EXPECT_NE(ds, nullptr);
1127
1128 // Create objects for the tensor ops
1129 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCrop({5, 10}, {4, 3}));
1130
1131 // Create a Map operation on ds
1132 ds = ds->Map({random_resized_crop});
1133 EXPECT_NE(ds, nullptr);
1134
1135 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1136 // Expect failure: Invalid RandomResizedCrop input
1137 EXPECT_EQ(iter, nullptr);
1138 }
1139
TEST_F(MindDataTestPipeline,TestRandomResizedCropFail3)1140 TEST_F(MindDataTestPipeline, TestRandomResizedCropFail3) {
1141 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropFail1 with invalid ratio input.";
1142 // This should fail because ratio isn't in {min, max} format
1143 // Create a Cifar10 Dataset
1144 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1145 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1146 EXPECT_NE(ds, nullptr);
1147
1148 // Create objects for the tensor ops
1149 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCrop({5, 10}, {4, 5}, {7, 6}));
1150
1151 // Create a Map operation on ds
1152 ds = ds->Map({random_resized_crop});
1153 EXPECT_NE(ds, nullptr);
1154
1155 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1156 // Expect failure: Invalid RandomResizedCrop input
1157 EXPECT_EQ(iter, nullptr);
1158 }
1159
TEST_F(MindDataTestPipeline,TestRandomResizedCropFail4)1160 TEST_F(MindDataTestPipeline, TestRandomResizedCropFail4) {
1161 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropFail1 with invalid scale size.";
1162 // This should fail because scale has a size of more than 2
1163 // Create a Cifar10 Dataset
1164 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1165 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1166 EXPECT_NE(ds, nullptr);
1167
1168 // Create objects for the tensor ops
1169 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCrop({5, 10, 20}, {4, 5}, {7, 6}));
1170
1171 // Create a Map operation on ds
1172 ds = ds->Map({random_resized_crop});
1173 EXPECT_NE(ds, nullptr);
1174
1175 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1176 // Expect failure: Invalid RandomResizedCrop input
1177 EXPECT_EQ(iter, nullptr);
1178 }
1179
TEST_F(MindDataTestPipeline,TestRandomResizedCropWithBBoxSuccess1)1180 TEST_F(MindDataTestPipeline, TestRandomResizedCropWithBBoxSuccess1) {
1181 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropWithBBoxSuccess1.";
1182 // Testing RandomResizedCropWithBBox with default values
1183 // Create an VOC Dataset
1184 uint32_t current_seed = config::get_seed();
1185 config::set_seed(327362);
1186 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
1187 std::shared_ptr<Dataset> ds =
1188 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 4));
1189 EXPECT_NE(ds, nullptr);
1190
1191 // Create objects for the tensor ops
1192 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCropWithBBox({5}));
1193
1194 // Create a Map operation on ds
1195 ds = ds->Map({random_resized_crop}, {"image", "bbox"});
1196 EXPECT_NE(ds, nullptr);
1197
1198 // Create an iterator over the result of the above dataset
1199 // This will trigger the creation of the Execution Tree and launch it.
1200 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1201 EXPECT_NE(iter, nullptr);
1202
1203 // Iterate the dataset and get each row
1204 std::unordered_map<std::string, mindspore::MSTensor> row;
1205 ASSERT_OK(iter->GetNextRow(&row));
1206
1207 uint64_t i = 0;
1208 while (row.size() != 0) {
1209 i++;
1210 auto image = row["image"];
1211 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1212 EXPECT_EQ(image.Shape()[0] == 5 && image.Shape()[1] == 5, true);
1213 ASSERT_OK(iter->GetNextRow(&row));
1214 }
1215
1216 EXPECT_EQ(i, 4);
1217
1218 config::set_seed(current_seed);
1219 // Manually terminate the pipeline
1220 iter->Stop();
1221 }
1222
TEST_F(MindDataTestPipeline,TestRandomResizedCropWithBBoxSuccess2)1223 TEST_F(MindDataTestPipeline, TestRandomResizedCropWithBBoxSuccess2) {
1224 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropWithBBoxSuccess2.";
1225 // Testing RandomResizedCropWithBBox with non-default values
1226 // Create an VOC Dataset
1227 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
1228 uint32_t current_seed = config::get_seed();
1229 config::set_seed(327362);
1230 std::shared_ptr<Dataset> ds =
1231 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 4));
1232 EXPECT_NE(ds, nullptr);
1233
1234 // Create objects for the tensor ops
1235 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCropWithBBox(
1236 {5, 10}, {0.25, 0.75}, {0.5, 1.25}, mindspore::dataset::InterpolationMode::kArea, 20));
1237
1238 // Create a Map operation on ds
1239 ds = ds->Map({random_resized_crop}, {"image", "bbox"});
1240 EXPECT_NE(ds, nullptr);
1241
1242 // Create an iterator over the result of the above dataset
1243 // This will trigger the creation of the Execution Tree and launch it.
1244 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1245 EXPECT_NE(iter, nullptr);
1246
1247 // Iterate the dataset and get each row
1248 std::unordered_map<std::string, mindspore::MSTensor> row;
1249 ASSERT_OK(iter->GetNextRow(&row));
1250
1251 uint64_t i = 0;
1252 while (row.size() != 0) {
1253 i++;
1254 auto image = row["image"];
1255 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1256 EXPECT_EQ(image.Shape()[0] == 5 && image.Shape()[1] == 10, true);
1257 ASSERT_OK(iter->GetNextRow(&row));
1258 }
1259
1260 EXPECT_EQ(i, 4);
1261 config::set_seed(current_seed);
1262
1263 // Manually terminate the pipeline
1264 iter->Stop();
1265 }
1266
TEST_F(MindDataTestPipeline,TestRandomResizedCropWithBBoxFail1)1267 TEST_F(MindDataTestPipeline, TestRandomResizedCropWithBBoxFail1) {
1268 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropWithBBoxFail1 with negative size value.";
1269 // This should fail because size has negative value
1270 // Create a Cifar10 Dataset
1271 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1272 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1273 EXPECT_NE(ds, nullptr);
1274
1275 // Create objects for the tensor ops
1276 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCropWithBBox({5, -10}));
1277 auto ds1 = ds->Map({random_resized_crop});
1278 EXPECT_NE(ds1, nullptr);
1279 // Create an iterator over the result of the above dataset
1280 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
1281 // Expect failure: invalid input for RandomResizedCropWithBBox
1282 EXPECT_EQ(iter1, nullptr);
1283 }
1284
TEST_F(MindDataTestPipeline,TestRandomResizedCropWithBBoxFail2)1285 TEST_F(MindDataTestPipeline, TestRandomResizedCropWithBBoxFail2) {
1286 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropWithBBoxFail2 with invalid scale input.";
1287 // This should fail because scale isn't in {min, max} format
1288 // Create a Cifar10 Dataset
1289 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1290 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1291 EXPECT_NE(ds, nullptr);
1292
1293 // Create objects for the tensor ops
1294 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCropWithBBox({5, 10}, {4, 3}));
1295 auto ds1 = ds->Map({random_resized_crop});
1296 EXPECT_NE(ds1, nullptr);
1297 // Create an iterator over the result of the above dataset
1298 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
1299 // Expect failure: invalid input for RandomResizedCropWithBBox
1300 EXPECT_EQ(iter1, nullptr);
1301 }
1302
TEST_F(MindDataTestPipeline,TestRandomResizedCropWithBBoxFail3)1303 TEST_F(MindDataTestPipeline, TestRandomResizedCropWithBBoxFail3) {
1304 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropWithBBoxFail3 with invalid ratio input.";
1305 // This should fail because ratio isn't in {min, max} format
1306 // Create a Cifar10 Dataset
1307 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1308 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1309 EXPECT_NE(ds, nullptr);
1310
1311 // Create objects for the tensor ops
1312 std::shared_ptr<TensorTransform> random_resized_crop(new vision::RandomResizedCropWithBBox({5, 10}, {4, 5}, {7, 6}));
1313 auto ds1 = ds->Map({random_resized_crop});
1314 EXPECT_NE(ds1, nullptr);
1315 // Create an iterator over the result of the above dataset
1316 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
1317 // Expect failure: invalid input for RandomResizedCropWithBBox
1318 EXPECT_EQ(iter1, nullptr);
1319 }
1320
TEST_F(MindDataTestPipeline,TestRandomResizedCropWithBBoxFail4)1321 TEST_F(MindDataTestPipeline, TestRandomResizedCropWithBBoxFail4) {
1322 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomResizedCropWithBBoxFail4 with invalid scale size.";
1323 // This should fail because scale has a size of more than 2
1324 // Create a Cifar10 Dataset
1325 std::string folder_path = datasets_root_path_ + "/testCifar10Data/";
1326 std::shared_ptr<Dataset> ds = Cifar10(folder_path, "all", std::make_shared<RandomSampler>(false, 10));
1327 EXPECT_NE(ds, nullptr);
1328
1329 // Create objects for the tensor ops
1330 std::shared_ptr<TensorTransform> random_resized_crop(
1331 new vision::RandomResizedCropWithBBox({5, 10, 20}, {4, 5}, {7, 6}));
1332 auto ds1 = ds->Map({random_resized_crop});
1333 EXPECT_NE(ds1, nullptr);
1334 // Create an iterator over the result of the above dataset
1335 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
1336 // Expect failure: invalid input for RandomResizedCropWithBBox
1337 EXPECT_EQ(iter1, nullptr);
1338 }
1339
TEST_F(MindDataTestPipeline,TestRandomRotation)1340 TEST_F(MindDataTestPipeline, TestRandomRotation) {
1341 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomRotation.";
1342
1343 // Create an ImageFolder Dataset
1344 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1345 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
1346 EXPECT_NE(ds, nullptr);
1347
1348 // Create a Repeat operation on ds
1349 int32_t repeat_num = 2;
1350 ds = ds->Repeat(repeat_num);
1351 EXPECT_NE(ds, nullptr);
1352
1353 // Create objects for the tensor ops
1354 // Testing the size of degrees is 1
1355 std::shared_ptr<TensorTransform> random_rotation_op(new vision::RandomRotation({180}));
1356 // Testing the size of degrees is 2
1357 std::shared_ptr<TensorTransform> random_rotation_op1(new vision::RandomRotation({-180, 180}));
1358 // Testing the size of fill_value is 1
1359 std::shared_ptr<TensorTransform> random_rotation_op2(
1360 new vision::RandomRotation({180}, InterpolationMode::kNearestNeighbour, false, {-1, -1}, {2}));
1361 // Testing the size of fill_value is 3
1362 std::shared_ptr<TensorTransform> random_rotation_op3(
1363 new vision::RandomRotation({180}, InterpolationMode::kNearestNeighbour, false, {-1, -1}, {2, 2, 2}));
1364
1365 // Create a Map operation on ds
1366 ds = ds->Map({random_rotation_op, random_rotation_op1, random_rotation_op2, random_rotation_op3});
1367 EXPECT_NE(ds, nullptr);
1368
1369 // Create a Batch operation on ds
1370 int32_t batch_size = 1;
1371 ds = ds->Batch(batch_size);
1372 EXPECT_NE(ds, nullptr);
1373
1374 // Create an iterator over the result of the above dataset
1375 // This will trigger the creation of the Execution Tree and launch it.
1376 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1377 EXPECT_NE(iter, nullptr);
1378
1379 // Iterate the dataset and get each row
1380 std::unordered_map<std::string, mindspore::MSTensor> row;
1381 ASSERT_OK(iter->GetNextRow(&row));
1382
1383 uint64_t i = 0;
1384 while (row.size() != 0) {
1385 i++;
1386 auto image = row["image"];
1387 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1388 ASSERT_OK(iter->GetNextRow(&row));
1389 }
1390
1391 EXPECT_EQ(i, 20);
1392
1393 // Manually terminate the pipeline
1394 iter->Stop();
1395 }
1396
TEST_F(MindDataTestPipeline,TestRandomRotationFail)1397 TEST_F(MindDataTestPipeline, TestRandomRotationFail) {
1398 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomRotationFail with invalid parameters.";
1399 // Create an ImageFolder Dataset
1400 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1401 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
1402 EXPECT_NE(ds, nullptr);
1403
1404 // Case 1: Testing the size of degrees vector is 0
1405 // Create objects for the tensor ops
1406 std::shared_ptr<TensorTransform> random_rotation_op1(new vision::RandomRotation({}));
1407 auto ds1 = ds->Map({random_rotation_op1});
1408 EXPECT_NE(ds1, nullptr);
1409 // Create an iterator over the result of the above dataset
1410 std::shared_ptr<Iterator> iter1 = ds1->CreateIterator();
1411 // Expect failure: invalid input for RandomRotation
1412 EXPECT_EQ(iter1, nullptr);
1413
1414 // Case 2: Testing the size of degrees vector is 3
1415 // Create objects for the tensor ops
1416 std::shared_ptr<TensorTransform> random_rotation_op2(new vision::RandomRotation({-50.0, 50.0, 100.0}));
1417 auto ds2 = ds->Map({random_rotation_op2});
1418 EXPECT_NE(ds2, nullptr);
1419 // Create an iterator over the result of the above dataset
1420 std::shared_ptr<Iterator> iter2 = ds2->CreateIterator();
1421 // Expect failure: invalid input for RandomRotation
1422 EXPECT_EQ(iter2, nullptr);
1423
1424 // Case 3: Test the case where the first column value of degrees is greater than the second column value
1425 // Create objects for the tensor ops
1426 std::shared_ptr<TensorTransform> random_rotation_op3(new vision::RandomRotation({50.0, -50.0}));
1427 auto ds3 = ds->Map({random_rotation_op3});
1428 EXPECT_NE(ds3, nullptr);
1429 // Create an iterator over the result of the above dataset
1430 std::shared_ptr<Iterator> iter3 = ds3->CreateIterator();
1431 // Expect failure: invalid input for RandomRotation
1432 EXPECT_EQ(iter3, nullptr);
1433
1434 // Case 4: Testing the size of center vector is 1
1435 // Create objects for the tensor ops
1436 std::shared_ptr<TensorTransform> random_rotation_op4(
1437 new vision::RandomRotation({-50.0, 50.0}, mindspore::dataset::InterpolationMode::kNearestNeighbour, false, {-1.0}));
1438 auto ds4 = ds->Map({random_rotation_op4});
1439 EXPECT_NE(ds4, nullptr);
1440 // Create an iterator over the result of the above dataset
1441 std::shared_ptr<Iterator> iter4 = ds4->CreateIterator();
1442 // Expect failure: invalid input for RandomRotation
1443 EXPECT_EQ(iter4, nullptr);
1444
1445 // Case 5: Testing the size of center vector is 3
1446 // Create objects for the tensor ops
1447 std::shared_ptr<TensorTransform> random_rotation_op5(new vision::RandomRotation(
1448 {-50.0, 50.0}, mindspore::dataset::InterpolationMode::kNearestNeighbour, false, {-1.0, -1.0, -1.0}));
1449 auto ds5 = ds->Map({random_rotation_op5});
1450 EXPECT_NE(ds5, nullptr);
1451 // Create an iterator over the result of the above dataset
1452 std::shared_ptr<Iterator> iter5 = ds5->CreateIterator();
1453 // Expect failure: invalid input for RandomRotation
1454 EXPECT_EQ(iter5, nullptr);
1455
1456 // Case 6: Testing the size of fill_value vector is 2
1457 // Create objects for the tensor ops
1458 std::shared_ptr<TensorTransform> random_rotation_op6(new vision::RandomRotation(
1459 {-50.0, 50.0}, mindspore::dataset::InterpolationMode::kNearestNeighbour, false, {-1.0, -1.0}, {2, 2}));
1460 auto ds6 = ds->Map({random_rotation_op6});
1461 EXPECT_NE(ds6, nullptr);
1462 // Create an iterator over the result of the above dataset
1463 std::shared_ptr<Iterator> iter6 = ds6->CreateIterator();
1464 // Expect failure: invalid input for RandomRotation
1465 EXPECT_EQ(iter6, nullptr);
1466
1467 // Case 7: Testing the size of fill_value vector is 4
1468 // Create objects for the tensor ops
1469 std::shared_ptr<TensorTransform> random_rotation_op7(new vision::RandomRotation(
1470 {-50.0, 50.0}, mindspore::dataset::InterpolationMode::kNearestNeighbour, false, {-1.0, -1.0}, {2, 2, 2, 2}));
1471 auto ds7 = ds->Map({random_rotation_op7});
1472 EXPECT_NE(ds7, nullptr);
1473 // Create an iterator over the result of the above dataset
1474 std::shared_ptr<Iterator> iter7 = ds7->CreateIterator();
1475 // Expect failure: invalid input for RandomRotation
1476 EXPECT_EQ(iter7, nullptr);
1477 }
1478
TEST_F(MindDataTestPipeline,TestRandomSharpness)1479 TEST_F(MindDataTestPipeline, TestRandomSharpness) {
1480 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomSharpness.";
1481
1482 // Create an ImageFolder Dataset
1483 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1484 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
1485 EXPECT_NE(ds, nullptr);
1486
1487 // Create a Repeat operation on ds
1488 int32_t repeat_num = 2;
1489 ds = ds->Repeat(repeat_num);
1490 EXPECT_NE(ds, nullptr);
1491
1492 // Create objects for the tensor ops
1493 // Valid case: Input start degree and end degree
1494 std::shared_ptr<TensorTransform> random_sharpness_op_1(new vision::RandomSharpness({0.4, 2.3}));
1495
1496 // Valid case: Use default input values
1497 std::shared_ptr<TensorTransform> random_sharpness_op_2(new vision::RandomSharpness());
1498
1499 // Create a Map operation on ds
1500 ds = ds->Map({random_sharpness_op_1, random_sharpness_op_2});
1501 EXPECT_NE(ds, nullptr);
1502
1503 // Create a Batch operation on ds
1504 int32_t batch_size = 1;
1505 ds = ds->Batch(batch_size);
1506 EXPECT_NE(ds, nullptr);
1507
1508 // Create an iterator over the result of the above dataset
1509 // This will trigger the creation of the Execution Tree and launch it.
1510 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1511 EXPECT_NE(iter, nullptr);
1512
1513 // Iterate the dataset and get each row
1514 std::unordered_map<std::string, mindspore::MSTensor> row;
1515 ASSERT_OK(iter->GetNextRow(&row));
1516
1517 uint64_t i = 0;
1518 while (row.size() != 0) {
1519 i++;
1520 auto image = row["image"];
1521 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1522 ASSERT_OK(iter->GetNextRow(&row));
1523 }
1524
1525 EXPECT_EQ(i, 20);
1526
1527 // Manually terminate the pipeline
1528 iter->Stop();
1529 }
1530
TEST_F(MindDataTestPipeline,TestRandomSolarizeSucess1)1531 TEST_F(MindDataTestPipeline, TestRandomSolarizeSucess1) {
1532 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomSolarizeSucess1.";
1533
1534 // Create an ImageFolder Dataset
1535 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1536 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
1537 EXPECT_NE(ds, nullptr);
1538
1539 // Create objects for the tensor ops
1540 std::vector<uint8_t> threshold = {10, 100};
1541 std::shared_ptr<TensorTransform> random_solarize =
1542 std::make_shared<mindspore::dataset::vision::RandomSolarize>(threshold);
1543
1544 // Create a Map operation on ds
1545 ds = ds->Map({random_solarize});
1546 EXPECT_NE(ds, nullptr);
1547
1548 // Create an iterator over the result of the above dataset
1549 // This will trigger the creation of the Execution Tree and launch it.
1550 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1551 EXPECT_NE(iter, nullptr);
1552
1553 // Iterate the dataset and get each row
1554 std::unordered_map<std::string, mindspore::MSTensor> row;
1555 ASSERT_OK(iter->GetNextRow(&row));
1556
1557 uint64_t i = 0;
1558 while (row.size() != 0) {
1559 i++;
1560 auto image = row["image"];
1561 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1562 ASSERT_OK(iter->GetNextRow(&row));
1563 }
1564
1565 EXPECT_EQ(i, 10);
1566
1567 // Manually terminate the pipeline
1568 iter->Stop();
1569 }
1570
TEST_F(MindDataTestPipeline,TestRandomSolarizeSucess2)1571 TEST_F(MindDataTestPipeline, TestRandomSolarizeSucess2) {
1572 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomSolarizeSuccess2 with default parameters.";
1573
1574 // Create an ImageFolder Dataset
1575 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1576 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 10));
1577 EXPECT_NE(ds, nullptr);
1578
1579 // Create objects for the tensor ops
1580 std::shared_ptr<TensorTransform> random_solarize = std::make_shared<mindspore::dataset::vision::RandomSolarize>();
1581
1582 // Create a Map operation on ds
1583 ds = ds->Map({random_solarize});
1584 EXPECT_NE(ds, nullptr);
1585
1586 // Create an iterator over the result of the above dataset
1587 // This will trigger the creation of the Execution Tree and launch it.
1588 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1589 EXPECT_NE(iter, nullptr);
1590
1591 // Iterate the dataset and get each row
1592 std::unordered_map<std::string, mindspore::MSTensor> row;
1593 ASSERT_OK(iter->GetNextRow(&row));
1594
1595 uint64_t i = 0;
1596 while (row.size() != 0) {
1597 i++;
1598 auto image = row["image"];
1599 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1600 ASSERT_OK(iter->GetNextRow(&row));
1601 }
1602
1603 EXPECT_EQ(i, 10);
1604
1605 // Manually terminate the pipeline
1606 iter->Stop();
1607 }
1608
TEST_F(MindDataTestPipeline,TestRandomVerticalFlipWithBBoxSuccess)1609 TEST_F(MindDataTestPipeline, TestRandomVerticalFlipWithBBoxSuccess) {
1610 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomVerticalFlipWithBBoxSuccess.";
1611 // Create an VOC Dataset
1612 std::string folder_path = datasets_root_path_ + "/testVOC2012_2";
1613 std::shared_ptr<Dataset> ds =
1614 VOC(folder_path, "Detection", "train", {}, true, std::make_shared<SequentialSampler>(0, 3));
1615 EXPECT_NE(ds, nullptr);
1616
1617 // Create objects for the tensor ops
1618 std::shared_ptr<TensorTransform> random_vertical_flip_op = std::make_shared<vision::RandomVerticalFlipWithBBox>(0.4);
1619
1620 // Create a Map operation on ds
1621 ds = ds->Map({random_vertical_flip_op}, {"image", "bbox"}, {"image", "bbox"}, {"image", "bbox"});
1622 EXPECT_NE(ds, nullptr);
1623
1624 // Create an iterator over the result of the above dataset
1625 // This will trigger the creation of the Execution Tree and launch it.
1626 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1627 EXPECT_NE(iter, nullptr);
1628
1629 // Iterate the dataset and get each row
1630 std::unordered_map<std::string, mindspore::MSTensor> row;
1631 ASSERT_OK(iter->GetNextRow(&row));
1632
1633 uint64_t i = 0;
1634 while (row.size() != 0) {
1635 i++;
1636 auto image = row["image"];
1637 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1638 ASSERT_OK(iter->GetNextRow(&row));
1639 }
1640
1641 EXPECT_EQ(i, 3);
1642 // Manually terminate the pipeline
1643 iter->Stop();
1644 }
1645
TEST_F(MindDataTestPipeline,TestRandomHorizontalAndVerticalFlipWithMultiField)1646 TEST_F(MindDataTestPipeline, TestRandomHorizontalAndVerticalFlipWithMultiField) {
1647 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomHorizontalAndVerticalFlipWithMultiField for horizontal and "
1648 "vertical flips.";
1649
1650 // Create an ImageFolder Dataset
1651 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1652 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 1));
1653 EXPECT_NE(ds, nullptr);
1654
1655 // Create objects for the tensor ops
1656 transforms::Duplicate duplicate = transforms::Duplicate();
1657 std::shared_ptr<TensorTransform> random_vertical_flip_op = std::make_shared<vision::RandomVerticalFlip>(1);
1658 std::shared_ptr<TensorTransform> random_horizontal_flip_op = std::make_shared<vision::RandomHorizontalFlip>(1);
1659
1660 // Create a Map operation on ds
1661 ds = ds->Map({duplicate}, {"image"}, {"image", "image_copy"});
1662 EXPECT_NE(ds, nullptr);
1663
1664 ds = ds->Map({random_vertical_flip_op}, {"image", "image_copy"}, {"image", "image_copy"});
1665 EXPECT_NE(ds, nullptr);
1666
1667 // Create an iterator over the result of the above dataset
1668 // This will trigger the creation of the Execution Tree and launch it.
1669 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1670 EXPECT_NE(iter, nullptr);
1671
1672 // Iterate the dataset and get each row
1673 std::unordered_map<std::string, mindspore::MSTensor> row;
1674 ASSERT_OK(iter->GetNextRow(&row));
1675
1676 uint64_t i = 0;
1677 while (row.size() != 0) {
1678 i++;
1679 auto image = row["image"];
1680 auto image_copy = row["image_copy"];
1681 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1682 MS_LOG(INFO) << "Tensor image_copy shape: " << image_copy.Shape();
1683 ASSERT_OK(iter->GetNextRow(&row));
1684 }
1685
1686 EXPECT_EQ(i, 1);
1687
1688 // Manually terminate the pipeline
1689 iter->Stop();
1690 }
1691
TEST_F(MindDataTestPipeline,TestRandomCropDecodeResizeWithMultiField)1692 TEST_F(MindDataTestPipeline, TestRandomCropDecodeResizeWithMultiField) {
1693 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropDecodeResizeWithMultiField.";
1694
1695 // Create an ImageFolder Dataset
1696 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1697 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, false, std::make_shared<RandomSampler>(false, 1));
1698 EXPECT_NE(ds, nullptr);
1699
1700 // Create objects for the tensor ops
1701 transforms::Duplicate duplicate = transforms::Duplicate();
1702 std::shared_ptr<TensorTransform> random_crop_decode_resize(new vision::RandomCropDecodeResize({500, 500}));
1703
1704 // Create a Map operation on ds
1705 ds = ds->Map({duplicate}, {"image"}, {"image", "image_copy"});
1706 EXPECT_NE(ds, nullptr);
1707
1708 ds = ds->Map({random_crop_decode_resize}, {"image", "image_copy"}, {"image", "image_copy"});
1709 EXPECT_NE(ds, nullptr);
1710
1711 // Create an iterator over the result of the above dataset
1712 // This will trigger the creation of the Execution Tree and launch it.
1713 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1714 EXPECT_NE(iter, nullptr);
1715
1716 // Iterate the dataset and get each row
1717 std::unordered_map<std::string, mindspore::MSTensor> row;
1718 ASSERT_OK(iter->GetNextRow(&row));
1719
1720 uint64_t i = 0;
1721 while (row.size() != 0) {
1722 i++;
1723 auto image = row["image"];
1724 auto image_copy = row["image_copy"];
1725 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1726 MS_LOG(INFO) << "Tensor image_copy shape: " << image_copy.Shape();
1727
1728 ASSERT_OK(iter->GetNextRow(&row));
1729 }
1730
1731 EXPECT_EQ(i, 1);
1732
1733 // Manually terminate the pipeline
1734 iter->Stop();
1735 }
1736
TEST_F(MindDataTestPipeline,TestRandomCropResizeWithMultiField)1737 TEST_F(MindDataTestPipeline, TestRandomCropResizeWithMultiField) {
1738 MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomCropResizeWithMultiField.";
1739
1740 // Create an ImageFolder Dataset
1741 std::string folder_path = datasets_root_path_ + "/testPK/data/";
1742 std::shared_ptr<Dataset> ds = ImageFolder(folder_path, true, std::make_shared<RandomSampler>(false, 1));
1743 EXPECT_NE(ds, nullptr);
1744
1745 // Create objects for the tensor ops
1746 transforms::Duplicate duplicate = transforms::Duplicate();
1747 std::shared_ptr<TensorTransform> random_crop_decode_resize(new vision::RandomResizedCrop({500, 500}));
1748
1749 // Create a Map operation on ds
1750 ds = ds->Map({duplicate}, {"image"}, {"image", "image_copy"});
1751 EXPECT_NE(ds, nullptr);
1752
1753 ds = ds->Map({random_crop_decode_resize}, {"image", "image_copy"}, {"image", "image_copy"});
1754 EXPECT_NE(ds, nullptr);
1755
1756 // Create an iterator over the result of the above dataset
1757 // This will trigger the creation of the Execution Tree and launch it.
1758 std::shared_ptr<Iterator> iter = ds->CreateIterator();
1759 EXPECT_NE(iter, nullptr);
1760
1761 // Iterate the dataset and get each row
1762 std::unordered_map<std::string, mindspore::MSTensor> row;
1763 ASSERT_OK(iter->GetNextRow(&row));
1764
1765 uint64_t i = 0;
1766 while (row.size() != 0) {
1767 i++;
1768 auto image = row["image"];
1769 auto image_copy = row["image_copy"];
1770 MS_LOG(INFO) << "Tensor image shape: " << image.Shape();
1771 MS_LOG(INFO) << "Tensor image_copy shape: " << image_copy.Shape();
1772 ASSERT_OK(iter->GetNextRow(&row));
1773 }
1774
1775 EXPECT_EQ(i, 1);
1776
1777 // Manually terminate the pipeline
1778 iter->Stop();
1779 }
1780