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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 } 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 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 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
