Add AutoML to 3 main builds.

onnxruntime/automl_ops/cpu/datetime_transformer.cc

@@ -25,7 +25,7 @@ Status DateTimeTransformer::Compute(OpKernelContext* ctx) const {
 
   int64_t tp = *input_tensor->Data<int64_t>();
   std::chrono::system_clock::time_point sys_time{std::chrono::seconds(tp)};
-  *output = std::move(dtf::SystemToDPTimePoint(sys_time));
+  *output = dtf::SystemToDPTimePoint(sys_time);
   return s;
 }
 

onnxruntime/core/automl/featurizers/src/FeaturizerPrep/Featurizers/SampleAdd.h

@@ -89,29 +89,6 @@ class Estimator : public Microsoft::Featurizer::Estimator<std::uint32_t, std::ui
 // ----------------------------------------------------------------------
 // ----------------------------------------------------------------------
 // ----------------------------------------------------------------------
-
-// ----------------------------------------------------------------------
-// |
-// |  Transformer
-// |
-// ----------------------------------------------------------------------
-template <typename ArchiveT>
-void Transformer::serialize(ArchiveT &ar, unsigned int const version) {
-    ar & boost::serialization::base_object<Microsoft::Featurizer::Transformer>(*this);
-    ar & boost::serialization::make_nvp("delta", _delta);
-}
-
-// ----------------------------------------------------------------------
-// |
-// |  Estimator
-// |
-// ----------------------------------------------------------------------
-template <typename ArchiveT>
-void Estimator::serialize(ArchiveT &ar, unsigned int const version) {
-    ar & boost::serialization::base_object<Microsoft::Featurizer::Estimator>(*this);
-    ar & boost::serialization::make_nvp("accumulated_delta", _accumulated_delta);
-}
-
 } // namespace SampleAdd
 
 } // namespace Featurizer

onnxruntime/core/automl/featurizers/src/FeaturizerPrep/Featurizers/UnitTests/DateTimeFeaturizer_UnitTests.cpp

