diff --git a/mindspore/ccsrc/minddata/dataset/api/text.cc b/mindspore/ccsrc/minddata/dataset/api/text.cc index 92079926576..a97d7d3923a 100644 --- a/mindspore/ccsrc/minddata/dataset/api/text.cc +++ b/mindspore/ccsrc/minddata/dataset/api/text.cc @@ -32,6 +32,8 @@ #endif #include "minddata/dataset/text/kernels/sentence_piece_tokenizer_op.h" #include "minddata/dataset/text/kernels/sliding_window_op.h" +#include "minddata/dataset/text/kernels/to_number_op.h" +#include "minddata/dataset/text/kernels/truncate_sequence_pair_op.h" #include "minddata/dataset/text/kernels/unicode_char_tokenizer_op.h" #ifndef _WIN32 #include "minddata/dataset/text/kernels/unicode_script_tokenizer_op.h" @@ -140,6 +142,18 @@ std::shared_ptr SlidingWindow(const int32_t width, const return op->ValidateParams() ? op : nullptr; } +std::shared_ptr ToNumber(const DataType data_type) { + auto op = std::make_shared(data_type); + + return op->ValidateParams() ? op : nullptr; +} + +std::shared_ptr TruncateSequencePair(int32_t max_length) { + auto op = std::make_shared(max_length); + + return op->ValidateParams() ? op : nullptr; +} + std::shared_ptr UnicodeCharTokenizer(bool with_offsets) { auto op = std::make_shared(with_offsets); @@ -461,6 +475,43 @@ std::shared_ptr SlidingWindowOperation::Build() { return tensor_op; } +// ToNumberOperation +ToNumberOperation::ToNumberOperation(DataType data_type) : data_type_(data_type) {} + +Status ToNumberOperation::ValidateParams() { + if (!data_type_.IsNumeric()) { + std::string err_msg = + "ToNumber : The parameter data_type must be a numeric type: " + std::to_string(data_type_.value()); + MS_LOG(ERROR) << err_msg; + RETURN_STATUS_SYNTAX_ERROR(err_msg); + } + + return Status::OK(); +} + +std::shared_ptr ToNumberOperation::Build() { + std::shared_ptr tensor_op = std::make_shared(data_type_); + return tensor_op; +} + +TruncateSequencePairOperation::TruncateSequencePairOperation(int32_t max_length) : max_length_(max_length) {} + +Status TruncateSequencePairOperation::ValidateParams() { + if (max_length_ < 0) { + std::string err_msg = "TruncateSequencePair : The parameter max_length must be greater than or equal to 0: " + + std::to_string(max_length_); + MS_LOG(ERROR) << err_msg; + RETURN_STATUS_SYNTAX_ERROR(err_msg); + } + + return Status::OK(); +} + +std::shared_ptr TruncateSequencePairOperation::Build() { + std::shared_ptr tensor_op = std::make_shared(max_length_); + return tensor_op; +} + // UnicodeCharTokenizerOperation UnicodeCharTokenizerOperation::UnicodeCharTokenizerOperation(bool with_offsets) : with_offsets_(with_offsets) {} diff --git a/mindspore/ccsrc/minddata/dataset/include/text.h b/mindspore/ccsrc/minddata/dataset/include/text.h index 7e2922712ec..9e05fd2012b 100644 --- a/mindspore/ccsrc/minddata/dataset/include/text.h +++ b/mindspore/ccsrc/minddata/dataset/include/text.h @@ -49,6 +49,8 @@ constexpr char kRegexReplaceOperation[] = "RegexReplace"; constexpr char kRegexTokenizerOperation[] = "RegexTokenizer"; constexpr char kSentencepieceTokenizerOperation[] = "SentencepieceTokenizer"; constexpr char kSlidingWindowOperation[] = "SlidingWindow"; +constexpr char kToNumberOperation[] = "ToNumber"; +constexpr char kTruncateSequencePairOperation[] = "TruncateSequencePair"; constexpr char kUnicodeCharTokenizerOperation[] = "UnicodeCharTokenizer"; constexpr char kUnicodeScriptTokenizerOperation[] = "UnicodeScriptTokenizer"; constexpr char kWhitespaceTokenizerOperation[] = "WhitespaceTokenizer"; @@ -69,6 +71,8 @@ class RegexTokenizerOperation; #endif class SentencePieceTokenizerOperation; class SlidingWindowOperation; +class ToNumberOperation; +class TruncateSequencePairOperation; class UnicodeCharTokenizerOperation; #ifndef _WIN32 class UnicodeScriptTokenizerOperation; @@ -216,6 +220,20 @@ std::shared_ptr SentencePieceTokenizer( /// \return Shared pointer to the current TensorOperation. std::shared_ptr SlidingWindow(const int32_t width, const int32_t axis = 0); +/// \brief Tensor operation to convert every element of a string tensor to a number. +/// Strings are casted according to the rules specified in the following links: +/// https://en.cppreference.com/w/cpp/string/basic_string/stof, +/// https://en.cppreference.com/w/cpp/string/basic_string/stoul, +/// except that any strings which represent negative numbers cannot be cast to an unsigned integer type. +/// \param[in] data_type DataType of the tensor to be casted to. Must be a numeric type. +/// \return Shared pointer to the current TensorOperation. +std::shared_ptr ToNumber(const DataType data_type); + +/// \brief Truncate a pair of rank-1 tensors such that the total length is less than max_length. +/// \param[in] max_length Maximum length required. +/// \return Shared pointer to the current TensorOperation. +std::shared_ptr TruncateSequencePair(int32_t max_length); + /// \brief Tokenize a scalar tensor of UTF-8 string to Unicode characters. /// \param[in] with_offsets If or not output offsets of tokens (default=false). /// \return Shared pointer to the current TensorOperation. @@ -452,6 +470,38 @@ class SlidingWindowOperation : public TensorOperation { int32_t axis_; }; +class ToNumberOperation : public TensorOperation { + public: + explicit ToNumberOperation(DataType data_type); + + ~ToNumberOperation() = default; + + std::shared_ptr Build() override; + + Status ValidateParams() override; + + std::string Name() const override { return kToNumberOperation; } + + private: + DataType data_type_; +}; + +class TruncateSequencePairOperation : public TensorOperation { + public: + explicit TruncateSequencePairOperation(int32_t max_length); + + ~TruncateSequencePairOperation() = default; + + std::shared_ptr Build() override; + + Status ValidateParams() override; + + std::string Name() const override { return kTruncateSequencePairOperation; } + + private: + int32_t max_length_; +}; + class UnicodeCharTokenizerOperation : public TensorOperation { public: explicit UnicodeCharTokenizerOperation(bool with_offsets); diff --git a/mindspore/dataset/text/transforms.py b/mindspore/dataset/text/transforms.py index 10cdac774ea..df038f4ebfa 100644 --- a/mindspore/dataset/text/transforms.py +++ b/mindspore/dataset/text/transforms.py @@ -730,7 +730,7 @@ class TruncateSequencePair(cde.TruncateSequencePairOp): """ Truncate a pair of rank-1 tensors such that the total length is less than max_length. - This operation takes two input tensors and returns two output Tenors. + This operation takes two input tensors and returns two output Tensors. Args: max_length (int): Maximum length required. diff --git a/tests/ut/cpp/dataset/c_api_text_test.cc b/tests/ut/cpp/dataset/c_api_text_test.cc index 328c6ef08d7..29420b02206 100644 --- a/tests/ut/cpp/dataset/c_api_text_test.cc +++ b/tests/ut/cpp/dataset/c_api_text_test.cc @@ -18,6 +18,7 @@ #include #include "common/common.h" +#include "minddata/dataset/include/config.h" #include "minddata/dataset/include/datasets.h" #include "minddata/dataset/include/status.h" #include "minddata/dataset/include/transforms.h" @@ -995,6 +996,428 @@ TEST_F(MindDataTestPipeline, TestSlidingWindowFail) { EXPECT_EQ(sliding_window1, nullptr); } +TEST_F(MindDataTestPipeline, TestToNumberSuccess1) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestToNumberSuccess1."; + // Test ToNumber with integer numbers + + std::string data_file = datasets_root_path_ + "/testTokenizerData/to_number.txt"; + + // Create a TextFile dataset + std::shared_ptr ds = TextFile({data_file}, 0, ShuffleMode::kFalse); + EXPECT_NE(ds, nullptr); + + // Create a Take operation on ds + ds = ds->Take(8); + EXPECT_NE(ds, nullptr); + + // Create ToNumber operation on ds + std::shared_ptr to_number = text::ToNumber(DataType("int64")); + EXPECT_NE(to_number, nullptr); + + // Create a Map operation on ds + ds = ds->Map({to_number}, {"text"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + iter->GetNextRow(&row); + + std::vector expected = {-121, 14, -2219, 7623, -8162536, 162371864, -1726483716, 98921728421}; + + uint64_t i = 0; + while (row.size() != 0) { + auto ind = row["text"]; + std::shared_ptr expected_tensor; + Tensor::CreateScalar(expected[i], &expected_tensor); + EXPECT_EQ(*ind, *expected_tensor); + iter->GetNextRow(&row); + i++; + } + + EXPECT_EQ(i, 8); + + // Manually terminate the pipeline + iter->Stop(); +} + +TEST_F(MindDataTestPipeline, TestToNumberSuccess2) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestToNumberSuccess2."; + // Test ToNumber with float numbers + + std::string data_file = datasets_root_path_ + "/testTokenizerData/to_number.txt"; + + // Create a TextFile dataset + std::shared_ptr ds = TextFile({data_file}, 0, ShuffleMode::kFalse); + EXPECT_NE(ds, nullptr); + + // Create a Skip operation on ds + ds = ds->Skip(8); + EXPECT_NE(ds, nullptr); + + // Create a Take operation on ds + ds = ds->Take(6); + EXPECT_NE(ds, nullptr); + + // Create ToNumber operation on ds + std::shared_ptr to_number = text::ToNumber(DataType("float64")); + EXPECT_NE(to_number, nullptr); + + // Create a Map operation on ds + ds = ds->Map({to_number}, {"text"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + iter->GetNextRow(&row); + + std::vector expected = {-1.1, 1.4, -2219.321, 7623.453, -816256.234282, 162371864.243243}; + + uint64_t i = 0; + while (row.size() != 0) { + auto ind = row["text"]; + std::shared_ptr expected_tensor; + Tensor::CreateScalar(expected[i], &expected_tensor); + EXPECT_EQ(*ind, *expected_tensor); + iter->GetNextRow(&row); + i++; + } + + EXPECT_EQ(i, 6); + + // Manually terminate the pipeline + iter->Stop(); +} + +TEST_F(MindDataTestPipeline, TestToNumberFail1) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestToNumberFail1."; + // Test ToNumber with overflow integer numbers + + std::string data_file = datasets_root_path_ + "/testTokenizerData/to_number.txt"; + + // Create a TextFile dataset + std::shared_ptr ds = TextFile({data_file}, 0, ShuffleMode::kFalse); + EXPECT_NE(ds, nullptr); + + // Create a Skip operation on ds + ds = ds->Skip(2); + EXPECT_NE(ds, nullptr); + + // Create a Take operation on ds + ds = ds->Take(6); + EXPECT_NE(ds, nullptr); + + // Create ToNumber operation on ds + std::shared_ptr to_number = text::ToNumber(DataType("int8")); + EXPECT_NE(to_number, nullptr); + + // Create a Map operation on ds + ds = ds->Map({to_number}, {"text"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + + // Expect error: input out of bounds of int8 + iter->GetNextRow(&row); + + uint64_t i = 0; + while (row.size() != 0) { + iter->GetNextRow(&row); + i++; + } + + // Expect failure: GetNextRow fail and return nothing + EXPECT_EQ(i, 0); + + // Manually terminate the pipeline + iter->Stop(); +} + +TEST_F(MindDataTestPipeline, TestToNumberFail2) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestToNumberFail2."; + // Test ToNumber with overflow float numbers + + std::string data_file = datasets_root_path_ + "/testTokenizerData/to_number.txt"; + + // Create a TextFile dataset + std::shared_ptr ds = TextFile({data_file}, 0, ShuffleMode::kFalse); + EXPECT_NE(ds, nullptr); + + // Create a Skip operation on ds + ds = ds->Skip(12); + EXPECT_NE(ds, nullptr); + + // Create a Take operation on ds + ds = ds->Take(2); + EXPECT_NE(ds, nullptr); + + // Create ToNumber operation on ds + std::shared_ptr to_number = text::ToNumber(DataType("float16")); + EXPECT_NE(to_number, nullptr); + + // Create a Map operation on ds + ds = ds->Map({to_number}, {"text"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + + // Expect error: input out of bounds of float16 + iter->GetNextRow(&row); + + uint64_t i = 0; + while (row.size() != 0) { + iter->GetNextRow(&row); + i++; + } + + // Expect failure: GetNextRow fail and return nothing + EXPECT_EQ(i, 0); + + // Manually terminate the pipeline + iter->Stop(); +} + +TEST_F(MindDataTestPipeline, TestToNumberFail3) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestToNumberFail3."; + // Test ToNumber with non numerical input + + std::string data_file = datasets_root_path_ + "/testTokenizerData/to_number.txt"; + + // Create a TextFile dataset + std::shared_ptr ds = TextFile({data_file}, 0, ShuffleMode::kFalse); + EXPECT_NE(ds, nullptr); + + // Create a Skip operation on ds + ds = ds->Skip(14); + EXPECT_NE(ds, nullptr); + + // Create ToNumber operation on ds + std::shared_ptr to_number = text::ToNumber(DataType("int64")); + EXPECT_NE(to_number, nullptr); + + // Create a Map operation on ds + ds = ds->Map({to_number}, {"text"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + + // Expect error: invalid input which is non numerical + iter->GetNextRow(&row); + + uint64_t i = 0; + while (row.size() != 0) { + iter->GetNextRow(&row); + i++; + } + + // Expect failure: GetNextRow fail and return nothing + EXPECT_EQ(i, 0); + + // Manually terminate the pipeline + iter->Stop(); +} + +TEST_F(MindDataTestPipeline, TestToNumberFail4) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestToNumberFail4."; + // Test ToNumber with non numerical DataType + + std::string data_file = datasets_root_path_ + "/testTokenizerData/to_number.txt"; + + // Create a TextFile dataset + std::shared_ptr ds = TextFile({data_file}, 0, ShuffleMode::kFalse); + EXPECT_NE(ds, nullptr); + + // Create ToNumber operation on ds + std::shared_ptr to_number = text::ToNumber(DataType("string")); + + // Expect failure: invalid parameter with non numerical DataType + EXPECT_EQ(to_number, nullptr); +} + +TEST_F(MindDataTestPipeline, TestTruncateSequencePairSuccess1) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestTruncateSequencePairSuccess1."; + // Testing basic TruncateSequencePair + + // Set seed for RandomDataset + auto original_seed = config::get_seed(); + bool status_set_seed = config::set_seed(0); + EXPECT_EQ(status_set_seed, true); + + // Set num_parallel_workers for RandomDataset + auto original_worker = config::get_num_parallel_workers(); + bool status_set_worker = config::set_num_parallel_workers(1); + EXPECT_EQ(status_set_worker, true); + + // Create a RandomDataset which has column names "col1" and "col2" + std::shared_ptr schema = Schema(); + schema->add_column("col1", mindspore::TypeId::kNumberTypeInt16, {5}); + schema->add_column("col2", mindspore::TypeId::kNumberTypeInt32, {3}); + std::shared_ptr ds = RandomData(3, schema); + EXPECT_NE(ds, nullptr); + + // Create a truncate_sequence_pair operation on ds + std::shared_ptr truncate_sequence_pair = text::TruncateSequencePair(4); + EXPECT_NE(truncate_sequence_pair, nullptr); + + // Create Map operation on ds + ds = ds->Map({truncate_sequence_pair}, {"col1", "col2"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + iter->GetNextRow(&row); + + std::vector> expected1 = {{-29556, -29556}, {-18505, -18505}, {-25958, -25958}}; + std::vector> expected2 = { + {-1751672937, -1751672937}, {-656877352, -656877352}, {-606348325, -606348325}}; + + uint64_t i = 0; + while (row.size() != 0) { + auto ind1 = row["col1"]; + auto ind2 = row["col2"]; + std::shared_ptr expected_tensor1; + std::shared_ptr expected_tensor2; + Tensor::CreateFromVector(expected1[i], &expected_tensor1); + Tensor::CreateFromVector(expected2[i], &expected_tensor2); + EXPECT_EQ(*ind1, *expected_tensor1); + EXPECT_EQ(*ind2, *expected_tensor2); + iter->GetNextRow(&row); + i++; + } + + EXPECT_EQ(i, 3); + + // Manually terminate the pipeline + iter->Stop(); + + // Restore original seed and num_parallel_workers + status_set_seed = config::set_seed(original_seed); + EXPECT_EQ(status_set_seed, true); + status_set_worker = config::set_num_parallel_workers(original_worker); + EXPECT_EQ(status_set_worker, true); +} + +TEST_F(MindDataTestPipeline, TestTruncateSequencePairSuccess2) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestTruncateSequencePairSuccess2."; + // Testing basic TruncateSequencePair with odd max_length + + // Set seed for RandomDataset + auto original_seed = config::get_seed(); + bool status_set_seed = config::set_seed(1); + EXPECT_EQ(status_set_seed, true); + + // Set num_parallel_workers for RandomDataset + auto original_worker = config::get_num_parallel_workers(); + bool status_set_worker = config::set_num_parallel_workers(1); + EXPECT_EQ(status_set_worker, true); + + // Create a RandomDataset which has column names "col1" and "col2" + std::shared_ptr schema = Schema(); + schema->add_column("col1", mindspore::TypeId::kNumberTypeInt32, {4}); + schema->add_column("col2", mindspore::TypeId::kNumberTypeInt64, {4}); + std::shared_ptr ds = RandomData(4, schema); + EXPECT_NE(ds, nullptr); + + // Create a truncate_sequence_pair operation on ds + std::shared_ptr truncate_sequence_pair = text::TruncateSequencePair(5); + EXPECT_NE(truncate_sequence_pair, nullptr); + + // Create Map operation on ds + ds = ds->Map({truncate_sequence_pair}, {"col1", "col2"}); + EXPECT_NE(ds, nullptr); + + // Create an iterator over the result of the above dataset + // This will trigger the creation of the Execution Tree and launch it. + std::shared_ptr iter = ds->CreateIterator(); + EXPECT_NE(iter, nullptr); + + // Iterate the dataset and get each row + std::unordered_map> row; + iter->GetNextRow(&row); + + std::vector> expected1 = {{1785358954, 1785358954, 1785358954}, + {-1195853640, -1195853640, -1195853640}, + {0, 0, 0}, + {1296911693, 1296911693, 1296911693}}; + std::vector> expected2 = { + {-1, -1}, {-1229782938247303442, -1229782938247303442}, {2314885530818453536, 2314885530818453536}, {-1, -1}}; + + uint64_t i = 0; + while (row.size() != 0) { + auto ind1 = row["col1"]; + auto ind2 = row["col2"]; + std::shared_ptr expected_tensor1; + std::shared_ptr expected_tensor2; + Tensor::CreateFromVector(expected1[i], &expected_tensor1); + Tensor::CreateFromVector(expected2[i], &expected_tensor2); + EXPECT_EQ(*ind1, *expected_tensor1); + EXPECT_EQ(*ind2, *expected_tensor2); + iter->GetNextRow(&row); + i++; + } + + EXPECT_EQ(i, 4); + + // Manually terminate the pipeline + iter->Stop(); + + // Restore original seed and num_parallel_workers + status_set_seed = config::set_seed(original_seed); + EXPECT_EQ(status_set_seed, true); + status_set_worker = config::set_num_parallel_workers(original_worker); + EXPECT_EQ(status_set_worker, true); +} + +TEST_F(MindDataTestPipeline, TestTruncateSequencePairFail) { + MS_LOG(INFO) << "Doing MindDataTestPipeline-TestTruncateSequencePairFail."; + // Testing TruncateSequencePair with negative max_length + + // Create a RandomDataset which has column names "col1" and "col2" + std::shared_ptr schema = Schema(); + schema->add_column("col1", mindspore::TypeId::kNumberTypeInt8, {3}); + schema->add_column("col2", mindspore::TypeId::kNumberTypeInt8, {3}); + std::shared_ptr ds = RandomData(3, schema); + EXPECT_NE(ds, nullptr); + + // Create a truncate_sequence_pair operation on ds + std::shared_ptr truncate_sequence_pair = text::TruncateSequencePair(-1); + + // Expect failure: invalid parameter with negative max_length + EXPECT_EQ(truncate_sequence_pair, nullptr); +} + TEST_F(MindDataTestPipeline, TestNgramSuccess) { // Testing the parameter of Ngram interface. MS_LOG(INFO) << "Doing MindDataTestPipeline-TestNgramSuccess."; diff --git a/tests/ut/cpp/dataset/c_api_vision_test.cc b/tests/ut/cpp/dataset/c_api_vision_test.cc index 77248a735b0..f8f0367816f 100644 --- a/tests/ut/cpp/dataset/c_api_vision_test.cc +++ b/tests/ut/cpp/dataset/c_api_vision_test.cc @@ -514,7 +514,7 @@ TEST_F(MindDataTestPipeline, TestCutOutFail1) { EXPECT_EQ(cutout_op, nullptr); } -TEST_F(MindDataTestPipeline, DISABLED_TestCutOutFail2) { +TEST_F(MindDataTestPipeline, TestCutOutFail2) { MS_LOG(INFO) << "Doing MindDataTestPipeline-TestCutOutFail2 with invalid params, boundary cases."; // Create object for the tensor op @@ -1407,12 +1407,12 @@ TEST_F(MindDataTestPipeline, TestRandomCropWithBboxFail) { EXPECT_EQ(random_crop7, nullptr); } -TEST_F(MindDataTestPipeline, DISABLED_TestRandomHorizontalFlipFail) { +TEST_F(MindDataTestPipeline, TestRandomHorizontalFlipFail) { MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomHorizontalFlipFail with invalid parameters."; // Create object for the tensor op - // Invalid zero input - std::shared_ptr random_horizontal_flip_op = vision::RandomHorizontalFlip(0); + // Invalid negative input + std::shared_ptr random_horizontal_flip_op = vision::RandomHorizontalFlip(-0.5); EXPECT_EQ(random_horizontal_flip_op, nullptr); // Invalid >1 input random_horizontal_flip_op = vision::RandomHorizontalFlip(2); @@ -2423,12 +2423,12 @@ TEST_F(MindDataTestPipeline, TestRandomSolarizeFail) { EXPECT_EQ(random_solarize, nullptr); } -TEST_F(MindDataTestPipeline, DISABLED_TestRandomVerticalFlipFail) { +TEST_F(MindDataTestPipeline, TestRandomVerticalFlipFail) { MS_LOG(INFO) << "Doing MindDataTestPipeline-TestRandomVerticalFlipFail with invalid parameters."; // Create object for the tensor op - // Invalid zero input - std::shared_ptr random_vertical_flip_op = vision::RandomVerticalFlip(0); + // Invalid negative input + std::shared_ptr random_vertical_flip_op = vision::RandomVerticalFlip(-0.5); EXPECT_EQ(random_vertical_flip_op, nullptr); // Invalid >1 input random_vertical_flip_op = vision::RandomVerticalFlip(1.1); diff --git a/tests/ut/data/dataset/testTokenizerData/to_number.txt b/tests/ut/data/dataset/testTokenizerData/to_number.txt new file mode 100644 index 00000000000..e0e96f499ad --- /dev/null +++ b/tests/ut/data/dataset/testTokenizerData/to_number.txt @@ -0,0 +1,15 @@ +-121 +14 +-2219 +7623 +-8162536 +162371864 +-1726483716 +98921728421 +-1.1 +1.4 +-2219.321 +7623.453 +-816256.234282 +162371864.243243 +This is a string. \ No newline at end of file