mlpack 4.6.2__cp313-cp313-win_amd64.whl → 4.7.0__cp313-cp313-win_amd64.whl

mlpack/include/mlpack/methods/ann/rnn_impl.hpp

@@ -161,7 +161,7 @@ typename MatType::elem_type RNN<
     OptimizerType& optimizer,
     CallbackTypes&&... callbacks)
 {
-  ResetData(std::move(predictors), std::move(responses), arma::urowvec());
+  ResetData(std::move(predictors), std::move(responses), URowType());
 
   network.WarnMessageMaxIterations(optimizer, this->predictors.n_cols);
 
@@ -170,8 +170,8 @@ typename MatType::elem_type RNN<
 
   // Train the model.
   Timer::Start("rnn_optimization");
-  const typename MatType::elem_type out =
-      optimizer.Optimize(*this, network.Parameters(), callbacks...);
+  const ElemType out = optimizer.Optimize(*this, network.Parameters(),
+      callbacks...);
   Timer::Stop("rnn_optimization");
 
   Log::Info << "RNN::Train(): final objective of trained model is " << out
@@ -212,7 +212,7 @@ typename MatType::elem_type RNN<
 >::Train(
     CubeType predictors,
     CubeType responses,
-    arma::urowvec sequenceLengths,
+    URowType sequenceLengths,
     OptimizerType& optimizer,
     CallbackTypes&&... callbacks)
 {
@@ -226,8 +226,8 @@ typename MatType::elem_type RNN<
 
   // Train the model.
   Timer::Start("rnn_optimization");
-  const typename MatType::elem_type out =
-      optimizer.Optimize(*this, network.Parameters(), callbacks...);
+  const ElemType out = optimizer.Optimize(*this, network.Parameters(),
+      callbacks...);
   Timer::Stop("rnn_optimization");
 
   Log::Info << "RNN::Train(): final objective of trained model is " << out
@@ -248,7 +248,7 @@ typename MatType::elem_type RNN<
 >::Train(
     CubeType predictors,
     CubeType responses,
-    arma::urowvec sequenceLengths,
+    URowType sequenceLengths,
     CallbackTypes&&... callbacks)
 {
   OptimizerType optimizer;
@@ -289,7 +289,8 @@ void RNN<
     // Iterate over all time steps.
     for (size_t t = 0; t < predictors.n_slices; ++t)
     {
-      SetCurrentStep(t, (t == predictors.n_slices - 1));
+      SetCurrentStep(t, (t == predictors.n_slices - 1), effectiveBatchSize,
+          effectiveBatchSize);
 
       // Create aliases for the input and output.  If we are in single mode, we
       // always output into the same slice.
@@ -315,7 +316,7 @@ void RNN<
 >::Predict(
     const CubeType& predictors,
     CubeType& results,
-    const arma::urowvec& sequenceLengths)
+    const URowType& sequenceLengths)
 {
   // Ensure that the network is configured correctly.
   network.CheckNetwork("RNN::Predict()", predictors.n_rows, true, false);
@@ -334,7 +335,7 @@ void RNN<
     const size_t steps = sequenceLengths[i];
     for (size_t t = 0; t < steps; ++t)
     {
-      SetCurrentStep(t, (t == steps - 1));
+      SetCurrentStep(t, (t == steps - 1), 1, 1);
 
       // Create aliases for the input and output.  If we are in single mode, we
       // always output into the same slice.
@@ -375,6 +376,132 @@ void RNN<
   }
 }
 
+template<
+    typename OutputLayerType,
+    typename InitializationRuleType,
+    typename MatType
+>
+typename MatType::elem_type RNN<
+    OutputLayerType,
+    InitializationRuleType,
+    MatType
+>::Evaluate(
+    const CubeType& predictors,
+    const CubeType& responses)
+{
+  // Ensure that the network is configured correctly.
+  network.CheckNetwork("RNN::Evaluate()", predictors.n_rows);
+
+  // Add the loss of the network unrelated to output.
+  ElemType lossSum = ElemType(network.network.Loss());
+
+  // Reset recurrent memory state.
+  ResetMemoryState(0, predictors.n_cols);
+
+  // Iterate over all time slices.
+  MatType forwardOutput;
+  for (size_t t = 0; t < predictors.n_slices; t++)
+  {
+    SetCurrentStep(t, (t == predictors.n_slices - 1), predictors.n_cols,
+        predictors.n_cols);
+    // Do a forward pass and calculate the loss.
+    network.Forward(predictors.slice(t), forwardOutput);
+    if (!single || t == predictors.n_slices - 1)
+      lossSum += network.outputLayer.Forward(forwardOutput,
+          responses.slice(single ? 0 : t));
+  }
+
+  return lossSum;
+}
+
+template<
+    typename OutputLayerType,
+    typename InitializationRuleType,
+    typename MatType
+>
+typename MatType::elem_type RNN<
+    OutputLayerType,
+    InitializationRuleType,
+    MatType
+>::Evaluate(
+    const CubeType& predictors,
+    const CubeType& responses,
+    const URowType& sequenceLengths,
+    const size_t batchSize)
+{
+  // Ensure that the network is configured correctly.
+  network.CheckNetwork("RNN::Evaluate()", predictors.n_rows);
+
+  if (sequenceLengths.n_elem > 0 && batchSize != 1 && single)
+    throw std::invalid_argument(
+        "Batch size must be 1 for ragged sequences in single mode!");
+
+  // Add the loss of the network unrelated to output.
+  ElemType lossSum = ElemType(network.network.Loss());
+
+  CubeType reordPredictors, reordResponses;
+  URowType reordLengths;
+  if (batchSize > 1)
+  {
+    // Make copies of the arguments so they can be reordered while the orignal
+    // arguments stay constant.
+    reordPredictors = predictors;
+    reordResponses = responses;
+    reordLengths = sequenceLengths;
+  }
+  else
+  {
+    // Reordering isn't actually needed so we just make aliases.
+    MakeAlias(reordPredictors, predictors, predictors.n_rows,
+        predictors.n_cols, predictors.n_slices);
+    MakeAlias(reordResponses, responses, responses.n_rows,
+        responses.n_cols, responses.n_slices);
+    MakeAlias(reordLengths, sequenceLengths, sequenceLengths.n_elem);
+  }
+
+  for (size_t i = 0; i < predictors.n_cols; i += batchSize)
+  {
+    size_t effectiveBatchSize = std::min(batchSize,
+        size_t(predictors.n_cols) - i);
+
+    // Reset recurrent memory state.
+    ResetMemoryState(0, effectiveBatchSize);
+
+    // Reorder the data so the sequence lengths are in descending order.
+    if (batchSize > 1)
+      ReorderBatch(i, effectiveBatchSize, reordPredictors, reordResponses,
+          reordLengths);
+
+    MatType forwardOutput, inputAlias, responseAlias;
+    // Iterate over all time slices.
+    size_t slices = reordLengths
+        .subvec(i, i + effectiveBatchSize - 1).max();
+    size_t activeBatchSize = effectiveBatchSize;
+    for (size_t t = 0; t < slices; t++)
+    {
+      // Calculate the number of active points.
+      CalculateActivePoints(activeBatchSize, i, reordLengths, t);
+
+      SetCurrentStep(t, (t == slices - 1), effectiveBatchSize, activeBatchSize);
+
+      // Get the input and response data.
+      MakeAlias(inputAlias, reordPredictors.slice(t), predictors.n_rows,
+          activeBatchSize, i * predictors.n_rows);
+
+      // Do a forward pass and calculate the loss.
+      network.Forward(inputAlias, forwardOutput);
+      if (!single || t == slices - 1)
+      {
+        MakeAlias(responseAlias, reordResponses.slice((single ? 0 : t)),
+            responses.n_rows, activeBatchSize, i * responses.n_rows);
+        lossSum += network.outputLayer.Forward(forwardOutput, responseAlias);
+      }
+    }
+  }
+
+  return lossSum;
+}
+
 template<
     typename OutputLayerType,
     typename InitializationRuleType,
@@ -431,32 +558,43 @@ typename MatType::elem_type RNN<
   // Ensure the network is valid.
   network.CheckNetwork("RNN::Evaluate()", predictors.n_rows);
 
+  if (sequenceLengths.n_elem > 0 && batchSize != 1 && single)
+    throw std::invalid_argument(
+        "Batch size must be 1 for ragged sequences in single mode!");
+
   // The core of the computation here is to pass through each step.  Since we
   // are not computing the gradient, we can be "clever" and use only one memory
   // cell---we don't need to know about the past.
-  ResetMemoryState(1, batchSize);
+  ResetMemoryState(0, batchSize);
   MatType output(network.network.OutputSize(), batchSize);
 
-  if (sequenceLengths.n_elem > 0 && batchSize != 1)
-    throw std::invalid_argument("Batch size must be 1 for ragged sequences!");
+  // Reorder the data so the sequence lengths are in descending order.
+  if (sequenceLengths.n_elem > 0 && batchSize > 1)
+    ReorderBatch(begin, batchSize, predictors, responses, sequenceLengths);
 
-  typename MatType::elem_type loss = 0.0;
+  ElemType loss = 0;
   MatType stepData, responseData;
   const size_t steps = (sequenceLengths.n_elem == 0) ? predictors.n_slices :
-      sequenceLengths[begin];
+      sequenceLengths.subvec(begin, begin + batchSize - 1).max();
+  size_t activeBatchSize = batchSize;
   for (size_t t = 0; t < steps; ++t)
   {
+    // Calculate the number of active points.
+    if (sequenceLengths.n_elem > 0)
+      CalculateActivePoints(activeBatchSize, begin, sequenceLengths, t);
+
     // Manually reset the data of the network to be an alias of the current time
     // step.
-    SetCurrentStep(t, (t == steps));
+    SetCurrentStep(t, (t == steps), batchSize, activeBatchSize);
+
     MakeAlias(network.predictors, predictors.slice(t), predictors.n_rows,
-        batchSize, begin * predictors.slice(t).n_rows);
+        activeBatchSize, begin * predictors.slice(t).n_rows);
     const size_t responseStep = (single) ? 0 : t;
     MakeAlias(network.responses, responses.slice(responseStep),
-        responses.n_rows, batchSize,
+        responses.n_rows, activeBatchSize,
         begin * responses.slice(responseStep).n_rows);
 
-    loss += network.Evaluate(output, begin, batchSize);
+    loss += network.Evaluate(output, begin, activeBatchSize);
   }
 
   return loss;
@@ -497,10 +635,11 @@ typename MatType::elem_type RNN<
 {
   network.CheckNetwork("RNN::EvaluateWithGradient()", predictors.n_rows);
 
-  if (sequenceLengths.n_elem > 0 && batchSize != 1)
-    throw std::invalid_argument("Batch size must be 1 for ragged sequences!");
+  if (sequenceLengths.n_elem > 0 && batchSize != 1 && single)
+    throw std::invalid_argument(
+        "Batch size must be 1 for ragged sequences in single mode!");
 
-  typename MatType::elem_type loss = 0;
+  ElemType loss = 0;
 
   // We must save anywhere between 1 and `bpttSteps` states, but we are limited
   // by `predictors.n_slices`.
@@ -523,22 +662,31 @@ typename MatType::elem_type RNN<
   // Add loss (this is not dependent on time steps, and should only be added
   // once).  This is, e.g., regularizer loss, and other additive losses not
   // having to do with the output layer.
-  loss += network.network.Loss();
+  loss += ElemType(network.network.Loss());
+
+  // Reorder the data so the sequence lengths are in descending order.
+  if (sequenceLengths.n_elem > 0 && batchSize > 1)
+    ReorderBatch(begin, batchSize, predictors, responses, sequenceLengths);
 
   // For backpropagation through time, we must backpropagate for every
   // subsequence of length `bpttSteps`.  Before we've taken `bpttSteps` though,
   // we will be backpropagating shorter sequences.
   const size_t steps = (sequenceLengths.n_elem == 0) ? predictors.n_slices :
-      sequenceLengths[begin];
+      sequenceLengths.subvec(begin, begin + batchSize - 1).max();
+  size_t activeBatchSize = batchSize;
   for (size_t t = 0; t < steps; ++t)
   {
-    SetCurrentStep(t, (t == (steps - 1)));
+    // Calculate the number of active points.
+    if (sequenceLengths.n_elem > 0)
+      CalculateActivePoints(activeBatchSize, begin, sequenceLengths, t);
+
+    SetCurrentStep(t, (t == (steps - 1)), batchSize, activeBatchSize);
 
     // Make an alias of the step's data for the forward pass.
-    MakeAlias(stepData, predictors.slice(t), predictors.n_rows, batchSize,
-        begin * predictors.slice(t).n_rows);
+    MakeAlias(stepData, predictors.slice(t), predictors.n_rows, activeBatchSize,
+        begin * predictors.n_rows);
     MakeAlias(outputData, outputs.slice(t % effectiveBPTTSteps), outputs.n_rows,
-        outputs.n_cols);
+        activeBatchSize);
     network.network.Forward(stepData, outputData);
 
     // Determine what the response should be.  If we are in single mode but not
@@ -553,7 +701,7 @@ typename MatType::elem_type RNN<
     MatType error;
     for (size_t step = 0; step < std::min(t + 1, effectiveBPTTSteps); ++step)
     {
-      SetCurrentStep(t - step, (step == 0));
+      SetCurrentStep(t - step, (step == 0), batchSize, activeBatchSize, true);
 
       if (step > 0)
       {
@@ -561,9 +709,9 @@ typename MatType::elem_type RNN<
         error.zeros();
 
         MakeAlias(stepData, predictors.slice(t - step), predictors.n_rows,
-            batchSize, begin * predictors.slice(t - step).n_rows);
+            activeBatchSize, begin * predictors.slice(t - step).n_rows);
         MakeAlias(outputData, outputs.slice((t - step) % effectiveBPTTSteps),
-            outputs.n_rows, outputs.n_cols);
+            outputs.n_rows, activeBatchSize);
       }
       else
       {
@@ -571,11 +719,11 @@ typename MatType::elem_type RNN<
         // error.
         const size_t responseStep = (single) ? 0 : t - step;
         MakeAlias(stepData, predictors.slice(t - step), predictors.n_rows,
-            batchSize, begin * predictors.slice(t - step).n_rows);
+            activeBatchSize, begin * predictors.n_rows);
         MakeAlias(responseData, responses.slice(responseStep), responses.n_rows,
-            batchSize, begin * responses.slice(responseStep).n_rows);
+            activeBatchSize, begin * responses.n_rows);
         MakeAlias(outputData, outputs.slice((t - step) % effectiveBPTTSteps),
-            outputs.n_rows, outputs.n_cols);
+            outputs.n_rows, activeBatchSize);
 
         // We only need to do this on the first time step of BPTT.
         loss += network.outputLayer.Forward(outputData, responseData);