@@ -19,31 +19,31 @@ using SysClock = std::chrono::system_clock;
 TEST(DateTimeFeaturizer_DateTime, Past_1976_Nov_17__12_27_04) {
     const time_t date = 217081624;
     SysClock::time_point stp = SysClock::from_time_t(date);
-    
+
     // Constructor
     TimePoint tp(stp);
-    ASSERT_TRUE(tp.year == 1976);
-    ASSERT_TRUE(tp.month == TimePoint::NOVEMBER);
-    ASSERT_TRUE(tp.day == 17);
-    ASSERT_TRUE(tp.hour == 12);
-    ASSERT_TRUE(tp.minute == 27);
-    ASSERT_TRUE(tp.second == 4);
-    ASSERT_TRUE(tp.dayOfWeek == TimePoint::WEDNESDAY);
-    ASSERT_TRUE(tp.dayOfYear == 321);
-    ASSERT_TRUE(tp.quarterOfYear == 4);
-    ASSERT_TRUE(tp.weekOfMonth == 2);
+    ASSERT_EQ(tp.year, 1976);
+    ASSERT_EQ(tp.month, TimePoint::NOVEMBER);
+    ASSERT_EQ(tp.day, 17);
+    ASSERT_EQ(tp.hour, 12);
+    ASSERT_EQ(tp.minute, 27);
+    ASSERT_EQ(tp.second, 4);
+    ASSERT_EQ(tp.dayOfWeek, TimePoint::WEDNESDAY);
+    ASSERT_EQ(tp.dayOfYear, 321);
+    ASSERT_EQ(tp.quarterOfYear, 4);
+    ASSERT_EQ(tp.weekOfMonth, 2);
 
     // assignment
     TimePoint tp1 = stp;
-    ASSERT_TRUE(tp1.year == 1976);
-    ASSERT_TRUE(tp1.month == TimePoint::NOVEMBER);
-    ASSERT_TRUE(tp1.day == 17);
+    ASSERT_EQ(tp1.year, 1976);
+    ASSERT_EQ(tp1.month, TimePoint::NOVEMBER);
+    ASSERT_EQ(tp1.day, 17);
 
     // function
     TimePoint tp2 = SystemToDPTimePoint(stp);
-    ASSERT_TRUE(tp2.year == 1976);
-    ASSERT_TRUE(tp2.month == TimePoint::NOVEMBER);
-    ASSERT_TRUE(tp2.day == 17);
+    ASSERT_EQ(tp2.year, 1976);
+    ASSERT_EQ(tp2.month, TimePoint::NOVEMBER);
+    ASSERT_EQ(tp2.day, 17);
 }
 
 TEST(DateTimeFeaturizer_Transformer , Past_1976_Nov_17__12_27_05) {
@@ -52,16 +52,16 @@ TEST(DateTimeFeaturizer_Transformer , Past_1976_Nov_17__12_27_05) {
 
     Transformer dt;
     TimePoint tp = dt.transform(stp);
-    ASSERT_TRUE(tp.year == 1976);
-    ASSERT_TRUE(tp.month == TimePoint::NOVEMBER);
-    ASSERT_TRUE(tp.day == 17);
-    ASSERT_TRUE(tp.hour == 12);
-    ASSERT_TRUE(tp.minute == 27);
-    ASSERT_TRUE(tp.second == 5);
-    ASSERT_TRUE(tp.dayOfWeek == TimePoint::WEDNESDAY);
-    ASSERT_TRUE(tp.dayOfYear == 321);
-    ASSERT_TRUE(tp.quarterOfYear == 4);
-    ASSERT_TRUE(tp.weekOfMonth == 2);
+    ASSERT_EQ(tp.year, 1976);
+    ASSERT_EQ(tp.month, TimePoint::NOVEMBER);
+    ASSERT_EQ(tp.day, 17);
+    ASSERT_EQ(tp.hour, 12);
+    ASSERT_EQ(tp.minute, 27);
+    ASSERT_EQ(tp.second, 5);
+    ASSERT_EQ(tp.dayOfWeek, TimePoint::WEDNESDAY);
+    ASSERT_EQ(tp.dayOfYear, 321);
+    ASSERT_EQ(tp.quarterOfYear, 4);
+    ASSERT_EQ(tp.weekOfMonth, 2);
 
 }
 
@@ -71,16 +71,16 @@ TEST(DateTimeFeaturizer_Transformer , Future_2025_June_30) {
 
     Transformer dt;
     TimePoint tp = dt.transform(stp);
-    ASSERT_TRUE(tp.year == 2025);
-    ASSERT_TRUE(tp.month == TimePoint::JUNE);
-    ASSERT_TRUE(tp.day == 30);
-    ASSERT_TRUE(tp.hour == 0);
-    ASSERT_TRUE(tp.minute == 0);
-    ASSERT_TRUE(tp.second == 0);
-    ASSERT_TRUE(tp.dayOfWeek == TimePoint::MONDAY);
-    ASSERT_TRUE(tp.dayOfYear == 180);
-    ASSERT_TRUE(tp.quarterOfYear == 2);
-    ASSERT_TRUE(tp.weekOfMonth == 4);
+    ASSERT_EQ(tp.year, 2025);
+    ASSERT_EQ(tp.month, TimePoint::JUNE);
+    ASSERT_EQ(tp.day, 30);
+    ASSERT_EQ(tp.hour, 0);
+    ASSERT_EQ(tp.minute, 0);
+    ASSERT_EQ(tp.second, 0);
+    ASSERT_EQ(tp.dayOfWeek, TimePoint::MONDAY);
+    ASSERT_EQ(tp.dayOfYear, 180);
+    ASSERT_EQ(tp.quarterOfYear, 2);
+    ASSERT_EQ(tp.weekOfMonth, 4);
 }
 
 #ifdef _MSC_VER
@@ -92,16 +92,16 @@ TEST(DateTimeFeaturizer_Transformer , Far_Future__2998_March_2__14_03_02) {
 
     Transformer dt;
     TimePoint tp = dt.transform(stp);
-    ASSERT_TRUE(tp.year == 2998);
-    ASSERT_TRUE(tp.month == TimePoint::MARCH);
-    ASSERT_TRUE(tp.day == 2);
-    ASSERT_TRUE(tp.hour == 14);
-    ASSERT_TRUE(tp.minute == 3);
-    ASSERT_TRUE(tp.second == 2);
-    ASSERT_TRUE(tp.dayOfWeek == TimePoint::FRIDAY);
-    ASSERT_TRUE(tp.dayOfYear == 60);
-    ASSERT_TRUE(tp.quarterOfYear == 1);
-    ASSERT_TRUE(tp.weekOfMonth == 0);
+    ASSERT_EQ(tp.year, 2998);
+    ASSERT_EQ(tp.month, TimePoint::MARCH);
+    ASSERT_EQ(tp.day, 2);
+    ASSERT_EQ(tp.hour, 14);
+    ASSERT_EQ(tp.minute, 3);
+    ASSERT_EQ(tp.second, 2);
+    ASSERT_EQ(tp.dayOfWeek, TimePoint::FRIDAY);
+    ASSERT_EQ(tp.dayOfYear, 60);
+    ASSERT_EQ(tp.quarterOfYear, 1);
+    ASSERT_EQ(tp.weekOfMonth, 0);
 }
 
 #else
@@ -115,9 +115,9 @@ TEST(DateTimeFeaturizer_Transformer, Pre_Epoch__1776_July_4) {
     // Constructor
     Transformer dt;
     TimePoint tp = dt.transform(stp);
-    ASSERT_TRUE(tp.year == 1776);
-    ASSERT_TRUE(tp.month == TimePoint::JULY);
-    ASSERT_TRUE(tp.day == 4);
+    ASSERT_EQ(tp.year, 1776);
+    ASSERT_EQ(tp.month, TimePoint::JULY);
+    ASSERT_EQ(tp.day, 4);
 }
 #endif /* _MSC_VER */
 } // namespace DateTimeFeaturizer

