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

mlpack/include/mlpack/methods/linear_svm/linear_svm_main.cpp

@@ -313,7 +313,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   // Now, do the training.
   if (params.Has("training"))
   {
-    data::NormalizeLabels(rawLabels, labels, model->mappings);
+    NormalizeLabels(rawLabels, labels, model->mappings);
     numClasses = params.Get<int>("num_classes") == 0 ?
         model->mappings.n_elem : params.Get<int>("num_classes");
     model->svm.Lambda() = lambda;
@@ -410,7 +410,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     }
 
     model->svm.Classify(testSet, predictedLabels);
-    data::RevertLabels(predictedLabels, model->mappings, predictions);
+    RevertLabels(predictedLabels, model->mappings, predictions);
 
     // Calculate accuracy, if desired.
     if (params.Has("test_labels"))
@@ -419,7 +419,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
       arma::Row<size_t> testRawLabels =
           std::move(params.Get<arma::Row<size_t>>("test_labels"));
 
-      data::NormalizeLabels(testRawLabels, testLabels, model->mappings);
+      NormalizeLabels(testRawLabels, testLabels, model->mappings);
 
       if (testSet.n_cols != testLabels.n_elem)
       {

mlpack/include/mlpack/methods/lmnn/lmnn_main.cpp

@@ -326,7 +326,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   // Now, normalize the labels.
   arma::Col<size_t> mappings;
   arma::Row<size_t> labels;
-  data::NormalizeLabels(rawLabels, labels, mappings);
+  NormalizeLabels(rawLabels, labels, mappings);
 
   arma::mat distance;
 

mlpack/include/mlpack/methods/lsh/lsh_main.cpp

@@ -183,7 +183,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   if (params.Has("reference"))
   {
     // Workaround: this avoids printing load information twice for the CLI
-    // bindings, where GetPrintable() will trigger a call to data::Load(),
+    // bindings, where GetPrintable() will trigger a call to Load(),
     // which prints loading information in the middle of the Log::Info
     // message.
     (void) params.Get<arma::mat>("reference");

mlpack/include/mlpack/methods/matrix_completion/matrix_completion_impl.hpp

@@ -81,7 +81,7 @@ inline void MatrixCompletion::CheckValues()
     if (indices(0, i) >= m || indices(1, i) >= n)
       Log::Fatal << "MatrixCompletion::CheckValues(): indices ("
           << indices(0, i) << ", " << indices(1, i)
-          << ") are out of bounds for matrix of size " << m << " x n!"
+          << ") are out of bounds for matrix of size " << m << " x " << n << "!"
           << std::endl;
   }
 }

mlpack/include/mlpack/methods/naive_bayes/naive_bayes_classifier_impl.hpp