@@ -590,7 +738,8 @@ typename MatType::elem_type RNN<
       // TODO: note that we could avoid the copy of currentGradient by having
       // each layer *add* its gradient to `gradient`.  However that would
       // require some amount of refactoring.
-      MatType networkDelta;
+      MatType networkDelta(predictors.n_rows, activeBatchSize,
+          GetFillType<MatType>::none);
       GradType currentGradient(gradient.n_rows, gradient.n_cols,
           GetFillType<MatType>::zeros);
       network.network.Backward(stepData, outputData, error, networkDelta);
@@ -656,7 +805,7 @@ void RNN<
 >::ResetData(
     CubeType predictors,
     CubeType responses,
-    arma::urowvec sequenceLengths)
+    URowType sequenceLengths)
 {
   this->predictors = std::move(predictors);
   this->responses = std::move(responses);
@@ -694,17 +843,60 @@ void RNN<
     OutputLayerType,
     InitializationRuleType,
     MatType
->::SetCurrentStep(const size_t step, const bool end)
+>::SetCurrentStep(const size_t step,
+                  const bool end,
+                  size_t batchSize,
+                  size_t activeBatchSize,
+                  bool backwards)
 {
-  // Iterate over all layers and set the memory size.
+  // Iterate over all layers and set the current step.
   for (Layer<MatType>* l : network.Network())
   {
     // We can only call CurrentStep() on RecurrentLayers.
     RecurrentLayer<MatType>* r =
         dynamic_cast<RecurrentLayer<MatType>*>(l);
     if (r != nullptr)
+    {
       r->CurrentStep(step, end);
+      r->OnStepChanged(step, batchSize, activeBatchSize, backwards);
+    }
+  }
+}
+
+template<
+    typename OutputLayerType,
+    typename InitializationRuleType,
+    typename MatType
+>
+void RNN<
+    OutputLayerType,
+    InitializationRuleType,
+    MatType
+>::ReorderBatch(const size_t begin,
+                const size_t batchSize,
+                CubeType& predictors,
+                CubeType& responses,
+                URowType& sequenceLengths)
+{
+  using UColType = typename GetUColType<MatType>::type;
+  URowType batchLengths;
+  MakeAlias(batchLengths, sequenceLengths, batchSize, begin);
+
+  // Get the new ordering of this batch.
+  UColType ordering = sort_index(batchLengths, "descending");
+
+  // Reorder all slices to use the new ordering.
+  MatType batchPredictors, batchResponses;
+  for (size_t i = 0; i < predictors.n_slices; i++)
+  {
+    MakeAlias(batchPredictors, predictors.slice(i), predictors.n_rows,
+        batchSize, begin * predictors.n_rows);
+    MakeAlias(batchResponses, responses.slice(i), responses.n_rows,
+        batchSize, begin * responses.n_rows);
+    batchPredictors = batchPredictors.cols(ordering);
+    batchResponses = batchResponses.cols(ordering);
   }
+  batchLengths = batchLengths.cols(ordering);
 }
 
 } // namespace mlpack