onnxruntime/core/automl/featurizers/src/FeaturizerPrep/Featurizers/UnitTests/SampleAdd_UnitTest.cpp

@@ -9,14 +9,14 @@
 #include "../SampleAdd.h"
 
 TEST(SampleAddTests, Transformer) {
-  ASSERT_TRUE(Microsoft::Featurizer::SampleAdd::Transformer(10).transform(20) == 30);
-  ASSERT_TRUE(Microsoft::Featurizer::SampleAdd::Transformer(20).transform(1) == 21);
+  ASSERT_EQ(Microsoft::Featurizer::SampleAdd::Transformer(10).transform(20), 30U);
+  ASSERT_EQ(Microsoft::Featurizer::SampleAdd::Transformer(20).transform(1), 21U);
 }
 
 TEST(SampleAddTests, Estimator) {
-  ASSERT_TRUE(Microsoft::Featurizer::SampleAdd::Estimator().fit(10).commit()->transform(20) == 30);
-  ASSERT_TRUE(Microsoft::Featurizer::SampleAdd::Estimator().fit(20).commit()->transform(1) == 21);
+  ASSERT_EQ(Microsoft::Featurizer::SampleAdd::Estimator().fit(10).commit()->transform(20), 30U);
+  ASSERT_EQ(Microsoft::Featurizer::SampleAdd::Estimator().fit(20).commit()->transform(1), 21U);
 
-  ASSERT_TRUE(Microsoft::Featurizer::SampleAdd::Estimator().fit(10).fit(20).commit()->transform(20) == 50);
-  ASSERT_TRUE(Microsoft::Featurizer::SampleAdd::Estimator().fit(10).fit(20).fit(30).commit()->transform(20) == 80);
+  ASSERT_EQ(Microsoft::Featurizer::SampleAdd::Estimator().fit(10).fit(20).commit()->transform(20), 50U);
+  ASSERT_EQ(Microsoft::Featurizer::SampleAdd::Estimator().fit(10).fit(20).fit(30).commit()->transform(20), 80U);
 }

onnxruntime/core/automl/featurizers/src/FeaturizerPrep/Traits.h

@@ -5,6 +5,7 @@
 
 #pragma once
 #include <array>
+#include <cmath>
 #include <functional>
 #include <map>
 #include <vector>