@@ -364,7 +364,7 @@ void NaiveBayesClassifier<ModelMatType>::Classify(
   ModelMatType logLikelihoods;
   LogLikelihood(data, logLikelihoods);
 
-  predictionProbs.set_size(arma::size(logLikelihoods));
+  predictionProbs.set_size(size(logLikelihoods));
   double maxValue, logProbX;
   for (size_t j = 0; j < data.n_cols; ++j)
   {

mlpack/include/mlpack/methods/naive_bayes/nbc_main.cpp

@@ -152,14 +152,14 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     {
       // Load labels.
       Row<size_t> rawLabels = std::move(params.Get<Row<size_t>>("labels"));
-      data::NormalizeLabels(rawLabels, labels, model->mappings);
+      NormalizeLabels(rawLabels, labels, model->mappings);
     }
     else
     {
       // Use the last row of the training data as the labels.
       Log::Info << "Using last dimension of training data as training labels."
           << endl;
-      data::NormalizeLabels(trainingData.row(trainingData.n_rows - 1), labels,
+      NormalizeLabels(trainingData.row(trainingData.n_rows - 1), labels,
           model->mappings);
       // Remove the label row.
       trainingData.shed_row(trainingData.n_rows - 1);
@@ -200,7 +200,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     {
       // Un-normalize labels to prepare output.
       Row<size_t> rawResults;
-      data::RevertLabels(predictions, model->mappings, rawResults);
+      RevertLabels(predictions, model->mappings, rawResults);
 
       if (params.Has("predictions"))
         params.Get<Row<size_t>>("predictions") = std::move(rawResults);

mlpack/include/mlpack/methods/nca/nca_main.cpp

@@ -217,7 +217,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   // Now, normalize the labels.
   arma::Col<size_t> mappings;
   arma::Row<size_t> labels;
-  data::NormalizeLabels(rawLabels, labels, mappings);
+  NormalizeLabels(rawLabels, labels, mappings);
 
   arma::mat distance;
 

mlpack/include/mlpack/methods/neighbor_search/kfn_main.cpp

@@ -179,16 +179,16 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   const string algorithm = params.Get<string>("algorithm");
   RequireParamInSet<string>(params, "algorithm", { "naive", "single_tree",
       "dual_tree", "greedy" }, true, "unknown neighbor search algorithm");
-  NeighborSearchMode searchMode = DUAL_TREE_MODE;
+  NeighborSearchStrategy searchStrategy = DUAL_TREE;
 
   if (algorithm == "naive")
-    searchMode = NAIVE_MODE;
+    searchStrategy = NAIVE;
   else if (algorithm == "single_tree")
-    searchMode = SINGLE_TREE_MODE;
+    searchStrategy = SINGLE_TREE;
   else if (algorithm == "dual_tree")
-    searchMode = DUAL_TREE_MODE;
+    searchStrategy = DUAL_TREE;
   else if (algorithm == "greedy")
-    searchMode = GREEDY_SINGLE_TREE_MODE;
+    searchStrategy = GREEDY_SINGLE_TREE;
 
   if (params.Has("reference"))
   {
@@ -240,7 +240,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     Log::Info << "Using reference data from "
         << params.GetPrintable<arma::mat>("reference") << "." << endl;
 
-    kfn->BuildModel(timers, std::move(referenceSet), searchMode, epsilon);
+    kfn->BuildModel(timers, std::move(referenceSet), searchStrategy, epsilon);
   }
   else
   {
@@ -248,7 +248,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     kfn = params.Get<KFNModel*>("input_model");
 
     // Adjust search mode.
-    kfn->SearchMode() = searchMode;
+    kfn->SearchStrategy() = searchStrategy;
     kfn->Epsilon() = epsilon;
 
     // If leaf_size wasn't provided, let's consider the current value in the
@@ -272,7 +272,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     if (params.Has("query"))
     {
       // Workaround: this avoids printing load information twice for the CLI
-      // bindings, where GetPrintable() will trigger a call to data::Load(),
+      // bindings, where GetPrintable() will trigger a call to Load(),
       // which prints loading information in the middle of the Log::Info
       // message.
       (void) params.Get<arma::mat>("query");

mlpack/include/mlpack/methods/neighbor_search/knn_main.cpp

@@ -187,16 +187,16 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
   const string algorithm = params.Get<string>("algorithm");
   RequireParamInSet<string>(params, "algorithm", { "naive", "single_tree",
       "dual_tree", "greedy" }, true, "unknown neighbor search algorithm");
-  NeighborSearchMode searchMode = DUAL_TREE_MODE;
+  NeighborSearchStrategy searchStrategy = DUAL_TREE;
 
   if (algorithm == "naive")
-    searchMode = NAIVE_MODE;
+    searchStrategy = NAIVE;
   else if (algorithm == "single_tree")
-    searchMode = SINGLE_TREE_MODE;
+    searchStrategy = SINGLE_TREE;
   else if (algorithm == "dual_tree")
-    searchMode = DUAL_TREE_MODE;
+    searchStrategy = DUAL_TREE;
   else if (algorithm == "greedy")
-    searchMode = GREEDY_SINGLE_TREE_MODE;
+    searchStrategy = GREEDY_SINGLE_TREE;
 
   if (params.Has("reference"))
   {
@@ -253,7 +253,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     Log::Info << "Using reference data from "
         << params.GetPrintable<arma::mat>("reference") << "." << endl;
 
-    knn->BuildModel(timers, std::move(referenceSet), searchMode, epsilon);
+    knn->BuildModel(timers, std::move(referenceSet), searchStrategy, epsilon);
   }
   else
   {
@@ -261,7 +261,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     knn = params.Get<KNNModel*>("input_model");
 
     // Adjust search mode.
-    knn->SearchMode() = searchMode;
+    knn->SearchStrategy() = searchStrategy;
     knn->Epsilon() = epsilon;
 
     // If leaf_size wasn't provided, let's consider the current value in the
@@ -285,7 +285,7 @@ void BINDING_FUNCTION(util::Params& params, util::Timers& timers)
     if (params.Has("query"))
     {
       // Workaround: this avoids printing load information twice for the CLI
-      // bindings, where GetPrintable() will trigger a call to data::Load(),
+      // bindings, where GetPrintable() will trigger a call to Load(),
       // which prints loading information in the middle of the Log::Info
       // message.
       (void) params.Get<arma::mat>("query");

mlpack/include/mlpack/methods/neighbor_search/neighbor_search.hpp

@@ -16,8 +16,6 @@
 #include <mlpack/core.hpp>
 
 #include "neighbor_search_stat.hpp"
-#include "sort_policies/nearest_neighbor_sort.hpp"
-#include "sort_policies/furthest_neighbor_sort.hpp"
 #include "neighbor_search_rules.hpp"
 #include "unmap.hpp"
 
@@ -32,7 +30,17 @@ template<typename SortPolicy,
          template<typename RuleType> class SingleTreeTraversalType>
 class LeafSizeNSWrapper;
 
-//! NeighborSearchMode represents the different neighbor search modes available.
+// NeighborSearchStrategy represents the different neighbor search strategies
+// available.
+enum NeighborSearchStrategy
+{
+  NAIVE,
+  SINGLE_TREE,
+  DUAL_TREE,
+  GREEDY_SINGLE_TREE
+};
+
+// This is for reverse compatibility and will be removed in mlpack 5.0.0.
 enum NeighborSearchMode
 {
   NAIVE_MODE,
@@ -41,6 +49,36 @@ enum NeighborSearchMode
   GREEDY_SINGLE_TREE_MODE
 };
 
+// This is for reverse compatibility and will be removed in mlpack 5.0.0.
+inline NeighborSearchStrategy ModeToStrategy(const NeighborSearchMode& mode)
+{
+  switch (mode)
+  {
+    case NAIVE_MODE:              return NAIVE;
+    case SINGLE_TREE_MODE:        return SINGLE_TREE;
+    case DUAL_TREE_MODE:          return DUAL_TREE;
+    case GREEDY_SINGLE_TREE_MODE: return GREEDY_SINGLE_TREE;
+  }
+
+  // Fix warning.
+  return DUAL_TREE;
+}
+
+// This is for reverse compatibility and will be removed in mlpack 5.0.0.
+inline NeighborSearchMode StrategyToMode(const NeighborSearchStrategy& strategy)
+{
+  switch (strategy)
+  {
+    case NAIVE:              return NAIVE_MODE;
+    case SINGLE_TREE:        return SINGLE_TREE_MODE;
+    case DUAL_TREE:          return DUAL_TREE_MODE;
+    case GREEDY_SINGLE_TREE: return GREEDY_SINGLE_TREE_MODE;
+  }
+
+  // Fix warning.
+  return DUAL_TREE_MODE;
+}
+
 /**
  * The NeighborSearch class is a template class for performing distance-based
  * neighbor searches.  It takes a query dataset and a reference dataset (or just
@@ -97,26 +135,34 @@ class NeighborSearch
    * pre-constructing the trees, passing std::move(yourReferenceSet).
    *
    * @param referenceSet Set of reference points.
-   * @param mode Neighbor search mode.
+   * @param strategy Neighbor search strategy.
    * @param epsilon Relative approximate error (non-negative).
    * @param distance An optional instance of the DistanceType class.
    */
   NeighborSearch(MatType referenceSet,
-                 const NeighborSearchMode mode = DUAL_TREE_MODE,
+                 const NeighborSearchStrategy strategy = DUAL_TREE,
                  const double epsilon = 0,
                  const DistanceType distance = DistanceType());
 
+  [[deprecated("Will be removed in mlpack 5.0.0.  Instead of a "
+               "NeighborSearchMode, pass a NeighborSearchStrategy.")]]
+  NeighborSearch(MatType referenceSet,
+                 const NeighborSearchMode mode,
+                 const double epsilon = 0,
+                 const DistanceType distance = DistanceType()) :
+      NeighborSearch(std::move(referenceSet), ModeToStrategy(mode), epsilon,
+                     distance) { }
+
   /**
    * Initialize the NeighborSearch object with a copy of the given
    * pre-constructed reference tree (this is the tree built on the points that
-   * will be searched).  Optionally, choose to use single-tree mode.  Naive mode
-   * is not available as an option for this constructor.  Additionally, an
-   * instantiated distance metric can be given, for cases where the distance
-   * metric holds data.
+   * will be searched).  Optionally, choose to use a different search strategy.
+   * Additionally, an instantiated distance metric can be given, for cases where
+   * the distance metric holds data.
    *
    * This method will copy the given tree. When copies must absolutely be
    * avoided, you can avoid this copy, while taking ownership of the given tree,
-   * by passing std::move(yourReferenceTree)
+   * by passing std::move(yourReferenceTree).
    *
    * @note
    * Mapping the points of the matrix back to their original indices is not done
@@ -127,12 +173,28 @@ class NeighborSearch
    * @param referenceTree Pre-built tree for reference points.
    * @param mode Neighbor search mode.
    * @param epsilon Relative approximate error (non-negative).
-   * @param distance Instantiated distance metric.
    */
   NeighborSearch(Tree referenceTree,
-                 const NeighborSearchMode mode = DUAL_TREE_MODE,
-                 const double epsilon = 0,
-                 const DistanceType distance = DistanceType());
+                 const NeighborSearchStrategy strategy = DUAL_TREE,
+                 const double epsilon = 0);
+
+  [[deprecated("Will be removed in mlpack 5.0.0.  Instead of a "
+               "NeighborSearchMode, pass a NeighborSearchStrategy.")]]
+  NeighborSearch(Tree referenceTree,
+                 const NeighborSearchMode mode,
+                 const double epsilon = 0) :
+      NeighborSearch(std::move(referenceTree), ModeToStrategy(mode), epsilon) {}
+
+  // This version is kept around for reverse compatibility; but, if you are
+  // passing a distance, you should use the overload above, which will just use
+  // the distance directly from the given tree.
+  [[deprecated("Will be removed in mlpack 5.0.0.  Use the version without "
+               "`distance` instead (`referenceTree.Distance()` will be used as "
+               "the distance metric).")]]
+  NeighborSearch(Tree referenceTree,
+                 const NeighborSearchMode mode,
+                 const double epsilon,
+                 const DistanceType distance);
 
   /**
    * Create a NeighborSearch object without any reference data.  If Search() is
@@ -143,10 +205,17 @@ class NeighborSearch
    * @param epsilon Relative approximate error (non-negative).
    * @param distance Instantiated distance metric.
    */
-  NeighborSearch(const NeighborSearchMode mode = DUAL_TREE_MODE,
+  NeighborSearch(const NeighborSearchStrategy strategy = DUAL_TREE,
                  const double epsilon = 0,
                  const DistanceType distance = DistanceType());
 
+  [[deprecated("Will be removed in mlpack 5.0.0.  Instead of a "
+               "NeighborSearchMode, pass a NeighborSearchStrategy.")]]
+  NeighborSearch(const NeighborSearchMode mode,
+                 const double epsilon = 0,
+                 const DistanceType distance = DistanceType()) :
+      NeighborSearch(ModeToStrategy(mode), epsilon, distance) { }
+
   /**
    * Construct the NeighborSearch object by copying the given NeighborSearch
    * object.
@@ -213,8 +282,8 @@ class NeighborSearch
    *
    * If querySet contains only a few query points, the extra cost of building a
    * tree on the points for dual-tree search may not be warranted, and it may be
-   * worthwhile to set singleMode = false (either in the constructor or with
-   * SingleMode()).
+   * worthwhile to set mode to SINGLE_TREE_MODE (either in the constructor or
+   * with SearchMode()).
    *
    * @param querySet Set of query points (can be just one point).
    * @param k Number of neighbors to search for.
@@ -311,17 +380,31 @@ class NeighborSearch
   static double Recall(arma::Mat<IndexType>& foundNeighbors,
                        arma::Mat<IndexType>& realNeighbors);
 
-  //! Return the total number of base case evaluations performed during the last
-  //! search.
+  // Reset all bounding quantities in a prebuilt external tree.
+  // When calling Search() multiple times with a prebuilt query tree, this must
+  // be called between each Search() invocation!
+  static void ResetTree(Tree& tree);
+
+  // Return the total number of base case evaluations performed during the last
+  // search.
   size_t BaseCases() const { return baseCases; }
 
-  //! Return the number of node combination scores during the last search.
+  // Return the number of node combination scores during the last search.
   size_t Scores() const { return scores; }
 
-  //! Access the search mode.
+  // Access the search mode.
+  [[deprecated("Will be removed in mlpack 5.0.0.  Use SearchStrategy() "
+               "instead.")]]
   NeighborSearchMode SearchMode() const { return searchMode; }
-  //! Modify the search mode.
-  NeighborSearchMode& SearchMode() { return searchMode; }
+  // Modify the search mode.
+  [[deprecated("Will be removed in mlpack 5.0.0.  Use SearchStrategy() "
+               "instead.")]]
+  NeighborSearchMode& SearchMode() { searchModeMod = true; return searchMode; }
+
+  // Access the search strategy.
+  NeighborSearchStrategy SearchStrategy() const { return searchStrategy; }
+  // Modify the search strategy.
+  NeighborSearchStrategy& SearchStrategy() { return searchStrategy; }
 
   //! Access the relative error to be considered in approximate search.
   double Epsilon() const { return epsilon; }
@@ -341,37 +424,74 @@ class NeighborSearch
   void serialize(Archive& ar, const uint32_t version);
 
  private:
-  //! Permutations of reference points during tree building.
+  // Permutations of reference points during tree building.
   std::vector<size_t> oldFromNewReferences;
-  //! Pointer to the root of the reference tree.
+  // Pointer to the root of the reference tree.
   Tree* referenceTree;
-  //! Reference dataset.  In some situations we may be the owner of this.
+  // Reference dataset.  In some situations we may be the owner of this.
   const MatType* referenceSet;
 
-  //! Indicates the neighbor search mode.
+  // This is only kept for reverse compatibility and will be removed in mlpack
+  // 5.0.0.
   NeighborSearchMode searchMode;
-  //! Indicates the relative error to be considered in approximate search.
+  bool searchModeMod; // also for reverse compatibility
+  // Indicates the neighbor search strategy.
+  NeighborSearchStrategy searchStrategy;
+  // Indicates the relative error to be considered in approximate search.
   double epsilon;
 
-  //! Instantiation of distance metric.
+  // Instantiation of distance metric.
   DistanceType distance;
 
-  //! The total number of base cases.
+  // The total number of base cases.
   size_t baseCases;
-  //! The total number of scores (applicable for non-naive search).
+  // The total number of scores (applicable for non-naive search).
   size_t scores;
 
-  //! If this is true, the reference tree bounds need to be reset on a call to
-  //! Search() without a query set.
+  // If this is true, the reference tree bounds need to be reset on a call to
+  // Search() without a query set.
   bool treeNeedsReset;
 
-  //! The NSModel class should have access to internal members.
+  // The NSModel class should have access to internal members.
   friend class LeafSizeNSWrapper<SortPolicy, TreeType, DualTreeTraversalType,
       SingleTreeTraversalType>;
 }; // class NeighborSearch
 
 } // namespace mlpack
 
+// The CEREAL_TEMPLATE_CLASS_VERSION() macro does not work with template
+// template parameters so we write it manually.
+namespace cereal {
+namespace detail {
+
+template<typename SortPolicy,
+         typename DistanceType,
+         typename MatType,
+         template<typename TreeDistanceType,
+                  typename TreeStatType,
+                  typename TreeMatType> class TreeType,
+         template<typename RuleType> class DualTreeTraversalType,
+         template<typename RuleType> class SingleTreeTraversalType>
+struct Version<mlpack::NeighborSearch<SortPolicy, DistanceType, MatType,
+    TreeType, DualTreeTraversalType, SingleTreeTraversalType>>
+{
+  static std::uint32_t registerVersion()
+  {
+    ::cereal::detail::StaticObject<Versions>::getInstance().mapping.emplace(
+        std::type_index(typeid(mlpack::NeighborSearch<SortPolicy, DistanceType,
+        MatType, TreeType, DualTreeTraversalType,
+        SingleTreeTraversalType>)).hash_code(), 1);
+    return 1;
+  }
+
+  static inline const std::uint32_t version = registerVersion();
+
+  static void unused() { (void) version; }
+}; /* end Version */
+
+} // namespace detail
+} // namespace cereal
+
 // Include implementation.
 #include "neighbor_search_impl.hpp"