mlpack 4.6.2__cp38-cp38-win_amd64.whl → 4.7.0__cp38-cp38-win_amd64.whl

mlpack/include/mlpack/methods/decision_tree/decision_tree_regressor.hpp

@@ -68,7 +68,7 @@ class DecisionTreeRegressor :
    */
   template<typename MatType, typename ResponsesType>
   DecisionTreeRegressor(MatType data,
-                        const data::DatasetInfo& datasetInfo,
+                        const DatasetInfo& datasetInfo,
                         ResponsesType responses,
                         const size_t minimumLeafSize = 10,
                         const double minimumGainSplit = 1e-7,
@@ -121,7 +121,7 @@ class DecisionTreeRegressor :
   template<typename MatType, typename ResponsesType, typename WeightsType>
   DecisionTreeRegressor(
       MatType data,
-      const data::DatasetInfo& datasetInfo,
+      const DatasetInfo& datasetInfo,
       ResponsesType responses,
       WeightsType weights,
       const size_t minimumLeafSize = 10,
@@ -182,7 +182,7 @@ class DecisionTreeRegressor :
   DecisionTreeRegressor(
       const DecisionTreeRegressor& other,
       MatType data,
-      const data::DatasetInfo& datasetInfo,
+      const DatasetInfo& datasetInfo,
       ResponsesType responses,
       WeightsType weights,
       const size_t minimumLeafSize = 10,
@@ -277,7 +277,7 @@ class DecisionTreeRegressor :
    */
   template<typename MatType, typename ResponsesType>
   double Train(MatType data,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                ResponsesType responses,
                const size_t minimumLeafSize = 10,
                const double minimumGainSplit = 1e-7,
@@ -338,7 +338,7 @@ class DecisionTreeRegressor :
    */
   template<typename MatType, typename ResponsesType, typename WeightsType>
   double Train(MatType data,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                ResponsesType responses,
                WeightsType weights,
                const size_t minimumLeafSize = 10,
@@ -481,7 +481,7 @@ class DecisionTreeRegressor :
   double Train(MatType& data,
                const size_t begin,
                const size_t count,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                ResponsesType& responses,
                arma::rowvec& weights,
                const size_t minimumLeafSize,

mlpack/include/mlpack/methods/decision_tree/decision_tree_regressor_impl.hpp

@@ -45,7 +45,7 @@ DecisionTreeRegressor<FitnessFunction,
                       DimensionSelectionType,
                       NoRecursion>::DecisionTreeRegressor(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     ResponsesType responses,
     const size_t minimumLeafSize,
     const double minimumGainSplit,
@@ -117,7 +117,7 @@ DecisionTreeRegressor<FitnessFunction,
                       DimensionSelectionType,
                       NoRecursion>::DecisionTreeRegressor(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     ResponsesType responses,
     WeightsType weights,
     const size_t minimumLeafSize,
@@ -199,7 +199,7 @@ DecisionTreeRegressor<FitnessFunction,
                       NoRecursion>::DecisionTreeRegressor(
     const DecisionTreeRegressor& other,
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     ResponsesType responses,
     WeightsType weights,
     const size_t minimumLeafSize,
@@ -429,7 +429,7 @@ double DecisionTreeRegressor<FitnessFunction,
                              DimensionSelectionType,
                              NoRecursion>::Train(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     ResponsesType responses,
     const size_t minimumLeafSize,
     const double minimumGainSplit,
@@ -510,7 +510,7 @@ double DecisionTreeRegressor<FitnessFunction,
                              DimensionSelectionType,
                              NoRecursion>::Train(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     ResponsesType responses,
     WeightsType weights,
     const size_t minimumLeafSize,
@@ -601,7 +601,7 @@ double DecisionTreeRegressor<FitnessFunction,
     MatType& data,
     const size_t begin,
     const size_t count,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     ResponsesType& responses,
     arma::rowvec& weights,
     const size_t minimumLeafSize,
@@ -630,7 +630,7 @@ double DecisionTreeRegressor<FitnessFunction,
          i = dimensionSelector.Next())
     {
       double dimGain = -DBL_MAX;
-      if (datasetInfo.Type(i) == data::Datatype::categorical)
+      if (datasetInfo.Type(i) == Datatype::categorical)
       {
         dimGain = CategoricalSplit::template SplitIfBetter<UseWeights>(bestGain,
             data.cols(begin, begin + count - 1).row(i),
@@ -643,7 +643,7 @@ double DecisionTreeRegressor<FitnessFunction,
             *this,
             fitnessFunction);
       }
-      else if (datasetInfo.Type(i) == data::Datatype::numeric)
+      else if (datasetInfo.Type(i) == Datatype::numeric)
       {
         dimGain = NumericSplit::template SplitIfBetter<UseWeights>(bestGain,
             data.cols(begin, begin + count - 1).row(i),
@@ -679,14 +679,14 @@ double DecisionTreeRegressor<FitnessFunction,
 
     // Get the number of children we will have.
     size_t numChildren = 0;
-    if (datasetInfo.Type(bestDim) == data::Datatype::categorical)
+    if (datasetInfo.Type(bestDim) == Datatype::categorical)
       numChildren = CategoricalSplit::NumChildren(splitInfo, *this);
     else
       numChildren = NumericSplit::NumChildren(splitInfo, *this);
 
     // Calculate all child assignments.
     arma::Row<size_t> childAssignments(count);
-    if (datasetInfo.Type(bestDim) == data::Datatype::categorical)
+    if (datasetInfo.Type(bestDim) == Datatype::categorical)
     {
       for (size_t j = begin; j < begin + count; ++j)
         childAssignments[j - begin] = CategoricalSplit::CalculateDirection(
@@ -844,7 +844,7 @@ double DecisionTreeRegressor<FitnessFunction,
     // We know that the split is numeric.
     size_t numChildren = NumericSplit::NumChildren(splitInfo, *this);
     splitDimension = bestDim;
-    dimensionType = (size_t) data::Datatype::numeric;
+    dimensionType = (size_t) Datatype::numeric;
 
     // Calculate all child assignments.
     arma::Row<size_t> childAssignments(count);
@@ -986,7 +986,7 @@ size_t DecisionTreeRegressor<FitnessFunction,
                              NoRecursion
 >::CalculateDirection(const VecType& point) const
 {
-  if ((data::Datatype) dimensionType == data::Datatype::categorical)
+  if ((Datatype) dimensionType == Datatype::categorical)
     return CategoricalSplit::CalculateDirection(point[splitDimension],
         splitInfo, *this);
   else

mlpack/include/mlpack/methods/det/det_main.cpp

@@ -297,7 +297,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
       }
 
       if (params.Has("tag_counters_file"))
-        data::Save(params.Get<string>("tag_counters_file"), counters);
+        Save(params.Get<string>("tag_counters_file"), counters);
     }
 
     timers.Stop("det_test_set_tagging");

mlpack/include/mlpack/methods/hmm/hmm_train_main.cpp

@@ -356,7 +356,7 @@ struct Train
 
           // Now read the matrix.
           Mat<size_t> label;
-          data::Load(lineBuf, label, true); // Fatal on failure.
+          Load(lineBuf, label, Fatal);
 
           // Ensure that matrix only has one row.
           if (label.n_cols == 1)
@@ -387,7 +387,7 @@ struct Train
       else
       {
         Mat<size_t> label;
-        data::Load(labelsFile, label, true);
+        Load(labelsFile, label, Fatal);
 
         // Ensure that matrix only has one row.
         if (label.n_cols == 1)
@@ -498,7 +498,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& /* timers */)
 
       // Now read the matrix.
       trainSeq.push_back(mat());
-      data::Load(lineBuf, trainSeq.back(), true); // Fatal on failure.
+      Load(lineBuf, trainSeq.back(), Fatal);
 
       // See if we need to transpose the data.
       if (type == "discrete")
@@ -516,7 +516,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& /* timers */)
   {
     // Only one input file.
     trainSeq.resize(1);
-    data::Load(inputFile, trainSeq[0], true);
+    Load(inputFile, trainSeq[0], Fatal);
   }
 
   // Get the type.

mlpack/include/mlpack/methods/hmm/hmm_util_impl.hpp

@@ -38,7 +38,7 @@ template<typename ActionType, typename ExtraInfoType>
 void LoadHMMAndPerformAction(const std::string& modelFile,
                              ExtraInfoType* x)
 {
-  const std::string extension = data::Extension(modelFile);
+  const std::string extension = Extension(modelFile);
   if (extension == "xml")
   {
     LoadHMMAndPerformActionHelper<ActionType, cereal::XMLInputArchive>(
@@ -126,7 +126,7 @@ char GetHMMType();
 template<typename HMMType>
 void SaveHMM(HMMType& hmm, const std::string& modelFile)
 {
-  const std::string extension = data::Extension(modelFile);
+  const std::string extension = Extension(modelFile);
   if (extension == "xml")
     SaveHMMHelper<cereal::XMLOutputArchive>(hmm, modelFile);
   else if (extension == "bin")

mlpack/include/mlpack/methods/hoeffding_trees/hoeffding_tree.hpp

@@ -133,7 +133,7 @@ class HoeffdingTree
    * @param copyDatasetInfo If true, then a copy of the datasetInfo will be
    *      made.
    */
-  HoeffdingTree(const data::DatasetInfo& datasetInfo,
+  HoeffdingTree(const DatasetInfo& datasetInfo,
                 const size_t numClasses,
                 const double successProbability = 0.95,
                 const size_t maxSamples = 0,
@@ -211,7 +211,7 @@ class HoeffdingTree
    */
   template<typename MatType>
   HoeffdingTree(const MatType& data,
-                const data::DatasetInfo& datasetInfo,
+                const DatasetInfo& datasetInfo,
                 const arma::Row<size_t>& labels,
                 const size_t numClasses,
                 const bool batchTraining = true,
@@ -330,7 +330,7 @@ class HoeffdingTree
    */
   template<typename MatType>
   void Train(const MatType& data,
-             const data::DatasetInfo& info,
+             const DatasetInfo& info,
              const arma::Row<size_t>& labels,
              const size_t numClasses = 0,
              const bool batchTraining = true,
@@ -340,7 +340,7 @@ class HoeffdingTree
 
   template<typename MatType>
   void Train(const MatType& data,
-             const data::DatasetInfo& info,
+             const DatasetInfo& info,
              const arma::Row<size_t>& labels,
              const size_t numClasses,
              const bool batchTraining,
@@ -497,7 +497,7 @@ class HoeffdingTree
   /**
    * Reset the tree, setting a new number of classes and a new datasetInfo.
    */
-  void Reset(const data::DatasetInfo& datasetInfo, const size_t numClasses);
+  void Reset(const DatasetInfo& datasetInfo, const size_t numClasses);
 
   //! Serialize the split.
   template<typename Archive>
@@ -527,7 +527,7 @@ class HoeffdingTree
   //! The minimum number of samples for splitting.
   size_t minSamples;
   //! The dataset information.
-  const data::DatasetInfo* datasetInfo;
+  const DatasetInfo* datasetInfo;
   //! Whether or not we own the dataset information.
   bool ownsInfo;
   //! The required probability of success for a split to be performed.

mlpack/include/mlpack/methods/hoeffding_trees/hoeffding_tree_impl.hpp

@@ -33,7 +33,7 @@ HoeffdingTree<
     maxSamples(size_t(-1)),
     checkInterval(100),
     minSamples(100),
-    datasetInfo(new data::DatasetInfo()),
+    datasetInfo(new DatasetInfo()),
     ownsInfo(true),
     successProbability(0.95),
     splitDimension(size_t(-1)),
@@ -71,7 +71,7 @@ HoeffdingTree<
     maxSamples((maxSamples == 0) ? size_t(-1) : maxSamples),
     checkInterval(checkInterval),
     minSamples(minSamples),
-    datasetInfo(new data::DatasetInfo(dimensionality)),
+    datasetInfo(new DatasetInfo(dimensionality)),
     ownsInfo(true),
     successProbability(successProbability),
     splitDimension(size_t(-1)),
@@ -103,7 +103,7 @@ HoeffdingTree<
     FitnessFunction,
     NumericSplitType,
     CategoricalSplitType
->::HoeffdingTree(const data::DatasetInfo& datasetInfo,
+>::HoeffdingTree(const DatasetInfo& datasetInfo,
                  const size_t numClasses,
                  const double successProbability,
                  const size_t maxSamples,
@@ -123,7 +123,7 @@ HoeffdingTree<
     maxSamples((maxSamples == 0) ? size_t(-1) : maxSamples),
     checkInterval(checkInterval),
     minSamples(minSamples),
-    datasetInfo(copyDatasetInfo ? new data::DatasetInfo(datasetInfo) :
+    datasetInfo(copyDatasetInfo ? new DatasetInfo(datasetInfo) :
         &datasetInfo),
     ownsInfo(copyDatasetInfo),
     successProbability(successProbability),
@@ -142,7 +142,7 @@ HoeffdingTree<
   {
     for (size_t i = 0; i < datasetInfo.Dimensionality(); ++i)
     {
-      if (datasetInfo.Type(i) == data::Datatype::categorical)
+      if (datasetInfo.Type(i) == Datatype::categorical)
       {
         categoricalSplits.push_back(CategoricalSplitType<FitnessFunction>(
             datasetInfo.NumMappings(i), numClasses, categoricalSplitIn));
@@ -182,7 +182,7 @@ HoeffdingTree<
     maxSamples((maxSamples == 0) ? size_t(-1) : maxSamples),
     checkInterval(checkInterval),
     minSamples(minSamples),
-    datasetInfo(new data::DatasetInfo(data.n_rows)),
+    datasetInfo(new DatasetInfo(data.n_rows)),
     ownsInfo(true),
     successProbability(successProbability),
     splitDimension(size_t(-1)),
@@ -207,7 +207,7 @@ HoeffdingTree<
     NumericSplitType,
     CategoricalSplitType
 >::HoeffdingTree(const MatType& data,
-                 const data::DatasetInfo& datasetInfoIn,
+                 const DatasetInfo& datasetInfoIn,
                  const arma::Row<size_t>& labels,
                  const size_t numClasses,
                  const bool batchTraining,
@@ -225,7 +225,7 @@ HoeffdingTree<
     maxSamples((maxSamples == 0) ? size_t(-1) : maxSamples),
     checkInterval(checkInterval),
     minSamples(minSamples),
-    datasetInfo(new data::DatasetInfo(datasetInfoIn)),
+    datasetInfo(new DatasetInfo(datasetInfoIn)),
     ownsInfo(true),
     successProbability(successProbability),
     splitDimension(size_t(-1)),
@@ -257,7 +257,7 @@ HoeffdingTree<FitnessFunction, NumericSplitType, CategoricalSplitType>::
     maxSamples(other.maxSamples),
     checkInterval(other.checkInterval),
     minSamples(other.minSamples),
-    datasetInfo(new data::DatasetInfo(*other.datasetInfo)),
+    datasetInfo(new DatasetInfo(*other.datasetInfo)),
     ownsInfo(true),
     successProbability(other.successProbability),
     splitDimension(other.splitDimension),
@@ -341,7 +341,7 @@ HoeffdingTree<FitnessFunction, NumericSplitType, CategoricalSplitType>&
     maxSamples = other.maxSamples;
     checkInterval = other.checkInterval;
     minSamples = other.minSamples;
-    datasetInfo = new data::DatasetInfo(*other.datasetInfo);
+    datasetInfo = new DatasetInfo(*other.datasetInfo);
     ownsInfo = true;
     successProbability = other.successProbability;
     splitDimension = other.splitDimension;
@@ -482,7 +482,7 @@ void HoeffdingTree<
     // Create a new datasetInfo, which assumes that all features are numeric.
     if (ownsInfo)
       delete datasetInfo;
-    datasetInfo = new data::DatasetInfo(data.n_rows);
+    datasetInfo = new DatasetInfo(data.n_rows);
     ownsInfo = true;
 
     // Set the number of classes correctly.
@@ -510,7 +510,7 @@ void HoeffdingTree<
     NumericSplitType,
     CategoricalSplitType
 >::Train(const MatType& data,
-         const data::DatasetInfo& info,
+         const DatasetInfo& info,
          const arma::Row<size_t>& labels,
          const size_t numClasses,
          const bool batchTraining,
@@ -535,7 +535,7 @@ void HoeffdingTree<
     NumericSplitType,
     CategoricalSplitType
 >::Train(const MatType& data,
-         const data::DatasetInfo& info,
+         const DatasetInfo& info,
          const arma::Row<size_t>& labels,
          const size_t numClasses,
          const bool batchTraining,
@@ -596,9 +596,9 @@ void HoeffdingTree<
     size_t categoricalIndex = 0;
     for (size_t i = 0; i < point.n_rows; ++i)
     {
-      if (datasetInfo->Type(i) == data::Datatype::categorical)
+      if (datasetInfo->Type(i) == Datatype::categorical)
         categoricalSplits[categoricalIndex++].Train(point[i], label);
-      else if (datasetInfo->Type(i) == data::Datatype::numeric)
+      else if (datasetInfo->Type(i) == Datatype::numeric)
         numericSplits[numericIndex++].Train(point[i], label);
     }
 
@@ -673,10 +673,10 @@ size_t HoeffdingTree<
     // best two splits that can be done in every network.
     double bestGain = 0.0;
     double secondBestGain = 0.0;
-    if (type == data::Datatype::categorical)
+    if (type == Datatype::categorical)
       categoricalSplits[index].EvaluateFitnessFunction(bestGain,
           secondBestGain);
-    else if (type == data::Datatype::numeric)
+    else if (type == Datatype::numeric)
       numericSplits[index].EvaluateFitnessFunction(bestGain, secondBestGain);
 
     // See if these gains are better than the previous.
@@ -706,7 +706,7 @@ size_t HoeffdingTree<
     splitDimension = largestIndex;
     const size_t type = dimensionMappings->at(largestIndex).first;
     const size_t index = dimensionMappings->at(largestIndex).second;
-    if (type == data::Datatype::categorical)
+    if (type == Datatype::categorical)
     {
       // I don't know if this should be here.
       majorityClass = categoricalSplits[index].MajorityClass();
@@ -801,9 +801,9 @@ size_t HoeffdingTree<
 >::CalculateDirection(const VecType& point) const
 {
   // Don't call this before the node is split...
-  if (datasetInfo->Type(splitDimension) == data::Datatype::numeric)
+  if (datasetInfo->Type(splitDimension) == Datatype::numeric)
     return numericSplit.CalculateDirection(point[splitDimension]);
-  else if (datasetInfo->Type(splitDimension) == data::Datatype::categorical)
+  else if (datasetInfo->Type(splitDimension) == Datatype::categorical)
     return categoricalSplit.CalculateDirection(point[splitDimension]);
   else
     return 0; // Not sure what to do here...
@@ -938,13 +938,13 @@ void HoeffdingTree<
   // Create the children.
   arma::Col<size_t> childMajorities;
   if (dimensionMappings->at(splitDimension).first ==
-      data::Datatype::categorical)
+      Datatype::categorical)
   {
     categoricalSplits[dimensionMappings->at(splitDimension).second].Split(
         childMajorities, categoricalSplit);
   }
   else if (dimensionMappings->at(splitDimension).first ==
-           data::Datatype::numeric)
+           Datatype::numeric)
   {
     numericSplits[dimensionMappings->at(splitDimension).second].Split(
         childMajorities, numericSplit);
@@ -1016,7 +1016,7 @@ void HoeffdingTree<
 {
   if (ownsInfo)
     delete datasetInfo;
-  datasetInfo = new data::DatasetInfo(dimensionality); // All features numeric.
+  datasetInfo = new DatasetInfo(dimensionality); // All features numeric.
   ownsInfo = true;
 
   this->numClasses = numClasses;
@@ -1033,7 +1033,7 @@ void HoeffdingTree<
     FitnessFunction,
     NumericSplitType,
     CategoricalSplitType
->::Reset(const data::DatasetInfo& info, const size_t numClasses)
+>::Reset(const DatasetInfo& info, const size_t numClasses)
 {
   if (ownsInfo)
     delete datasetInfo;
@@ -1066,9 +1066,9 @@ void HoeffdingTree<
   ar(CEREAL_POINTER(dimensionMappings));
 
   // Special handling for const object.
-  data::DatasetInfo* d = NULL;
+  DatasetInfo* d = NULL;
   if (cereal::is_saving<Archive>())
-    d = const_cast<data::DatasetInfo*>(datasetInfo);
+    d = const_cast<DatasetInfo*>(datasetInfo);
   ar(CEREAL_POINTER(d));
 
   if (cereal::is_loading<Archive>())
@@ -1108,7 +1108,7 @@ void HoeffdingTree<
       categoricalSplits.clear();
       for (size_t i = 0; i < datasetInfo->Dimensionality(); ++i)
       {
-        if (datasetInfo->Type(i) == data::Datatype::categorical)
+        if (datasetInfo->Type(i) == Datatype::categorical)
           categoricalSplits.push_back(CategoricalSplitType<FitnessFunction>(
               datasetInfo->NumMappings(i), numClasses));
         else
@@ -1136,7 +1136,7 @@ void HoeffdingTree<
   else
   {
     // We have split, so we only need to save the split and the children.
-    if (datasetInfo->Type(splitDimension) == data::Datatype::categorical)
+    if (datasetInfo->Type(splitDimension) == Datatype::categorical)
       ar(CEREAL_NVP(categoricalSplit));
     else
       ar(CEREAL_NVP(numericSplit));
@@ -1280,18 +1280,18 @@ void HoeffdingTree<
   ownsMappings = true;
   for (size_t i = 0; i < datasetInfo->Dimensionality(); ++i)
   {
-    if (datasetInfo->Type(i) == data::Datatype::categorical)
+    if (datasetInfo->Type(i) == Datatype::categorical)
     {
       categoricalSplits.push_back(CategoricalSplitType<FitnessFunction>(
           datasetInfo->NumMappings(i), numClasses, categoricalSplitIn));
-      (*dimensionMappings)[i] = std::make_pair(data::Datatype::categorical,
+      (*dimensionMappings)[i] = std::make_pair(Datatype::categorical,
           categoricalSplits.size() - 1);
     }
     else
     {
       numericSplits.push_back(NumericSplitType<FitnessFunction>(numClasses,
           numericSplitIn));
-      (*dimensionMappings)[i] = std::make_pair(data::Datatype::numeric,
+      (*dimensionMappings)[i] = std::make_pair(Datatype::numeric,
           numericSplits.size() - 1);
     }
   }

mlpack/include/mlpack/methods/hoeffding_trees/hoeffding_tree_main.cpp

@@ -23,7 +23,6 @@
 
 using namespace std;
 using namespace mlpack;
-using namespace mlpack::data;
 using namespace mlpack::util;
 
 // Program Name.
@@ -276,7 +275,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   if (params.Has("test"))
   {
     // Before loading, pre-set the dataset info by getting the raw parameter
-    // (that doesn't call data::Load()).
+    // (that doesn't call Load()).
     std::get<0>(params.GetRaw<TupleType>("test")) = datasetInfo;
     arma::mat testSet = std::get<1>(params.Get<TupleType>("test"));
 

mlpack/include/mlpack/methods/hoeffding_trees/hoeffding_tree_model.hpp

@@ -112,7 +112,7 @@ class HoeffdingTreeModel
    *      Hoeffding numeric split.
    */
   void BuildModel(const arma::mat& dataset,
-                  const data::DatasetInfo& datasetInfo,
+                  const DatasetInfo& datasetInfo,
                   const arma::Row<size_t>& labels,
                   const size_t numClasses,
                   const bool batchTraining,
@@ -185,7 +185,7 @@ class HoeffdingTreeModel
     ar(CEREAL_NVP(type));
 
     // Fake dataset info may be needed to create fake trees.
-    data::DatasetInfo info;
+    DatasetInfo info;
     if (type == GINI_HOEFFDING)
       ar(CEREAL_POINTER(giniHoeffdingTree));
     else if (type == GINI_BINARY)

mlpack/include/mlpack/methods/hoeffding_trees/hoeffding_tree_model_impl.hpp

@@ -129,7 +129,7 @@ inline HoeffdingTreeModel::~HoeffdingTreeModel()
 // Create the model.
 inline void HoeffdingTreeModel::BuildModel(
     const arma::mat& dataset,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     const arma::Row<size_t>& labels,
     const size_t numClasses,
     const bool batchTraining,

mlpack/include/mlpack/methods/kde/kde_rules_impl.hpp

@@ -226,10 +226,10 @@ Score(const size_t queryIndex, TreeType& referenceNode)
         sample(oldSize + i) =
             EvaluateKernel(queryIndex, referenceNode.Descendant(randomPoint));
       }
-      meanSample = arma::mean(sample);
-      const double stddev = arma::stddev(sample);
+      meanSample = mean(sample);
+      const double sampleStddev = stddev(sample);
       const double mThreshBase =
-          z * stddev * (1 + relError) / (relError * meanSample);
+          z * sampleStddev * (1 + relError) / (relError * meanSample);
       const size_t mThresh = std::ceil(mThreshBase * mThreshBase);
 
       if (sample.size() < mThresh)
@@ -441,10 +441,10 @@ Score(TreeType& queryNode, TreeType& referenceNode)
           sample(oldSize + i) =
               EvaluateKernel(queryIndex, referenceNode.Descendant(randomPoint));
         }
-        meanSample = arma::mean(sample);
-        const double stddev = arma::stddev(sample);
+        meanSample = mean(sample);
+        const double sampleStddev = stddev(sample);
         const double mThreshBase =
-            z * stddev * (1 + relError) / (relError * meanSample);
+            z * sampleStddev * (1 + relError) / (relError * meanSample);
         const size_t mThresh = std::ceil(mThreshBase * mThreshBase);
 
         if (sample.size() < mThresh)

mlpack/include/mlpack/methods/lars/lars_impl.hpp

@@ -510,7 +510,7 @@ LARS<ModelMatType>::Train(const MatType& matX,
   {
     if (fitIntercept)
     {
-      offsetX = arma::mean(matX, 1);
+      offsetX = mean(matX, 1);
       dataTrans = (matX.each_col() - offsetX).t();
     }
 
@@ -536,7 +536,7 @@ LARS<ModelMatType>::Train(const MatType& matX,
     // We don't need to transpose the data---it's already in row-major form.
     if (fitIntercept)
     {
-      offsetX = arma::mean(matX, 0).t();
+      offsetX = mean(matX, 0).t();
       dataTrans = (matX.each_row() - offsetX.t());
     }
 
@@ -558,7 +558,7 @@ LARS<ModelMatType>::Train(const MatType& matX,
 
   if (fitIntercept)
   {
-    this->offsetY = arma::mean(y);
+    this->offsetY = mean(y);
     yCentered = y - this->offsetY;
   }
 

mlpack/include/mlpack/methods/linear_svm/linear_svm_function_impl.hpp

@@ -288,7 +288,7 @@ void LinearSVMFunction<MatType, ParametersType>::Gradient(
   }
   else
   {
-    gradient.set_size(arma::size(parameters));
+    gradient.set_size(size(parameters));
     gradient.submat(0, 0, parameters.n_rows - 2, parameters.n_cols - 1) =
         dataset * difference.t();
     gradient.row(parameters.n_rows - 1) =
@@ -345,7 +345,7 @@ void LinearSVMFunction<MatType, ParametersType>::Gradient(
   }
   else
   {
-    gradient.set_size(arma::size(parameters));
+    gradient.set_size(size(parameters));
     gradient.submat(0, 0, parameters.n_rows - 2, parameters.n_cols - 1) =
         dataset.cols(firstId, lastId) * difference.t();
     gradient.row(parameters.n_rows - 1) =
@@ -400,7 +400,7 @@ LinearSVMFunction<MatType, ParametersType>::EvaluateWithGradient(
   }
   else
   {
-    gradient.set_size(arma::size(parameters));
+    gradient.set_size(size(parameters));
     gradient.submat(0, 0, parameters.n_rows - 2, parameters.n_cols - 1) =
             dataset * difference.t();
     gradient.row(parameters.n_rows - 1) =
@@ -472,7 +472,7 @@ LinearSVMFunction<MatType, ParametersType>::EvaluateWithGradient(
   }
   else
   {
-    gradient.set_size(arma::size(parameters));
+    gradient.set_size(size(parameters));
     gradient.submat(0, 0, parameters.n_rows - 2, parameters.n_cols - 1) =
         dataset.cols(firstId, lastId) * difference.t();
     gradient.row(parameters.n_rows - 1) =