@@ -67,7 +68,7 @@ template <>
 struct Traits<float> : public TraitsImpl<float> {
   using nullable_type = float;
   static bool IsNull(nullable_type const& value) {
-    return isnan(value);
+    return std::isnan(value);
   }
 
   // static std::string ToString(nullable_type const& value) {
@@ -79,7 +80,7 @@ template <>
 struct Traits<double> : public TraitsImpl<double> {
   using nullable_type = double;
   static bool IsNull(nullable_type const& value) {
-    return isnan(value);
+    return std::isnan(value);
   }
 
   // static std::string ToString(nullable_type const& value) {

onnxruntime/core/automl/featurizers/src/FeaturizerPrep/UnitTests/Featurizer_UnitTest.cpp

@@ -33,14 +33,6 @@ class MyTransformer : public Microsoft::Featurizer::Transformer<bool, int> {
     // ----------------------------------------------------------------------
     // |  Private Data
     bool const                              _true_on_odd;
-
-    // ----------------------------------------------------------------------
-    // |  Private Methods
-    template <typename ArchiveT>
-    void serialize(ArchiveT &ar, unsigned int const /*version*/) {
-        ar & boost::serialization::base_object<transformer_type>(*this);
-        ar & boost::serialization::make_nvp("true_on_odd", const_cast<bool &>(_true_on_odd));
-    }
 };
 
 class MyEstimator : public Microsoft::Featurizer::Estimator<bool, int> {
@@ -78,27 +70,20 @@ class MyEstimator : public Microsoft::Featurizer::Estimator<bool, int> {
 
         return std::make_unique<MyTransformer>(_true_on_odd_state);
     }
-
-    template <typename ArchiveT>
-    void serialize(ArchiveT &ar, unsigned int const /*version*/) {
-        ar & boost::serialization::base_object<estimator_type>(*this);
-        ar & boost::serialization::make_nvp("return_invalid_transformer", const_cast<bool &>(_return_invalid_transformer));
-        ar & boost::serialization::make_nvp("true_on_odd_state", const_cast<bool &>(_true_on_odd_state));
-    }
 };
 
 TEST(FeaturizerTests, TransformerFunctionality) {
-  ASSERT_TRUE(MyTransformer(true).transform(1) == true);
-  ASSERT_TRUE(MyTransformer(false).transform(1) == false);
-  ASSERT_TRUE(MyTransformer(true).transform(2) == false);
-  ASSERT_TRUE(MyTransformer(false).transform(2) == true);
+  ASSERT_TRUE(MyTransformer(true).transform(1));
+  ASSERT_FALSE(MyTransformer(false).transform(1));
+  ASSERT_FALSE(MyTransformer(true).transform(2));
+  ASSERT_TRUE(MyTransformer(false).transform(2));
 }
 
 TEST(FeaturizerTests, EstimatorFunctionality) {
-  ASSERT_TRUE(MyEstimator().fit(1).commit()->transform(1) == true);
-  ASSERT_TRUE(MyEstimator().fit(0).commit()->transform(1) == false);
-  ASSERT_TRUE(MyEstimator().fit(1).commit()->transform(2) == false);
-  ASSERT_TRUE(MyEstimator().fit(0).commit()->transform(2) == true);
+  ASSERT_TRUE(MyEstimator().fit(1).commit()->transform(1));
+  ASSERT_FALSE(MyEstimator().fit(0).commit()->transform(1));
+  ASSERT_FALSE(MyEstimator().fit(1).commit()->transform(2));
+  ASSERT_TRUE(MyEstimator().fit(0).commit()->transform(2));
 }
 
 TEST(FeaturizerTests, EstimatorErrors) {
@@ -112,8 +97,8 @@ TEST(FeaturizerTests, EstimatorErrors) {
 }
 
 TEST(FeaturizerTests, EstimatorFitAndCommit) {
-  ASSERT_TRUE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(1, false)->transform(1) == true);
-  ASSERT_TRUE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(0, false)->transform(1) == false);
-  ASSERT_TRUE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(1, false)->transform(2) == false);
-  ASSERT_TRUE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(0, false)->transform(2) == true);
+  ASSERT_TRUE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(1, false)->transform(1));
+  ASSERT_FALSE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(0, false)->transform(1));
+  ASSERT_FALSE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(1, false)->transform(2));
+  ASSERT_TRUE(Microsoft::Featurizer::fit_and_commit<MyEstimator>(0, false)->transform(2));
 }

onnxruntime/test/automl_ops/datetimetransformer_test.cc