mlpack/include/mlpack/methods/approx_kfn/drusilla_select_impl.hpp

@@ -80,7 +80,7 @@ void DrusillaSelect<MatType>::Train(
   candidateSet.set_size(referenceSet.n_rows, l * m);
   candidateIndices.set_size(l * m);
 
-  arma::vec dataMean(arma::mean(referenceSet, 1));
+  arma::vec dataMean(mean(referenceSet, 1));
   arma::vec norms(referenceSet.n_cols);
 
   MatType refCopy(referenceSet.n_rows, referenceSet.n_cols);

mlpack/include/mlpack/methods/bayesian_linear_regression/bayesian_linear_regression_main.cpp

@@ -100,7 +100,7 @@ BINDING_SEE_ALSO("Bayesian Interpolation",
     "https://cs.uwaterloo.ca/~mannr/cs886-w10/mackay-bayesian.pdf");
 BINDING_SEE_ALSO("Bayesian Linear Regression, Section 3.3",
     // I wonder how long this full text PDF will remain available...
-    "https://www.microsoft.com/en-us/research/uploads/prod/2006/01/"
+    "https://www.microsoft.com/en-us/research/wp-content/uploads/2006/01/"
     "Bishop-Pattern-Recognition-and-Machine-Learning-2006.pdf");
 BINDING_SEE_ALSO("BayesianLinearRegression C++ class documentation",
     "@doc/user/methods/bayesian_linear_regression.md");

mlpack/include/mlpack/methods/bias_svd/bias_svd_function_impl.hpp

@@ -313,7 +313,7 @@ inline double ParallelSGD<ExponentialBackoff>::Optimize(
     // Get the stepsize for this iteration
     double stepSize = decayPolicy.StepSize(i);
 
-    if (shuffle) // Determine order of visitation.
+    if (Shuffle()) // Determine order of visitation.
       std::shuffle(visitationOrder.begin(), visitationOrder.end(),
           mlpack::RandGen());
 

mlpack/include/mlpack/methods/cf/cf_model.hpp

@@ -100,7 +100,7 @@ class CFWrapper : public CFWrapperBase
             const size_t numUsersForSimilarity,
             const size_t rank,
             const size_t maxIterations,
-            const size_t minResidue,
+            const double minResidue,
             const bool mit) :
       cf(data,
          decomposition,

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

@@ -64,7 +64,7 @@ class DecisionTree :
    */
   template<typename MatType, typename LabelsType>
   DecisionTree(MatType data,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                LabelsType labels,
                const size_t numClasses,
                const size_t minimumLeafSize = 10,
@@ -121,7 +121,7 @@ class DecisionTree :
   template<typename MatType, typename LabelsType, typename WeightsType>
   DecisionTree(
       MatType data,
-      const data::DatasetInfo& datasetInfo,
+      const DatasetInfo& datasetInfo,
       LabelsType labels,
       const size_t numClasses,
       WeightsType weights,
@@ -186,7 +186,7 @@ class DecisionTree :
   DecisionTree(
       const DecisionTree& other,
       MatType data,
-      const data::DatasetInfo& datasetInfo,
+      const DatasetInfo& datasetInfo,
       LabelsType labels,
       const size_t numClasses,
       WeightsType weights,
@@ -291,7 +291,7 @@ class DecisionTree :
    */
   template<typename MatType, typename LabelsType>
   double Train(MatType data,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                LabelsType labels,
                const size_t numClasses,
                const size_t minimumLeafSize = 10,
@@ -350,7 +350,7 @@ class DecisionTree :
    */
   template<typename MatType, typename LabelsType, typename WeightsType>
   double Train(MatType data,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                LabelsType labels,
                const size_t numClasses,
                WeightsType weights,
@@ -540,7 +540,7 @@ class DecisionTree :
   double Train(MatType& data,
                const size_t begin,
                const size_t count,
-               const data::DatasetInfo& datasetInfo,
+               const DatasetInfo& datasetInfo,
                arma::Row<size_t>& labels,
                const size_t numClasses,
                WeightsType& weights,

mlpack/include/mlpack/methods/decision_tree/decision_tree_impl.hpp

@@ -29,7 +29,7 @@ DecisionTree<FitnessFunction,
              DimensionSelectionType,
              NoRecursion>::DecisionTree(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     LabelsType labels,
     const size_t numClasses,
     const size_t minimumLeafSize,
@@ -103,7 +103,7 @@ DecisionTree<FitnessFunction,
              DimensionSelectionType,
              NoRecursion>::DecisionTree(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     LabelsType labels,
     const size_t numClasses,
     WeightsType weights,
@@ -186,7 +186,7 @@ DecisionTree<FitnessFunction,
         NoRecursion>::DecisionTree(
     const DecisionTree& other,
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     LabelsType labels,
     const size_t numClasses,
     WeightsType weights,
@@ -446,7 +446,7 @@ double DecisionTree<FitnessFunction,
                     DimensionSelectionType,
                     NoRecursion>::Train(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     LabelsType labels,
     const size_t numClasses,
     const size_t minimumLeafSize,
@@ -527,7 +527,7 @@ double DecisionTree<FitnessFunction,
                     DimensionSelectionType,
                     NoRecursion>::Train(
     MatType data,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     LabelsType labels,
     const size_t numClasses,
     WeightsType weights,
@@ -618,7 +618,7 @@ double DecisionTree<FitnessFunction,
     MatType& data,
     const size_t begin,
     const size_t count,
-    const data::DatasetInfo& datasetInfo,
+    const DatasetInfo& datasetInfo,
     arma::Row<size_t>& labels,
     const size_t numClasses,
     WeightsType& weights,
@@ -650,7 +650,7 @@ double DecisionTree<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),
@@ -663,7 +663,7 @@ double DecisionTree<FitnessFunction,
             classProbabilities,
             *this);
       }
-      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),
@@ -699,14 +699,14 @@ double DecisionTree<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(classProbabilities, *this);
     else
       numChildren = NumericSplit::NumChildren(classProbabilities, *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(
@@ -868,7 +868,7 @@ double DecisionTree<FitnessFunction,
     size_t numChildren =
         NumericSplit::NumChildren(classProbabilities, *this);
     splitDimension = bestDim;
-    dimensionType = (size_t) data::Datatype::numeric;
+    dimensionType = (size_t) Datatype::numeric;
 
     // Calculate all child assignments.
     arma::Row<size_t> childAssignments(count);
@@ -1099,7 +1099,7 @@ size_t DecisionTree<FitnessFunction,
                     DimensionSelectionType,
                     NoRecursion>::CalculateDirection(const VecType& point) const
 {
-  if ((data::Datatype) dimensionType == data::Datatype::categorical)
+  if ((Datatype) dimensionType == Datatype::categorical)
     return CategoricalSplit::CalculateDirection(point[splitDimension],
         classProbabilities, *this);
   else

mlpack/include/mlpack/methods/decision_tree/decision_tree_main.cpp

@@ -19,7 +19,6 @@
 
 using namespace std;
 using namespace mlpack;
-using namespace mlpack::data;
 using namespace mlpack::util;
 
 // Program Name.