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 "include/api/types.h"
18 #include "minddata/dataset/core/de_tensor.h"
19 #include "minddata/dataset/include/dataset/audio.h"
20 #include "minddata/dataset/include/dataset/execute.h"
21 #include "minddata/dataset/include/dataset/transforms.h"
22 #include "minddata/dataset/include/dataset/audio.h"
23 #include "minddata/dataset/include/dataset/vision.h"
24 #include "minddata/dataset/include/dataset/audio.h"
25 #include "minddata/dataset/include/dataset/text.h"
26 #include "utils/log_adapter.h"
27
28 using namespace mindspore::dataset;
29 using mindspore::LogStream;
30 using mindspore::ExceptionType::NoExceptionType;
31 using mindspore::MsLogLevel::INFO;
32
33 class MindDataTestExecute : public UT::DatasetOpTesting {
34 protected:
35 };
36
TEST_F(MindDataTestExecute,TestAllpassBiquadWithEager)37 TEST_F(MindDataTestExecute, TestAllpassBiquadWithEager) {
38 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAllpassBiquadWithEager.";
39 // Original waveform
40 std::vector<float> labels = {
41 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
42 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
43 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
44 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
45 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
46 std::shared_ptr<Tensor> input;
47 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
48 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
49 std::shared_ptr<TensorTransform> allpass_biquad_01 = std::make_shared<audio::AllpassBiquad>(44100, 200);
50 mindspore::dataset::Execute Transform01({allpass_biquad_01});
51 // Filtered waveform by allpassbiquad
52 Status s01 = Transform01(input_02, &input_02);
53 EXPECT_TRUE(s01.IsOk());
54 }
55
TEST_F(MindDataTestExecute,TestAllpassBiquadWithWrongArg)56 TEST_F(MindDataTestExecute, TestAllpassBiquadWithWrongArg) {
57 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAllpassBiquadWithWrongArg.";
58 std::vector<double> labels = {
59 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
60 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
61 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
62 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
63 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
64 std::shared_ptr<Tensor> input;
65 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
66 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
67 // Check Q
68 MS_LOG(INFO) << "Q is zero.";
69 std::shared_ptr<TensorTransform> allpass_biquad_op = std::make_shared<audio::AllpassBiquad>(44100, 200, 0);
70 mindspore::dataset::Execute Transform01({allpass_biquad_op});
71 Status s01 = Transform01(input_02, &input_02);
72 EXPECT_FALSE(s01.IsOk());
73 }
74
TEST_F(MindDataTestExecute,TestAdjustGammaEager3Channel)75 TEST_F(MindDataTestExecute, TestAdjustGammaEager3Channel) {
76 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAdjustGammaEager3Channel.";
77 // Read images
78 auto image = ReadFileToTensor("data/dataset/apple.jpg");
79
80 // Transform params
81 auto decode = vision::Decode();
82 auto adjust_gamma_op = vision::AdjustGamma(0.1, 1.0);
83
84 auto transform = Execute({decode, adjust_gamma_op});
85 Status rc = transform(image, &image);
86 EXPECT_EQ(rc, Status::OK());
87 }
88
TEST_F(MindDataTestExecute,TestAdjustGammaEager1Channel)89 TEST_F(MindDataTestExecute, TestAdjustGammaEager1Channel) {
90 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAdjustGammaEager1Channel.";
91 auto m1 = ReadFileToTensor("data/dataset/apple.jpg");
92 // Transform params
93 auto decode = vision::Decode();
94 auto rgb2gray = vision::RGB2GRAY();
95 auto adjust_gamma_op = vision::AdjustGamma(0.1, 1.0);
96
97 auto transform = Execute({decode, rgb2gray, adjust_gamma_op});
98 Status rc = transform(m1, &m1);
99 EXPECT_EQ(rc, Status::OK());
100 }
101
TEST_F(MindDataTestExecute,TestAmplitudeToDB)102 TEST_F(MindDataTestExecute, TestAmplitudeToDB) {
103 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAmplitudeToDB.";
104 // Original waveform
105 std::vector<float> labels = {
106 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
107 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
108 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
109 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
110 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03,
111 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
112 std::shared_ptr<Tensor> input;
113 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 2, 2, 3}), &input));
114 auto input_ms = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
115 std::shared_ptr<TensorTransform> amplitude_to_db_op = std::make_shared<audio::AmplitudeToDB>();
116 // apply amplitude_to_db
117 mindspore::dataset::Execute trans({amplitude_to_db_op});
118 Status status = trans(input_ms, &input_ms);
119 EXPECT_TRUE(status.IsOk());
120 }
121
TEST_F(MindDataTestExecute,TestAmplitudeToDBWrongArgs)122 TEST_F(MindDataTestExecute, TestAmplitudeToDBWrongArgs) {
123 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAmplitudeToDBWrongArgs.";
124 // Original waveform
125 std::vector<float> labels = {
126 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
127 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
128 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
129 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
130 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
131 std::shared_ptr<Tensor> input;
132 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
133 auto input_ms = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
134 std::shared_ptr<TensorTransform> amplitude_to_db_op =
135 std::make_shared<audio::AmplitudeToDB>(ScaleType::kPower, 1.0, -1e-10, 80.0);
136 // apply amplitude_to_db
137 mindspore::dataset::Execute trans({amplitude_to_db_op});
138 Status status = trans(input_ms, &input_ms);
139 EXPECT_FALSE(status.IsOk());
140 }
141
TEST_F(MindDataTestExecute,TestAmplitudeToDBWrongInput)142 TEST_F(MindDataTestExecute, TestAmplitudeToDBWrongInput) {
143 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAmplitudeToDBWrongInput.";
144 // Original waveform
145 std::vector<float> labels = {
146 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
147 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
148 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
149 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
150 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
151 std::shared_ptr<Tensor> input;
152 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({20}), &input));
153 auto input_ms = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
154 std::shared_ptr<TensorTransform> amplitude_to_db_op = std::make_shared<audio::AmplitudeToDB>();
155 // apply amplitude_to_db
156 mindspore::dataset::Execute trans({amplitude_to_db_op});
157 Status status = trans(input_ms, &input_ms);
158 EXPECT_FALSE(status.IsOk());
159 }
160
TEST_F(MindDataTestExecute,TestComposeTransforms)161 TEST_F(MindDataTestExecute, TestComposeTransforms) {
162 MS_LOG(INFO) << "Doing MindDataTestExecute-TestComposeTransforms.";
163
164 // Read images
165 auto image = ReadFileToTensor("data/dataset/apple.jpg");
166
167 // Transform params
168 std::shared_ptr<TensorTransform> decode = std::make_shared<vision::Decode>();
169 std::shared_ptr<TensorTransform> center_crop(new vision::CenterCrop({30}));
170 std::shared_ptr<TensorTransform> rescale = std::make_shared<vision::Rescale>(1. / 3, 0.5);
171
172 auto transform = Execute({decode, center_crop, rescale});
173 Status rc = transform(image, &image);
174
175 EXPECT_EQ(rc, Status::OK());
176 EXPECT_EQ(30, image.Shape()[0]);
177 EXPECT_EQ(30, image.Shape()[1]);
178 }
179
TEST_F(MindDataTestExecute,TestCrop)180 TEST_F(MindDataTestExecute, TestCrop) {
181 MS_LOG(INFO) << "Doing MindDataTestExecute-TestCrop.";
182
183 // Read images
184 auto image = ReadFileToTensor("data/dataset/apple.jpg");
185
186 // Transform params
187 auto decode = vision::Decode();
188 auto crop = vision::Crop({10, 30}, {10, 15});
189
190 auto transform = Execute({decode, crop});
191 Status rc = transform(image, &image);
192
193 EXPECT_EQ(rc, Status::OK());
194 EXPECT_EQ(image.Shape()[0], 10);
195 EXPECT_EQ(image.Shape()[1], 15);
196 }
197
TEST_F(MindDataTestExecute,TestFrequencyMasking)198 TEST_F(MindDataTestExecute, TestFrequencyMasking) {
199 MS_LOG(INFO) << "Doing MindDataTestExecute-TestFrequencyMasking.";
200 std::shared_ptr<Tensor> input_tensor_;
201 TensorShape s = TensorShape({6, 2});
202 ASSERT_OK(Tensor::CreateFromVector(
203 std::vector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f}), s, &input_tensor_));
204 auto input_tensor = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
205 std::shared_ptr<TensorTransform> frequency_masking_op = std::make_shared<audio::FrequencyMasking>(true, 2);
206 mindspore::dataset::Execute transform({frequency_masking_op});
207 Status status = transform(input_tensor, &input_tensor);
208 EXPECT_TRUE(status.IsOk());
209 }
210
TEST_F(MindDataTestExecute,TestTimeMasking)211 TEST_F(MindDataTestExecute, TestTimeMasking) {
212 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTimeMasking.";
213 std::shared_ptr<Tensor> input_tensor_;
214 TensorShape s = TensorShape({2, 6});
215 ASSERT_OK(Tensor::CreateFromVector(
216 std::vector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f}), s, &input_tensor_));
217 auto input_tensor = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
218 std::shared_ptr<TensorTransform> time_masking_op = std::make_shared<audio::TimeMasking>(true, 2);
219 mindspore::dataset::Execute transform({time_masking_op});
220 Status status = transform(input_tensor, &input_tensor);
221 EXPECT_TRUE(status.IsOk());
222 }
223
TEST_F(MindDataTestExecute,TestTimeStretchEager)224 TEST_F(MindDataTestExecute, TestTimeStretchEager) {
225 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTimeStretchEager.";
226 std::shared_ptr<Tensor> input_tensor_;
227 // op param
228 int freq = 4;
229 int hop_length = 20;
230 float rate = 1.3;
231 int frame_num = 10;
232 // create tensor
233 TensorShape s = TensorShape({2, freq, frame_num, 2});
234 // init input vec
235 std::vector<float> input_vec(2 * freq * frame_num * 2);
236 for (int ind = 0; ind < input_vec.size(); ind++) {
237 input_vec[ind] = std::rand() % (1000) / (1000.0f);
238 }
239 ASSERT_OK(Tensor::CreateFromVector(input_vec, s, &input_tensor_));
240 auto input_ms = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
241 std::shared_ptr<TensorTransform> time_stretch_op = std::make_shared<audio::TimeStretch>(hop_length, freq, rate);
242
243 // apply timestretch
244 mindspore::dataset::Execute Transform({time_stretch_op});
245 Status status = Transform(input_ms, &input_ms);
246 EXPECT_TRUE(status.IsOk());
247 }
248
TEST_F(MindDataTestExecute,TestTimeStretchParamCheck)249 TEST_F(MindDataTestExecute, TestTimeStretchParamCheck) {
250 MS_LOG(INFO) << "Doing MindDataTestTimeStretch-TestTimeStretchParamCheck.";
251 // Create an input
252 std::shared_ptr<Tensor> input_tensor_;
253 std::shared_ptr<Tensor> output_tensor;
254 TensorShape s = TensorShape({1, 4, 3, 2});
255 ASSERT_OK(Tensor::CreateFromVector(
256 std::vector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f,
257 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f}),
258 s, &input_tensor_));
259 auto input_ms = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
260
261 std::shared_ptr<TensorTransform> time_stretch1 = std::make_shared<audio::TimeStretch>(4, 512, -2);
262 mindspore::dataset::Execute Transform1({time_stretch1});
263 Status status = Transform1(input_ms, &input_ms);
264 EXPECT_FALSE(status.IsOk());
265
266 std::shared_ptr<TensorTransform> time_stretch2 = std::make_shared<audio::TimeStretch>(4, -512, 2);
267 mindspore::dataset::Execute Transform2({time_stretch2});
268 status = Transform2(input_ms, &input_ms);
269 EXPECT_FALSE(status.IsOk());
270 }
271
TEST_F(MindDataTestExecute,TestTransformInput1)272 TEST_F(MindDataTestExecute, TestTransformInput1) {
273 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTransformInput1.";
274 // Test Execute with transform op input using API constructors, with std::shared_ptr<TensorTransform pointers,
275 // instantiated via mix of make_shared and new
276
277 // Read images
278 auto image = ReadFileToTensor("data/dataset/apple.jpg");
279
280 // Define transform operations
281 std::shared_ptr<TensorTransform> decode = std::make_shared<vision::Decode>();
282 std::shared_ptr<TensorTransform> resize(new vision::Resize({224, 224}));
283 std::shared_ptr<TensorTransform> normalize(
284 new vision::Normalize({0.485 * 255, 0.456 * 255, 0.406 * 255}, {0.229 * 255, 0.224 * 255, 0.225 * 255}));
285 std::shared_ptr<TensorTransform> hwc2chw = std::make_shared<vision::HWC2CHW>();
286
287 mindspore::dataset::Execute Transform({decode, resize, normalize, hwc2chw});
288
289 // Apply transform on image
290 Status rc = Transform(image, &image);
291
292 // Check image info
293 ASSERT_TRUE(rc.IsOk());
294 ASSERT_EQ(image.Shape().size(), 3);
295 ASSERT_EQ(image.Shape()[0], 3);
296 ASSERT_EQ(image.Shape()[1], 224);
297 ASSERT_EQ(image.Shape()[2], 224);
298 }
299
TEST_F(MindDataTestExecute,TestTransformInput2)300 TEST_F(MindDataTestExecute, TestTransformInput2) {
301 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTransformInput2.";
302 // Test Execute with transform op input using API constructors, with std::shared_ptr<TensorTransform pointers,
303 // instantiated via new
304 // With this way of creating TensorTransforms, we don't need to explicitly delete the object created with the
305 // "new" keyword. When the shared pointer goes out of scope the object destructor will be called.
306
307 // Read image, construct MSTensor from dataset tensor
308 std::shared_ptr<mindspore::dataset::Tensor> de_tensor;
309 mindspore::dataset::Tensor::CreateFromFile("data/dataset/apple.jpg", &de_tensor);
310 auto image = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
311
312 // Define transform operations
313 std::shared_ptr<TensorTransform> decode(new vision::Decode());
314 std::shared_ptr<TensorTransform> resize(new vision::Resize({224, 224}));
315 std::shared_ptr<TensorTransform> normalize(
316 new vision::Normalize({0.485 * 255, 0.456 * 255, 0.406 * 255}, {0.229 * 255, 0.224 * 255, 0.225 * 255}));
317 std::shared_ptr<TensorTransform> hwc2chw(new vision::HWC2CHW());
318
319 mindspore::dataset::Execute Transform({decode, resize, normalize, hwc2chw});
320
321 // Apply transform on image
322 Status rc = Transform(image, &image);
323
324 // Check image info
325 ASSERT_TRUE(rc.IsOk());
326 ASSERT_EQ(image.Shape().size(), 3);
327 ASSERT_EQ(image.Shape()[0], 3);
328 ASSERT_EQ(image.Shape()[1], 224);
329 ASSERT_EQ(image.Shape()[2], 224);
330 }
331
TEST_F(MindDataTestExecute,TestTransformInput3)332 TEST_F(MindDataTestExecute, TestTransformInput3) {
333 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTransformInput3.";
334 // Test Execute with transform op input using API constructors, with auto pointers
335
336 // Read image, construct MSTensor from dataset tensor
337 std::shared_ptr<mindspore::dataset::Tensor> de_tensor;
338 mindspore::dataset::Tensor::CreateFromFile("data/dataset/apple.jpg", &de_tensor);
339 auto image = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
340
341 // Define transform operations
342 auto decode = vision::Decode();
343 mindspore::dataset::Execute Transform1(decode);
344
345 auto resize = vision::Resize({224, 224});
346 mindspore::dataset::Execute Transform2(resize);
347
348 // Apply transform on image
349 Status rc;
350 rc = Transform1(image, &image);
351 ASSERT_TRUE(rc.IsOk());
352 rc = Transform2(image, &image);
353 ASSERT_TRUE(rc.IsOk());
354
355 // Check image info
356 ASSERT_EQ(image.Shape().size(), 3);
357 ASSERT_EQ(image.Shape()[0], 224);
358 ASSERT_EQ(image.Shape()[1], 224);
359 ASSERT_EQ(image.Shape()[2], 3);
360 }
361
TEST_F(MindDataTestExecute,TestTransformInputSequential)362 TEST_F(MindDataTestExecute, TestTransformInputSequential) {
363 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTransformInputSequential.";
364 // Test Execute with transform op input using API constructors, with auto pointers;
365 // Apply 2 transformations sequentially, including single non-vector Transform op input
366
367 // Read image, construct MSTensor from dataset tensor
368 std::shared_ptr<mindspore::dataset::Tensor> de_tensor;
369 mindspore::dataset::Tensor::CreateFromFile("data/dataset/apple.jpg", &de_tensor);
370 auto image = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
371
372 // Define transform#1 operations
373 std::shared_ptr<TensorTransform> decode(new vision::Decode());
374 std::shared_ptr<TensorTransform> resize(new vision::Resize({224, 224}));
375 std::shared_ptr<TensorTransform> normalize(
376 new vision::Normalize({0.485 * 255, 0.456 * 255, 0.406 * 255}, {0.229 * 255, 0.224 * 255, 0.225 * 255}));
377
378 std::vector<std::shared_ptr<TensorTransform>> op_list = {decode, resize, normalize};
379 mindspore::dataset::Execute Transform(op_list);
380
381 // Apply transform#1 on image
382 Status rc = Transform(image, &image);
383
384 // Define transform#2 operations
385 std::shared_ptr<TensorTransform> hwc2chw(new vision::HWC2CHW());
386 mindspore::dataset::Execute Transform2(hwc2chw);
387
388 // Apply transform#2 on image
389 rc = Transform2(image, &image);
390
391 // Check image info
392 ASSERT_TRUE(rc.IsOk());
393 ASSERT_EQ(image.Shape().size(), 3);
394 ASSERT_EQ(image.Shape()[0], 3);
395 ASSERT_EQ(image.Shape()[1], 224);
396 ASSERT_EQ(image.Shape()[2], 224);
397 }
398
TEST_F(MindDataTestExecute,TestTransformDecodeResizeCenterCrop1)399 TEST_F(MindDataTestExecute, TestTransformDecodeResizeCenterCrop1) {
400 MS_LOG(INFO) << "Doing MindDataTestExecute-TestTransformDecodeResizeCenterCrop1.";
401 // Test Execute with Decode, Resize and CenterCrop transform ops input using API constructors, with shared pointers
402
403 // Read image, construct MSTensor from dataset tensor
404 std::shared_ptr<mindspore::dataset::Tensor> de_tensor;
405 mindspore::dataset::Tensor::CreateFromFile("data/dataset/apple.jpg", &de_tensor);
406 auto image = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
407
408 // Define transform operations
409 std::vector<int32_t> resize_paras = {256, 256};
410 std::vector<int32_t> crop_paras = {224, 224};
411 std::shared_ptr<TensorTransform> decode(new vision::Decode());
412 std::shared_ptr<TensorTransform> resize(new vision::Resize(resize_paras));
413 std::shared_ptr<TensorTransform> centercrop(new vision::CenterCrop(crop_paras));
414 std::shared_ptr<TensorTransform> hwc2chw(new vision::HWC2CHW());
415
416 std::vector<std::shared_ptr<TensorTransform>> op_list = {decode, resize, centercrop, hwc2chw};
417 mindspore::dataset::Execute Transform(op_list, MapTargetDevice::kCpu);
418
419 // Apply transform on image
420 Status rc = Transform(image, &image);
421
422 // Check image info
423 ASSERT_TRUE(rc.IsOk());
424 ASSERT_EQ(image.Shape().size(), 3);
425 ASSERT_EQ(image.Shape()[0], 3);
426 ASSERT_EQ(image.Shape()[1], 224);
427 ASSERT_EQ(image.Shape()[2], 224);
428 }
429
TEST_F(MindDataTestExecute,TestUniformAugment)430 TEST_F(MindDataTestExecute, TestUniformAugment) {
431 // Read images
432 auto image = ReadFileToTensor("data/dataset/apple.jpg");
433 std::vector<mindspore::MSTensor> image2;
434
435 // Transform params
436 std::shared_ptr<TensorTransform> decode = std::make_shared<vision::Decode>();
437 std::shared_ptr<TensorTransform> resize_op(new vision::Resize({16, 16}));
438 std::shared_ptr<TensorTransform> vertical = std::make_shared<vision::RandomVerticalFlip>();
439 std::shared_ptr<TensorTransform> horizontal = std::make_shared<vision::RandomHorizontalFlip>();
440
441 std::shared_ptr<TensorTransform> uniform_op(new vision::UniformAugment({resize_op, vertical, horizontal}, 3));
442
443 auto transform1 = Execute({decode});
444 Status rc = transform1(image, &image);
445 ASSERT_TRUE(rc.IsOk());
446
447 auto transform2 = Execute({uniform_op});
448 rc = transform2({image}, &image2);
449 ASSERT_TRUE(rc.IsOk());
450 }
451
TEST_F(MindDataTestExecute,TestBasicTokenizer)452 TEST_F(MindDataTestExecute, TestBasicTokenizer) {
453 std::shared_ptr<Tensor> de_tensor;
454 Tensor::CreateScalar<std::string>("Welcome to China.", &de_tensor);
455 auto txt = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
456 std::vector<mindspore::MSTensor> txt_result;
457
458 // Transform params
459 std::shared_ptr<TensorTransform> tokenizer =
460 std::make_shared<text::BasicTokenizer>(false, false, NormalizeForm::kNone, false, true);
461
462 // BasicTokenizer has 3 outputs so we need a vector to receive its result
463 auto transform1 = Execute({tokenizer});
464 Status rc = transform1({txt}, &txt_result);
465 ASSERT_EQ(txt_result.size(), 3);
466 ASSERT_TRUE(rc.IsOk());
467 }
468
TEST_F(MindDataTestExecute,TestRotate)469 TEST_F(MindDataTestExecute, TestRotate) {
470 MS_LOG(INFO) << "Doing MindDataTestExecute-TestRotate.";
471
472 // Read images
473 auto image = ReadFileToTensor("data/dataset/apple.jpg");
474
475 // Transform params
476 auto decode = vision::Decode();
477 auto rotate = vision::Rotate(10.5);
478
479 auto transform = Execute({decode, rotate});
480 Status rc = transform(image, &image);
481
482 EXPECT_EQ(rc, Status::OK());
483 }
484
TEST_F(MindDataTestExecute,TestResizeWithBBox)485 TEST_F(MindDataTestExecute, TestResizeWithBBox) {
486 auto image = ReadFileToTensor("data/dataset/apple.jpg");
487 std::shared_ptr<TensorTransform> decode_op = std::make_shared<vision::Decode>();
488 std::shared_ptr<TensorTransform> resizewithbbox_op =
489 std::make_shared<vision::ResizeWithBBox>(std::vector<int32_t>{250, 500});
490
491 // Test Compute(Tensor, Tensor) method of ResizeWithBBox
492 auto transform = Execute({decode_op, resizewithbbox_op});
493
494 // Expect fail since Compute(Tensor, Tensor) is not a valid behaviour for this Op,
495 // while Compute(TensorRow, TensorRow) is the correct one.
496 Status rc = transform(image, &image);
497 EXPECT_FALSE(rc.IsOk());
498 }
499
TEST_F(MindDataTestExecute,TestBandBiquadWithEager)500 TEST_F(MindDataTestExecute, TestBandBiquadWithEager) {
501 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBandBiquadWithEager.";
502 // Original waveform
503 std::vector<float> labels = {
504 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
505 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
506 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
507 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
508 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
509 std::shared_ptr<Tensor> input;
510 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
511 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
512 std::shared_ptr<TensorTransform> band_biquad_01 = std::make_shared<audio::BandBiquad>(44100, 200);
513 mindspore::dataset::Execute Transform01({band_biquad_01});
514 // Filtered waveform by bandbiquad
515 Status s01 = Transform01(input_02, &input_02);
516 EXPECT_TRUE(s01.IsOk());
517 }
518
TEST_F(MindDataTestExecute,TestBandBiquadWithWrongArg)519 TEST_F(MindDataTestExecute, TestBandBiquadWithWrongArg) {
520 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBandBiquadWithWrongArg.";
521 std::vector<double> labels = {
522 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
523 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
524 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
525 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
526 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
527 std::shared_ptr<Tensor> input;
528 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
529 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
530 // Check Q
531 MS_LOG(INFO) << "Q is zero.";
532 std::shared_ptr<TensorTransform> band_biquad_op = std::make_shared<audio::BandBiquad>(44100, 200, 0);
533 mindspore::dataset::Execute Transform01({band_biquad_op});
534 Status s01 = Transform01(input_02, &input_02);
535 EXPECT_FALSE(s01.IsOk());
536 }
537
TEST_F(MindDataTestExecute,TestBandpassBiquadWithEager)538 TEST_F(MindDataTestExecute, TestBandpassBiquadWithEager) {
539 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBandpassBiquadWithEager.";
540 // Original waveform
541 std::vector<float> labels = {
542 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
543 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
544 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
545 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
546 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
547 std::shared_ptr<Tensor> input;
548 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
549 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
550 std::shared_ptr<TensorTransform> bandpass_biquad_01 = std::make_shared<audio::BandpassBiquad>(44100, 200);
551 mindspore::dataset::Execute Transform01({bandpass_biquad_01});
552 // Filtered waveform by bandpassbiquad
553 Status s01 = Transform01(input_02, &input_02);
554 EXPECT_TRUE(s01.IsOk());
555 }
556
TEST_F(MindDataTestExecute,TestBandpassBiquadWithWrongArg)557 TEST_F(MindDataTestExecute, TestBandpassBiquadWithWrongArg) {
558 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBandpassBiquadWithWrongArg.";
559 std::vector<double> labels = {
560 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
561 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
562 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
563 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
564 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
565 std::shared_ptr<Tensor> input;
566 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
567 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
568 // Check Q
569 MS_LOG(INFO) << "Q is zero.";
570 std::shared_ptr<TensorTransform> bandpass_biquad_op = std::make_shared<audio::BandpassBiquad>(44100, 200, 0);
571 mindspore::dataset::Execute Transform01({bandpass_biquad_op});
572 Status s01 = Transform01(input_02, &input_02);
573 EXPECT_FALSE(s01.IsOk());
574 }
575
TEST_F(MindDataTestExecute,TestBandrejectBiquadWithEager)576 TEST_F(MindDataTestExecute, TestBandrejectBiquadWithEager) {
577 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBandrejectBiquadWithEager.";
578 // Original waveform
579 std::vector<float> labels = {
580 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
581 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
582 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
583 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
584 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
585 std::shared_ptr<Tensor> input;
586 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
587 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
588 std::shared_ptr<TensorTransform> bandreject_biquad_01 = std::make_shared<audio::BandrejectBiquad>(44100, 200);
589 mindspore::dataset::Execute Transform01({bandreject_biquad_01});
590 // Filtered waveform by bandrejectbiquad
591 Status s01 = Transform01(input_02, &input_02);
592 EXPECT_TRUE(s01.IsOk());
593 }
594
TEST_F(MindDataTestExecute,TestBandrejectBiquadWithWrongArg)595 TEST_F(MindDataTestExecute, TestBandrejectBiquadWithWrongArg) {
596 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBandrejectBiquadWithWrongArg.";
597 std::vector<double> labels = {
598 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
599 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
600 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
601 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
602 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
603 std::shared_ptr<Tensor> input;
604 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
605 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
606 // Check Q
607 MS_LOG(INFO) << "Q is zero.";
608 std::shared_ptr<TensorTransform> bandreject_biquad_op = std::make_shared<audio::BandrejectBiquad>(44100, 200, 0);
609 mindspore::dataset::Execute Transform01({bandreject_biquad_op});
610 Status s01 = Transform01(input_02, &input_02);
611 EXPECT_FALSE(s01.IsOk());
612 }
613
TEST_F(MindDataTestExecute,TestAngleEager)614 TEST_F(MindDataTestExecute, TestAngleEager) {
615 MS_LOG(INFO) << "Doing MindDataTestExecute-TestAngleEager.";
616 std::vector<double> origin = {1.143, 1.3123, 2.632, 2.554, -1.213, 1.3, 0.456, 3.563};
617 TensorShape input_shape({4, 2});
618 std::shared_ptr<Tensor> de_tensor;
619 Tensor::CreateFromVector(origin, input_shape, &de_tensor);
620
621 std::shared_ptr<TensorTransform> angle = std::make_shared<audio::Angle>();
622 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
623 mindspore::dataset::Execute Transform({angle});
624 Status s = Transform(input, &input);
625
626 ASSERT_TRUE(s.IsOk());
627 }
628
TEST_F(MindDataTestExecute,TestRGB2BGREager)629 TEST_F(MindDataTestExecute, TestRGB2BGREager) {
630 MS_LOG(INFO) << "Doing MindDataTestExecute-TestRGB2BGREager.";
631
632 // Read images
633 auto image = ReadFileToTensor("data/dataset/apple.jpg");
634
635 // Transform params
636 auto decode = vision::Decode();
637 auto rgb2bgr_op = vision::RGB2BGR();
638
639 auto transform = Execute({decode, rgb2bgr_op});
640 Status rc = transform(image, &image);
641
642 EXPECT_EQ(rc, Status::OK());
643 }
644
TEST_F(MindDataTestExecute,TestEqualizerBiquadEager)645 TEST_F(MindDataTestExecute, TestEqualizerBiquadEager) {
646 MS_LOG(INFO) << "Doing MindDataTestExecute-TestEqualizerBiquadEager.";
647 int sample_rate = 44100;
648 float center_freq = 3.5;
649 float gain = 5.5;
650 float Q = 0.707;
651 std::vector<mindspore::MSTensor> output;
652 std::shared_ptr<Tensor> test;
653 std::vector<double> test_vector = {0.8236, 0.2049, 0.3335, 0.5933, 0.9911, 0.2482, 0.3007, 0.9054,
654 0.7598, 0.5394, 0.2842, 0.5634, 0.6363, 0.2226, 0.2288};
655 Tensor::CreateFromVector(test_vector, TensorShape({5, 3}), &test);
656 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
657 std::shared_ptr<TensorTransform> equalizer_biquad(new audio::EqualizerBiquad({sample_rate, center_freq, gain, Q}));
658 auto transform = Execute({equalizer_biquad});
659 Status rc = transform({input}, &output);
660 ASSERT_TRUE(rc.IsOk());
661 }
662
TEST_F(MindDataTestExecute,TestEqualizerBiquadParamCheckQ)663 TEST_F(MindDataTestExecute, TestEqualizerBiquadParamCheckQ) {
664 MS_LOG(INFO) << "Doing MindDataTestExecute-TestEqualizerBiquadParamCheckQ.";
665 std::vector<mindspore::MSTensor> output;
666 std::shared_ptr<Tensor> test;
667 std::vector<double> test_vector = {0.1129, 0.3899, 0.7762, 0.2437, 0.9911, 0.8764, 0.4524, 0.9034,
668 0.3277, 0.8904, 0.1852, 0.6721, 0.1325, 0.2345, 0.5538};
669 Tensor::CreateFromVector(test_vector, TensorShape({3, 5}), &test);
670 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
671 // Check Q
672 std::shared_ptr<TensorTransform> equalizer_biquad_op = std::make_shared<audio::EqualizerBiquad>(44100, 3.5, 5.5, 0);
673 mindspore::dataset::Execute transform({equalizer_biquad_op});
674 Status rc = transform({input}, &output);
675 ASSERT_FALSE(rc.IsOk());
676 }
677
TEST_F(MindDataTestExecute,TestEqualizerBiquadParamCheckSampleRate)678 TEST_F(MindDataTestExecute, TestEqualizerBiquadParamCheckSampleRate) {
679 MS_LOG(INFO) << "Doing MindDataTestExecute-TestEqualizerBiquadParamCheckSampleRate.";
680 std::vector<mindspore::MSTensor> output;
681 std::shared_ptr<Tensor> test;
682 std::vector<double> test_vector = {0.5236, 0.7049, 0.4335, 0.4533, 0.0911, 0.3482, 0.3407, 0.9054,
683 0.7598, 0.5394, 0.2842, 0.5634, 0.6363, 0.2226, 0.2288, 0.6743};
684 Tensor::CreateFromVector(test_vector, TensorShape({4, 4}), &test);
685 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
686 // Check sample_rate
687 std::shared_ptr<TensorTransform> equalizer_biquad_op = std::make_shared<audio::EqualizerBiquad>(0, 3.5, 5.5, 0.7);
688 mindspore::dataset::Execute transform({equalizer_biquad_op});
689 Status rc = transform({input}, &output);
690 ASSERT_FALSE(rc.IsOk());
691 }
692
TEST_F(MindDataTestExecute,TestLowpassBiquadEager)693 TEST_F(MindDataTestExecute, TestLowpassBiquadEager) {
694 MS_LOG(INFO) << "Doing MindDataTestExecute-TestLowpassBiquadEager.";
695 int sample_rate = 44100;
696 float cutoff_freq = 2000.0;
697 float Q = 0.6;
698 std::vector<mindspore::MSTensor> output;
699 std::shared_ptr<Tensor> test;
700 std::vector<double> test_vector = {23.5, 13.2, 62.5, 27.1, 15.5, 30.3, 44.9, 25.0,
701 11.3, 37.4, 67.1, 33.8, 73.4, 53.3, 93.7, 31.1};
702 Tensor::CreateFromVector(test_vector, TensorShape({4, 4}), &test);
703 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
704 std::shared_ptr<TensorTransform> lowpass_biquad(new audio::LowpassBiquad({sample_rate, cutoff_freq, Q}));
705 auto transform = Execute({lowpass_biquad});
706 Status rc = transform({input}, &output);
707 ASSERT_TRUE(rc.IsOk());
708 }
709
TEST_F(MindDataTestExecute,TestLowpassBiuqadParamCheckQ)710 TEST_F(MindDataTestExecute, TestLowpassBiuqadParamCheckQ) {
711 MS_LOG(INFO) << "Doing MindDataTestExecute-TestLowpassBiuqadParamCheckQ.";
712
713 std::vector<mindspore::MSTensor> output;
714 std::shared_ptr<Tensor> test;
715 std::vector<double> test_vector = {0.8236, 0.2049, 0.3335, 0.5933, 0.9911, 0.2482, 0.3007, 0.9054,
716 0.7598, 0.5394, 0.2842, 0.5634, 0.6363, 0.2226, 0.2288};
717 Tensor::CreateFromVector(test_vector, TensorShape({5, 3}), &test);
718 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
719 // Check Q
720 std::shared_ptr<TensorTransform> lowpass_biquad_op = std::make_shared<audio::LowpassBiquad>(44100, 3000.5, 0);
721 mindspore::dataset::Execute transform({lowpass_biquad_op});
722 Status rc = transform({input}, &output);
723 ASSERT_FALSE(rc.IsOk());
724 }
725
TEST_F(MindDataTestExecute,TestLowpassBiuqadParamCheckSampleRate)726 TEST_F(MindDataTestExecute, TestLowpassBiuqadParamCheckSampleRate) {
727 MS_LOG(INFO) << "Doing MindDataTestExecute-TestLowpassBiuqadParamCheckSampleRate.";
728
729 std::vector<mindspore::MSTensor> output;
730 std::shared_ptr<Tensor> test;
731 std::vector<double> test_vector = {0.5, 4.6, 2.2, 0.6, 1.9, 4.7, 2.3, 4.9, 4.7, 0.5, 0.8, 0.9};
732 Tensor::CreateFromVector(test_vector, TensorShape({6, 2}), &test);
733 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
734 // Check sample_rate
735 std::shared_ptr<TensorTransform> lowpass_biquad_op = std::make_shared<audio::LowpassBiquad>(0, 2000.5, 0.7);
736 mindspore::dataset::Execute transform({lowpass_biquad_op});
737 Status rc = transform({input}, &output);
738 ASSERT_FALSE(rc.IsOk());
739 }
740
TEST_F(MindDataTestExecute,TestComplexNormEager)741 TEST_F(MindDataTestExecute, TestComplexNormEager) {
742 MS_LOG(INFO) << "Doing MindDataTestExecute-TestComplexNormEager.";
743 // testing
744 std::shared_ptr<Tensor> input_tensor_;
745 Tensor::CreateFromVector(std::vector<float>({1.0, 1.0, 2.0, 3.0, 4.0, 4.0}), TensorShape({3, 2}), &input_tensor_);
746
747 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
748 std::shared_ptr<TensorTransform> complex_norm_01 = std::make_shared<audio::ComplexNorm>(4.0);
749
750 // Filtered waveform by complexnorm
751 mindspore::dataset::Execute Transform01({complex_norm_01});
752 Status s01 = Transform01(input_02, &input_02);
753 EXPECT_TRUE(s01.IsOk());
754 }
755
TEST_F(MindDataTestExecute,TestContrastWithEager)756 TEST_F(MindDataTestExecute, TestContrastWithEager) {
757 MS_LOG(INFO) << "Doing MindDataTestExecute-TestContrastWithEager.";
758 // Original waveform
759 std::vector<float> labels = {4.11, 5.37, 5.85, 5.4, 4.27, 1.861, -1.1291, -4.76, 1.495};
760 std::shared_ptr<Tensor> input;
761 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({3, 3}), &input));
762 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
763 std::shared_ptr<TensorTransform> contrast_01 = std::make_shared<audio::Contrast>();
764 mindspore::dataset::Execute Transform01({contrast_01});
765 // Filtered waveform by contrast
766 Status s01 = Transform01(input_02, &input_02);
767 EXPECT_TRUE(s01.IsOk());
768 }
769
TEST_F(MindDataTestExecute,TestContrastWithWrongArg)770 TEST_F(MindDataTestExecute, TestContrastWithWrongArg) {
771 MS_LOG(INFO) << "Doing MindDataTestExecute-TestContrastWithWrongArg.";
772 std::vector<double> labels = {-1.007, -5.06, 7.934, 6.683, 1.312, 1.84, 2.246, 2.597};
773 std::shared_ptr<Tensor> input;
774 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 4}), &input));
775 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
776 // Check enhancement_amount
777 MS_LOG(INFO) << "enhancement_amount is negative.";
778 std::shared_ptr<TensorTransform> contrast_op = std::make_shared<audio::Contrast>(-10);
779 mindspore::dataset::Execute Transform01({contrast_op});
780 Status s01 = Transform01(input_02, &input_02);
781 EXPECT_FALSE(s01.IsOk());
782 }
783
TEST_F(MindDataTestExecute,TestDeemphBiquadWithEager)784 TEST_F(MindDataTestExecute, TestDeemphBiquadWithEager) {
785 MS_LOG(INFO) << "Doing MindDataTestExecute-TestDeemphBiquadWithEager";
786 // Original waveform
787 std::vector<float> labels = {
788 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
789 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
790 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
791 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
792 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
793 std::shared_ptr<Tensor> input;
794 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
795 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
796 std::shared_ptr<TensorTransform> deemph_biquad_01 = std::make_shared<audio::DeemphBiquad>(44100);
797 mindspore::dataset::Execute Transform01({deemph_biquad_01});
798 // Filtered waveform by deemphbiquad
799 Status s01 = Transform01(input_02, &input_02);
800 EXPECT_TRUE(s01.IsOk());
801 }
802
TEST_F(MindDataTestExecute,TestDeemphBiquadWithWrongArg)803 TEST_F(MindDataTestExecute, TestDeemphBiquadWithWrongArg) {
804 MS_LOG(INFO) << "Doing MindDataTestExecute-TestDeemphBiquadWithWrongArg.";
805 std::vector<double> labels = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6};
806 std::shared_ptr<Tensor> input;
807 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({1, 6}), &input));
808 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
809 // Check sample_rate
810 MS_LOG(INFO) << "sample_rate is zero.";
811 std::shared_ptr<TensorTransform> deemph_biquad_op = std::make_shared<audio::DeemphBiquad>(0);
812 mindspore::dataset::Execute Transform01({deemph_biquad_op});
813 Status s01 = Transform01(input_02, &input_02);
814 EXPECT_FALSE(s01.IsOk());
815 }
816
TEST_F(MindDataTestExecute,TestHighpassBiquadEager)817 TEST_F(MindDataTestExecute, TestHighpassBiquadEager) {
818 MS_LOG(INFO) << "Doing MindDataTestExecute-TestHighpassBiquadEager.";
819 int sample_rate = 44100;
820 float cutoff_freq = 3000.5;
821 float Q = 0.707;
822 std::vector<mindspore::MSTensor> output;
823 std::shared_ptr<Tensor> test;
824 std::vector<double> test_vector = {0.8236, 0.2049, 0.3335, 0.5933, 0.9911, 0.2482, 0.3007, 0.9054,
825 0.7598, 0.5394, 0.2842, 0.5634, 0.6363, 0.2226, 0.2288};
826 Tensor::CreateFromVector(test_vector, TensorShape({5, 3}), &test);
827 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
828 std::shared_ptr<TensorTransform> highpass_biquad(new audio::HighpassBiquad({sample_rate, cutoff_freq, Q}));
829 auto transform = Execute({highpass_biquad});
830 Status rc = transform({input}, &output);
831 ASSERT_TRUE(rc.IsOk());
832 }
833
TEST_F(MindDataTestExecute,TestHighpassBiquadParamCheckQ)834 TEST_F(MindDataTestExecute, TestHighpassBiquadParamCheckQ) {
835 MS_LOG(INFO) << "Doing MindDataTestExecute-TestHighpassBiquadParamCheckQ.";
836 std::vector<mindspore::MSTensor> output;
837 std::shared_ptr<Tensor> test;
838 std::vector<float> test_vector = {0.6013, 0.8081, 0.6600, 0.4278, 0.4049, 0.0541, 0.8800, 0.7143, 0.0926, 0.3502,
839 0.6148, 0.8738, 0.1869, 0.9023, 0.4293, 0.2175, 0.5132, 0.2622, 0.6490, 0.0741,
840 0.7903, 0.3428, 0.1598, 0.4841, 0.8128, 0.7409, 0.7226, 0.4951, 0.5589, 0.9210};
841 Tensor::CreateFromVector(test_vector, TensorShape({5, 3, 2}), &test);
842 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
843 // Check Q
844 std::shared_ptr<TensorTransform> highpass_biquad_op = std::make_shared<audio::HighpassBiquad>(44100, 3000.5, 0);
845 mindspore::dataset::Execute transform({highpass_biquad_op});
846 Status rc = transform({input}, &output);
847 ASSERT_FALSE(rc.IsOk());
848 }
849
TEST_F(MindDataTestExecute,TestHighpassBiquadParamCheckSampleRate)850 TEST_F(MindDataTestExecute, TestHighpassBiquadParamCheckSampleRate) {
851 MS_LOG(INFO) << "Doing MindDataTestExecute-TestHighpassBiquadParamCheckSampleRate.";
852 std::vector<mindspore::MSTensor> output;
853 std::shared_ptr<Tensor> test;
854 std::vector<double> test_vector = {0.0237, 0.6026, 0.3801, 0.1978, 0.8672, 0.0095, 0.5166, 0.2641, 0.5485, 0.5144};
855 Tensor::CreateFromVector(test_vector, TensorShape({1, 10}), &test);
856 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
857 // Check sample_rate
858 std::shared_ptr<TensorTransform> highpass_biquad_op = std::make_shared<audio::HighpassBiquad>(0, 3000.5, 0.7);
859 mindspore::dataset::Execute transform({highpass_biquad_op});
860 Status rc = transform({input}, &output);
861 ASSERT_FALSE(rc.IsOk());
862 }
863
TEST_F(MindDataTestExecute,TestMuLawDecodingEager)864 TEST_F(MindDataTestExecute, TestMuLawDecodingEager) {
865 MS_LOG(INFO) << "Doing MindDataTestExecute-TestMuLawDecodingEager.";
866 // testing
867 std::shared_ptr<Tensor> input_tensor_;
868 Tensor::CreateFromVector(std::vector<float>({1, 254, 231, 155, 101, 77}), TensorShape({1, 6}), &input_tensor_);
869
870 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
871 std::shared_ptr<TensorTransform> mu_law_encoding_01 = std::make_shared<audio::MuLawDecoding>(255);
872
873 // Filtered waveform by mulawencoding
874 mindspore::dataset::Execute Transform01({mu_law_encoding_01});
875 Status s01 = Transform01(input_02, &input_02);
876 EXPECT_TRUE(s01.IsOk());
877 }
878
TEST_F(MindDataTestExecute,TestLFilterWithEager)879 TEST_F(MindDataTestExecute, TestLFilterWithEager) {
880 MS_LOG(INFO) << "Doing MindDataTestExecute-TestLFilterWithEager.";
881 // Original waveform
882 std::vector<float> labels = {
883 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
884 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
885 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
886 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
887 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
888 std::shared_ptr<Tensor> input;
889 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 10}), &input));
890 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
891 std::vector<float> a_coeffs = {0.1, 0.2, 0.3};
892 std::vector<float> b_coeffs = {0.1, 0.2, 0.3};
893 std::shared_ptr<TensorTransform> lfilter_01 = std::make_shared<audio::LFilter>(a_coeffs, b_coeffs);
894 mindspore::dataset::Execute Transform01({lfilter_01});
895 // Filtered waveform by lfilter
896 Status s01 = Transform01(input_02, &input_02);
897 EXPECT_TRUE(s01.IsOk());
898 }
899
TEST_F(MindDataTestExecute,TestLFilterWithWrongArg)900 TEST_F(MindDataTestExecute, TestLFilterWithWrongArg) {
901 MS_LOG(INFO) << "Doing MindDataTestExecute-TestLFilterWithWrongArg.";
902 std::vector<double> labels = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6};
903 std::shared_ptr<Tensor> input;
904 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({1, 6}), &input));
905 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
906
907 // Check a_coeffs size equal to b_coeffs
908 MS_LOG(INFO) << "a_coeffs size not equal to b_coeffs";
909 std::vector<float> a_coeffs = {0.1, 0.2, 0.3};
910 std::vector<float> b_coeffs = {0.1, 0.2};
911 std::shared_ptr<TensorTransform> lfilter_op = std::make_shared<audio::LFilter>(a_coeffs, b_coeffs);
912 mindspore::dataset::Execute Transform01({lfilter_op});
913 Status s01 = Transform01(input_02, &input_02);
914 EXPECT_FALSE(s01.IsOk());
915 }
916
TEST_F(MindDataTestExecute,TestDCShiftEager)917 TEST_F(MindDataTestExecute, TestDCShiftEager) {
918 MS_LOG(INFO) << "Doing MindDataTestExecute-TestDCShiftEager.";
919
920 std::vector<float> origin = {0.67443, 1.87523, 0.73465, -0.74553, -1.54346, 1.54093, -1.23453};
921 std::shared_ptr<Tensor> de_tensor;
922 Tensor::CreateFromVector(origin, &de_tensor);
923
924 std::shared_ptr<TensorTransform> dc_shift = std::make_shared<audio::DCShift>(0.5, 0.02);
925 auto input = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(de_tensor));
926 mindspore::dataset::Execute Transform({dc_shift});
927 Status s = Transform(input, &input);
928 ASSERT_TRUE(s.IsOk());
929 }
930
TEST_F(MindDataTestExecute,TestBiquadWithEager)931 TEST_F(MindDataTestExecute, TestBiquadWithEager) {
932 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBiquadWithEager.";
933 // Original waveform
934 std::vector<float> labels = {3.716064453125, 12.34765625, 5.246826171875, 1.0894775390625,
935 1.1383056640625, 2.1566162109375, 1.3946533203125, 3.55029296875};
936 std::shared_ptr<Tensor> input;
937 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({2, 4}), &input));
938 auto input_01 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
939 std::shared_ptr<TensorTransform> biquad_01 = std::make_shared<audio::Biquad>(1, 0.02, 0.13, 1, 0.12, 0.3);
940 mindspore::dataset::Execute Transform01({biquad_01});
941 // Filtered waveform by biquad
942 Status s01 = Transform01(input_01, &input_01);
943 EXPECT_TRUE(s01.IsOk());
944 }
945
TEST_F(MindDataTestExecute,TestBiquadWithWrongArg)946 TEST_F(MindDataTestExecute, TestBiquadWithWrongArg) {
947 MS_LOG(INFO) << "Doing MindDataTestExecute-TestBiquadWithWrongArg.";
948 std::vector<double> labels = {
949 2.716064453125000000e-03,
950 6.347656250000000000e-03,
951 9.246826171875000000e-03,
952 1.089477539062500000e-02,
953 };
954 std::shared_ptr<Tensor> input;
955 ASSERT_OK(Tensor::CreateFromVector(labels, TensorShape({1, 4}), &input));
956 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
957 // Check a0
958 MS_LOG(INFO) << "a0 is zero.";
959 std::shared_ptr<TensorTransform> biquad_op = std::make_shared<audio::Biquad>(1, 0.02, 0.13, 0, 0.12, 0.3);
960 mindspore::dataset::Execute Transform01({biquad_op});
961 Status s01 = Transform01(input_02, &input_02);
962 EXPECT_FALSE(s01.IsOk());
963 }
964
TEST_F(MindDataTestExecute,TestFade)965 TEST_F(MindDataTestExecute, TestFade) {
966 MS_LOG(INFO) << "Doing MindDataTestExecute-TestFade.";
967 std::vector<float> waveform = {
968 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
969 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
970 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
971 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
972 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
973 std::shared_ptr<Tensor> input;
974 ASSERT_OK(Tensor::CreateFromVector(waveform, TensorShape({1, 20}), &input));
975 auto input_01 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
976 std::shared_ptr<TensorTransform> fade01 = std::make_shared<audio::Fade>(5, 6, FadeShape::kLinear);
977 mindspore::dataset::Execute Transform01({fade01});
978 Status s01 = Transform01(input_01, &input_01);
979 EXPECT_TRUE(s01.IsOk());
980 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
981 std::shared_ptr<TensorTransform> fade02 = std::make_shared<audio::Fade>(5, 6, FadeShape::kQuarterSine);
982 mindspore::dataset::Execute Transform02({fade02});
983 Status s02 = Transform02(input_02, &input_02);
984 EXPECT_TRUE(s02.IsOk());
985 auto input_03 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
986 std::shared_ptr<TensorTransform> fade03 = std::make_shared<audio::Fade>(5, 6, FadeShape::kExponential);
987 mindspore::dataset::Execute Transform03({fade03});
988 Status s03 = Transform03(input_03, &input_03);
989 EXPECT_TRUE(s03.IsOk());
990 auto input_04 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
991 std::shared_ptr<TensorTransform> fade04 = std::make_shared<audio::Fade>(5, 6, FadeShape::kHalfSine);
992 mindspore::dataset::Execute Transform04({fade04});
993 Status s04 = Transform01(input_04, &input_04);
994 EXPECT_TRUE(s04.IsOk());
995 auto input_05 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
996 std::shared_ptr<TensorTransform> fade05 = std::make_shared<audio::Fade>(5, 6, FadeShape::kLogarithmic);
997 mindspore::dataset::Execute Transform05({fade05});
998 Status s05 = Transform01(input_05, &input_05);
999 EXPECT_TRUE(s05.IsOk());
1000 }
1001
TEST_F(MindDataTestExecute,TestFadeDefaultArg)1002 TEST_F(MindDataTestExecute, TestFadeDefaultArg) {
1003 MS_LOG(INFO) << "Doing MindDataTestExecute-TestFadeDefaultArg.";
1004 std::vector<double> waveform = {
1005 1.573897564868000000e-03, 5.462374385400000000e-03, 3.584989689205400000e-03, 2.035667767462500000e-02,
1006 2.353543454062500000e-02, 1.256616210937500000e-02, 2.394653320312500000e-02, 5.243553968750000000e-02,
1007 2.434554533002500000e-02, 3.454566960937500000e-02, 2.343545454437500000e-02, 2.534343093750000000e-02,
1008 2.354465654550000000e-02, 1.453545517187500000e-02, 1.454645535875000000e-02, 1.433243195312500000e-02,
1009 1.434354554812500000e-02, 3.343435276865400000e-02, 1.234257687312500000e-02, 5.368896484375000000e-03};
1010 std::shared_ptr<Tensor> input;
1011 ASSERT_OK(Tensor::CreateFromVector(waveform, TensorShape({2, 10}), &input));
1012 auto input_01 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1013 std::shared_ptr<TensorTransform> fade01 = std::make_shared<audio::Fade>();
1014 mindspore::dataset::Execute Transform01({fade01});
1015 Status s01 = Transform01(input_01, &input_01);
1016 EXPECT_TRUE(s01.IsOk());
1017 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1018 std::shared_ptr<TensorTransform> fade02 = std::make_shared<audio::Fade>(5);
1019 mindspore::dataset::Execute Transform02({fade02});
1020 Status s02 = Transform02(input_02, &input_02);
1021 EXPECT_TRUE(s02.IsOk());
1022 auto input_03 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1023 std::shared_ptr<TensorTransform> fade03 = std::make_shared<audio::Fade>(5, 6);
1024 mindspore::dataset::Execute Transform03({fade03});
1025 Status s03 = Transform03(input_03, &input_03);
1026 EXPECT_TRUE(s03.IsOk());
1027 }
1028
TEST_F(MindDataTestExecute,TestFadeWithInvalidArg)1029 TEST_F(MindDataTestExecute, TestFadeWithInvalidArg) {
1030 MS_LOG(INFO) << "Doing MindDataTestExecute-TestFadeWithInvalidArg.";
1031 std::vector<float> waveform = {
1032 2.716064453125000000e-03, 6.347656250000000000e-03, 9.246826171875000000e-03, 1.089477539062500000e-02,
1033 1.138305664062500000e-02, 1.156616210937500000e-02, 1.394653320312500000e-02, 1.550292968750000000e-02,
1034 1.614379882812500000e-02, 1.840209960937500000e-02, 1.718139648437500000e-02, 1.599121093750000000e-02,
1035 1.647949218750000000e-02, 1.510620117187500000e-02, 1.385498046875000000e-02, 1.345825195312500000e-02,
1036 1.419067382812500000e-02, 1.284790039062500000e-02, 1.052856445312500000e-02, 9.368896484375000000e-03};
1037 std::shared_ptr<Tensor> input;
1038 ASSERT_OK(Tensor::CreateFromVector(waveform, TensorShape({1, 20}), &input));
1039 auto input_01 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1040 std::shared_ptr<TensorTransform> fade1 = std::make_shared<audio::Fade>(-5, 6);
1041 mindspore::dataset::Execute Transform01({fade1});
1042 Status s01 = Transform01(input_01, &input_01);
1043 EXPECT_FALSE(s01.IsOk());
1044 auto input_02 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1045 std::shared_ptr<TensorTransform> fade2 = std::make_shared<audio::Fade>(0, -1);
1046 mindspore::dataset::Execute Transform02({fade2});
1047 Status s02 = Transform02(input_02, &input_02);
1048 EXPECT_FALSE(s02.IsOk());
1049 auto input_03 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1050 std::shared_ptr<TensorTransform> fade3 = std::make_shared<audio::Fade>(30, 10);
1051 mindspore::dataset::Execute Transform03({fade3});
1052 Status s03 = Transform03(input_03, &input_03);
1053 EXPECT_FALSE(s03.IsOk());
1054 auto input_04 = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input));
1055 std::shared_ptr<TensorTransform> fade4 = std::make_shared<audio::Fade>(10, 30);
1056 mindspore::dataset::Execute Transform04({fade4});
1057 Status s04 = Transform04(input_04, &input_04);
1058 EXPECT_FALSE(s04.IsOk());
1059 }
TEST_F(MindDataTestExecute,TestVolDefalutValue)1060 TEST_F(MindDataTestExecute, TestVolDefalutValue) {
1061 MS_LOG(INFO) << "Doing MindDataTestExecute-TestVolDefalutValue.";
1062 std::shared_ptr<Tensor> input_tensor_;
1063 TensorShape s = TensorShape({2, 6});
1064 ASSERT_OK(Tensor::CreateFromVector(
1065 std::vector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f}), s, &input_tensor_));
1066 auto input_tensor = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
1067 std::shared_ptr<TensorTransform> vol_op = std::make_shared<audio::Vol>(0.333);
1068 mindspore::dataset::Execute transform({vol_op});
1069 Status status = transform(input_tensor, &input_tensor);
1070 EXPECT_TRUE(status.IsOk());
1071 }
1072
TEST_F(MindDataTestExecute,TestVolGainTypePower)1073 TEST_F(MindDataTestExecute, TestVolGainTypePower) {
1074 MS_LOG(INFO) << "Doing MindDataTestExecute-TestVolGainTypePower.";
1075 std::shared_ptr<Tensor> input_tensor_;
1076 TensorShape s = TensorShape({4, 3});
1077 ASSERT_OK(Tensor::CreateFromVector(
1078 std::vector<double>({4.0f, 5.0f, 3.0f, 5.0f, 4.0f, 6.0f, 6.0f, 1.0f, 2.0f, 3.0f, 2.0f, 1.0f}), s, &input_tensor_));
1079 auto input_tensor = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(input_tensor_));
1080 std::shared_ptr<TensorTransform> vol_op = std::make_shared<audio::Vol>(0.2, GainType::kPower);
1081 mindspore::dataset::Execute transform({vol_op});
1082 Status status = transform(input_tensor, &input_tensor);
1083 EXPECT_TRUE(status.IsOk());
1084 }
1085
TEST_F(MindDataTestExecute,TestMagphaseEager)1086 TEST_F(MindDataTestExecute, TestMagphaseEager) {
1087 MS_LOG(INFO) << "Doing MindDataTestExecute-TestMagphaseEager.";
1088 float power = 1.0;
1089 std::vector<mindspore::MSTensor> output_tensor;
1090 std::shared_ptr<Tensor> test;
1091 std::vector<float> test_vector = {3, 4, -3, 4, 3, -4, -3, -4,
1092 5, 12, -5, 12, 5, -12, -5, -12};
1093 Tensor::CreateFromVector(test_vector, TensorShape({2, 4, 2}), &test);
1094 auto input_tensor = mindspore::MSTensor(std::make_shared<mindspore::dataset::DETensor>(test));
1095 std::shared_ptr<TensorTransform> magphase(new audio::Magphase({power}));
1096 auto transform = Execute({magphase});
1097 Status rc = transform({input_tensor}, &output_tensor);
1098 ASSERT_TRUE(rc.IsOk());
1099 }
1100