@@ -13,7 +13,7 @@ using SysClock = std::chrono::system_clock;
 namespace onnxruntime {
 namespace test {
 
-TEST(DateTimeFeaturizer_DateTime, Past_1976_Nov_17__12_27_04) {
+TEST(DateTimeTransformer, Past_1976_Nov_17__12_27_04) {
 
   const time_t date = 217081624;
   OpTester test("DateTimeTransformer", 1, onnxruntime::kMSAutoMLDomain);
@@ -23,24 +23,24 @@ TEST(DateTimeFeaturizer_DateTime, Past_1976_Nov_17__12_27_04) {
 
   SysClock::time_point stp = SysClock::from_time_t(date);
   dft::TimePoint tp(stp);
-  ASSERT_TRUE(tp.year == 1976);
-  ASSERT_TRUE(tp.month == dft::TimePoint::NOVEMBER);
-  ASSERT_TRUE(tp.day == 17);
-  ASSERT_TRUE(tp.hour == 12);
-  ASSERT_TRUE(tp.minute == 27);
-  ASSERT_TRUE(tp.second == 4);
-  ASSERT_TRUE(tp.dayOfWeek == dft::TimePoint::WEDNESDAY);
-  ASSERT_TRUE(tp.dayOfYear == 321);
-  ASSERT_TRUE(tp.quarterOfYear == 4);
-  ASSERT_TRUE(tp.weekOfMonth == 2);
+  ASSERT_EQ(tp.year, 1976);
+  ASSERT_EQ(tp.month, dft::TimePoint::NOVEMBER);
+  ASSERT_EQ(tp.day, 17);
+  ASSERT_EQ(tp.hour, 12);
+  ASSERT_EQ(tp.minute, 27);
+  ASSERT_EQ(tp.second, 4);
+  ASSERT_EQ(tp.dayOfWeek, dft::TimePoint::WEDNESDAY);
+  ASSERT_EQ(tp.dayOfYear, 321);
+  ASSERT_EQ(tp.quarterOfYear, 4);
+  ASSERT_EQ(tp.weekOfMonth, 2);
 
   // Expected output.
   test.AddOutput<dft::TimePoint>("Y", std::move(tp));
   test.Run(OpTester::ExpectResult::kExpectSuccess);
 }
 
-TEST(DateTimeFeaturizer_Transformer, Past_1976_Nov_17__12_27_05) {
-  const time_t date = 32445842582;
+TEST(DateTimeTransformer, Past_1976_Nov_17__12_27_05) {
+  const time_t date = 217081625;
 
   OpTester test("DateTimeTransformer", 1, onnxruntime::kMSAutoMLDomain);
   // We are adding a scalar Tensor in this instance
@@ -50,21 +50,48 @@ TEST(DateTimeFeaturizer_Transformer, Past_1976_Nov_17__12_27_05) {
 
   dft::Transformer dt;
   dft::TimePoint tp = dt.transform(stp);
-  ASSERT_TRUE(tp.year == 2998);
-  ASSERT_TRUE(tp.month == dft::TimePoint::MARCH);
-  ASSERT_TRUE(tp.day == 2);
-  ASSERT_TRUE(tp.hour == 14);
-  ASSERT_TRUE(tp.minute == 3);
-  ASSERT_TRUE(tp.second == 2);
-  ASSERT_TRUE(tp.dayOfWeek == dft::TimePoint::FRIDAY);
-  ASSERT_TRUE(tp.dayOfYear == 60);
-  ASSERT_TRUE(tp.quarterOfYear == 1);
-  ASSERT_TRUE(tp.weekOfMonth == 0);
+  ASSERT_EQ(tp.year, 1976);
+  ASSERT_EQ(tp.month, dft::TimePoint::NOVEMBER);
+  ASSERT_EQ(tp.day, 17);
+  ASSERT_EQ(tp.hour, 12);
+  ASSERT_EQ(tp.minute, 27);
+  ASSERT_EQ(tp.second, 5);
+  ASSERT_EQ(tp.dayOfWeek, dft::TimePoint::WEDNESDAY);
+  ASSERT_EQ(tp.dayOfYear, 321);
+  ASSERT_EQ(tp.quarterOfYear, 4);
+  ASSERT_EQ(tp.weekOfMonth, 2);
 
   // Expected output.
   test.AddOutput<dft::TimePoint>("Y", std::move(tp));
   test.Run(OpTester::ExpectResult::kExpectSuccess);
 }
 
+TEST(DateTimeTransformer, Future_2025_June_30) {
+  const time_t date = 1751241600;
+
+  OpTester test("DateTimeTransformer", 1, onnxruntime::kMSAutoMLDomain);
+  // We are adding a scalar Tensor in this instance
+  test.AddInput<int64_t>("X", {1}, {date});
+
+  SysClock::time_point stp = SysClock::from_time_t(date);
+
+  dft::Transformer dt;
+  dft::TimePoint tp = dt.transform(stp);
+  ASSERT_EQ(tp.year, 2025);
+  ASSERT_EQ(tp.month, dft::TimePoint::JUNE);
+  ASSERT_EQ(tp.day, 30);
+  ASSERT_EQ(tp.hour, 0);
+  ASSERT_EQ(tp.minute, 0);
+  ASSERT_EQ(tp.second, 0);
+  ASSERT_EQ(tp.dayOfWeek, dft::TimePoint::MONDAY);
+  ASSERT_EQ(tp.dayOfYear, 180);
+  ASSERT_EQ(tp.quarterOfYear, 2);
+  ASSERT_EQ(tp.weekOfMonth, 4);
+
+  test.AddOutput<dft::TimePoint>("Y", std::move(tp));
+  test.Run(OpTester::ExpectResult::kExpectSuccess);
+}
+
+
 }  // namespace test
 }  // namespace onnxruntime