mlpack 4.6.1__cp312-cp312-win_amd64.whl → 4.7.0__cp312-cp312-win_amd64.whl

mlpack/__init__.py

@@ -11,14 +11,14 @@ http://www.opensource.org/licenses/BSD-3-Clause for more information.
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_10_1():
+def _delvewheel_patch_1_12_0():
     import os
     if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'mlpack.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_10_1()
-del _delvewheel_patch_1_10_1
+_delvewheel_patch_1_12_0()
+del _delvewheel_patch_1_12_0
 # end delvewheel patch
 
 import warnings
@@ -74,4 +74,4 @@ from .adaboost import *
 from .linear_regression_train import linear_regression_train
 from .linear_regression_predict import linear_regression_predict
 from .linear_regression import *
-__version__='4.6.1'
+__version__='4.7.0'

mlpack/include/mlpack/base.hpp

@@ -86,6 +86,7 @@
 #include <armadillo>
 #include <mlpack/core/util/arma_traits.hpp>
 #include <mlpack/core/util/omp_reductions.hpp>
+#include <mlpack/core/arma_extend/find_nan.hpp>
 
 // On Visual Studio, disable C4519 (default arguments for function templates)
 // since it's by default an error, which doesn't even make any sense because

mlpack/include/mlpack/core/arma_extend/find_nan.hpp

@@ -0,0 +1,63 @@
+/**
+ * @file find_nan.hpp
+ * @author Ryan Curtin
+ *
+ * When find_nan() is not available (Armadillo < 11.4), provide an internal
+ * mlpack implementation that operates the same way.  It is slower.
+ */
+#ifndef MLPACK_CORE_ARMA_EXTEND_FIND_NAN_HPP
+#define MLPACK_CORE_ARMA_EXTEND_FIND_NAN_HPP
+
+namespace mlpack {
+
+#if ARMA_VERSION_MAJOR < 11 || \
+    (ARMA_VERSION_MAJOR == 11 && ARMA_VERSION_MINOR < 4)
+
+template<typename T>
+arma::uvec find_nan(const T& m,
+                    const std::enable_if_t<arma::is_arma_type<T>::value>* = 0)
+{
+  typedef typename T::elem_type ElemType;
+
+  if (!std::numeric_limits<ElemType>::has_quiet_NaN)
+    return arma::uvec(); // There can't be any NaNs.
+
+  // find_nonfinite() exists on older Armadillo, and we can also search for +Inf
+  // and -Inf.
+  arma::uvec nonfiniteIndices = arma::find_nonfinite(m);
+  if (nonfiniteIndices.n_elem == 0)
+    return arma::uvec();
+
+  arma::uvec infIndices = arma::find(
+      m == std::numeric_limits<ElemType>::infinity());
+  arma::uvec neginfIndices = arma::find(
+      m == -std::numeric_limits<ElemType>::infinity());
+
+  arma::uvec result(nonfiniteIndices.n_elem -
+      (infIndices.n_elem + neginfIndices.n_elem));
+  if (result.n_elem == 0)
+    return result;
+
+  size_t infIndex = 0;
+  size_t neginfIndex = 0;
+  size_t outputIndex = 0;
+  for (size_t i = 0; i < nonfiniteIndices.n_elem; ++i)
+  {
+    if (infIndex < infIndices.n_elem &&
+        nonfiniteIndices[i] == infIndices[infIndex])
+      ++infIndex;
+    else if (neginfIndex < neginfIndices.n_elem &&
+             nonfiniteIndices[i] == neginfIndices[neginfIndex])
+      ++neginfIndex;
+    else
+      result[outputIndex++] = nonfiniteIndices[i];
+  }
+
+  return result;
+}
+
+#endif
+
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/core/cereal/low_precision.hpp

@@ -0,0 +1,48 @@
+/**
+ * @file core/cereal/low_precision.hpp
+ * @author Ryan Curtin
+ *
+ * Extra shims necessary for cereal to serialize to JSON for low-precision types
+ * (e.g.  FP16, BF16, etc.).
+ *
+ * mlpack is free software; you may redistribute it and/or modify it under the
+ * terms of the 3-clause BSD license.  You should have received a copy of the
+ * 3-clause BSD license along with mlpack.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef MLPACK_CORE_CEREAL_LOW_PRECISION_HPP
+#define MLPACK_CORE_CEREAL_LOW_PRECISION_HPP
+
+namespace cereal {
+
+// Because our serialization is always done with name-value pairs, we can catch
+// any FP16 serialization at the NVP level with a specialized implementation of
+// the load and save functions for the JSON archive (the only one that does not
+// serialize low-precision correctly).
+
+#if defined(ARMA_HAVE_FP16)
+
+inline void CEREAL_SAVE_FUNCTION_NAME(JSONOutputArchive &ar,
+                                      NameValuePair<arma::fp16&> const& t)
+{
+  ar.setNextName(t.name);
+  std::ostringstream oss;
+  oss.precision(std::numeric_limits<arma::fp16>::max_digits10);
+  oss << t.value;
+  ar(oss.str());
+}
+
+inline void CEREAL_LOAD_FUNCTION_NAME(JSONInputArchive& ar,
+                                      NameValuePair<arma::fp16&>& t)
+{
+  ar.setNextName(t.name);
+  std::string encoded;
+  ar.loadValue(encoded);
+  t.value = arma::fp16(std::stof(encoded));
+}
+
+#endif
+
+} // namespace cereal
+
+#endif

mlpack/include/mlpack/core/cv/cv_base.hpp

@@ -57,12 +57,12 @@ class CVBase
 
   /**
    * Assert that MLAlgorithm takes the numClasses parameter and a
-   * data::DatasetInfo parameter and store them.
+   * DatasetInfo parameter and store them.
    *
    * @param datasetInfo Type information for each dimension of the dataset.
    * @param numClasses Number of classes in the dataset.
    */
-  CVBase(const data::DatasetInfo& datasetInfo,
+  CVBase(const DatasetInfo& datasetInfo,
          const size_t numClasses);
 
   /**
@@ -101,9 +101,9 @@ class CVBase
   static_assert(MIE::IsSupported,
       "The given MLAlgorithm is not supported by MetaInfoExtractor");
 
-  //! A variable for storing a data::DatasetInfo parameter if it is passed.
-  const data::DatasetInfo datasetInfo;
-  //! An indicator whether a data::DatasetInfo parameter has been passed.
+  //! A variable for storing a DatasetInfo parameter if it is passed.
+  const DatasetInfo datasetInfo;
+  //! An indicator whether a DatasetInfo parameter has been passed.
   const bool isDatasetInfoPassed;
   //! A variable for storing the numClasses parameter if it is passed.
   size_t numClasses;
@@ -145,7 +145,7 @@ class CVBase
 
   /**
    * Construct a trained MLAlgorithm model if MLAlgorithm takes the
-   * numClasses parameter and a data::DatasetInfo parameter.
+   * numClasses parameter and a DatasetInfo parameter.
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = MIE::TakesNumClasses & MIE::TakesDatasetInfo,
@@ -183,7 +183,7 @@ class CVBase
 
   /**
    * Construct a trained MLAlgorithm model if MLAlgorithm takes the
-   * numClasses parameter and a data::DatasetInfo parameter.
+   * numClasses parameter and a DatasetInfo parameter.
    */
   template<typename... MLAlgorithmArgs,
            bool Enabled = MIE::TakesNumClasses & MIE::TakesDatasetInfo,
@@ -196,13 +196,13 @@ class CVBase
                          const MLAlgorithmArgs&... args);
 
   /**
-   * When MLAlgorithm supports a data::DatasetInfo parameter, training should be
+   * When MLAlgorithm supports a DatasetInfo parameter, training should be
    * treated separately - there are models that can be constructed with and
    * without a data:DatasetInfo parameter and models that can be constructed
-   * only with a data::DatasetInfo parameter.
+   * only with a DatasetInfo parameter.
    *
    * Construct a trained MLAlgorithm model when it can be constructed without a
-   * data::DatasetInfo parameter.
+   * DatasetInfo parameter.
    */
   template<bool ConstructableWithoutDatasetInfo,
            typename... MLAlgorithmArgs,
@@ -213,7 +213,7 @@ class CVBase
 
   /**
    * Construct a trained MLAlgorithm model when it can't be constructed without
-   * a data::DatasetInfo parameter.
+   * a DatasetInfo parameter.
    */
   template<bool ConstructableWithoutDatasetInfo,
            typename... MLAlgorithmArgs,

mlpack/include/mlpack/core/cv/cv_base_impl.hpp

@@ -54,7 +54,7 @@ template<typename MLAlgorithm,
 CVBase<MLAlgorithm,
        MatType,
        PredictionsType,
-       WeightsType>::CVBase(const data::DatasetInfo& datasetInfo,
+       WeightsType>::CVBase(const DatasetInfo& datasetInfo,
                             const size_t numClasses) :
     datasetInfo(datasetInfo),
     isDatasetInfoPassed(true),
@@ -63,7 +63,7 @@ CVBase<MLAlgorithm,
   static_assert(MIE::TakesNumClasses,
       "The given MLAlgorithm does not take the numClasses parameter");
   static_assert(MIE::TakesDatasetInfo,
-      "The given MLAlgorithm does not accept a data::DatasetInfo parameter");
+      "The given MLAlgorithm does not accept a DatasetInfo parameter");
 }
 
 template<typename MLAlgorithm,
@@ -184,9 +184,9 @@ MLAlgorithm CVBase<MLAlgorithm,
 {
   static_assert(
       std::is_constructible_v<MLAlgorithm, const MatType&,
-          const data::DatasetInfo, const PredictionsType&, const size_t,
+          const DatasetInfo, const PredictionsType&, const size_t,
               MLAlgorithmArgs...>,
-      "The given MLAlgorithm is not constructible with a data::DatasetInfo "
+      "The given MLAlgorithm is not constructible with a DatasetInfo "
       "parameter and the passed arguments");
 
   static const bool constructableWithoutDatasetInfo =
@@ -256,9 +256,9 @@ MLAlgorithm CVBase<MLAlgorithm,
 {
   static_assert(
       std::is_constructible_v<MLAlgorithm, const MatType&,
-          const data::DatasetInfo, const PredictionsType&, const size_t,
+          const DatasetInfo, const PredictionsType&, const size_t,
               const WeightsType&, MLAlgorithmArgs...>,
-      "The given MLAlgorithm is not constructible with a data::DatasetInfo "
+      "The given MLAlgorithm is not constructible with a DatasetInfo "
       "parameter and the passed arguments");
 
   static const bool constructableWithoutDatasetInfo =
@@ -302,7 +302,7 @@ MLAlgorithm CVBase<MLAlgorithm,
 {
   if (!isDatasetInfoPassed)
     throw std::invalid_argument(
-        "The given MLAlgorithm requires a data::DatasetInfo parameter");
+        "The given MLAlgorithm requires a DatasetInfo parameter");
 
   return MLAlgorithm(xs, datasetInfo, ys, numClasses, args...);
 }

mlpack/include/mlpack/core/cv/k_fold_cv.hpp

@@ -14,6 +14,7 @@
 
 #include <mlpack/core/cv/meta_info_extractor.hpp>
 #include <mlpack/core/cv/cv_base.hpp>
+#include <mlpack/core/util/arma_traits.hpp>
 
 namespace mlpack {
 
@@ -96,7 +97,7 @@ class KFoldCV
 
   /**
    * This constructor can be used for multiclass classification algorithms that
-   * can take a data::DatasetInfo parameter.
+   * can take a DatasetInfo parameter.
    *
    * @param k Number of folds (should be at least 2).
    * @param xs Data points to cross-validate on.
@@ -107,7 +108,7 @@ class KFoldCV
    */
   KFoldCV(const size_t k,
           const MatType& xs,
-          const data::DatasetInfo& datasetInfo,
+          const DatasetInfo& datasetInfo,
           const PredictionsType& ys,
           const size_t numClasses,
           const bool shuffle = true);
@@ -149,7 +150,7 @@ class KFoldCV
 
   /**
    * This constructor can be used for multiclass classification algorithms that
-   * can take a data::DatasetInfo parameter and support weighted learning.
+   * can take a DatasetInfo parameter and support weighted learning.
    *
    * @param k Number of folds (should be at least 2).
    * @param xs Data points to cross-validate on.
@@ -161,7 +162,7 @@ class KFoldCV
    */
   KFoldCV(const size_t k,
           const MatType& xs,
-          const data::DatasetInfo& datasetInfo,
+          const DatasetInfo& datasetInfo,
           const PredictionsType& ys,
           const size_t numClasses,
           const WeightsType& weights,
@@ -280,30 +281,38 @@ class KFoldCV
   /**
    * Get the ith training subset from a variable of a matrix type.
    */
-  template<typename ElementType>
-  inline arma::Mat<ElementType> GetTrainingSubset(arma::Mat<ElementType>& m,
-                                                  const size_t i);
+  template<typename SubsetMatType>
+  inline SubsetMatType GetTrainingSubset(
+      SubsetMatType& m,
+      const size_t i,
+      const typename std::enable_if_t<IsMatrix<SubsetMatType>::value>* = 0);
 
   /**
    * Get the ith training subset from a variable of a row type.
    */
-  template<typename ElementType>
-  inline arma::Row<ElementType> GetTrainingSubset(arma::Row<ElementType>& r,
-                                                  const size_t i);
+  template<typename SubsetRowType>
+  inline SubsetRowType GetTrainingSubset(
+      SubsetRowType& r,
+      const size_t i,
+      const typename std::enable_if_t<IsRow<SubsetRowType>::value>* = 0);
 
   /**
    * Get the ith validation subset from a variable of a matrix type.
    */
-  template<typename ElementType>
-  inline arma::Mat<ElementType> GetValidationSubset(arma::Mat<ElementType>& m,
-                                                    const size_t i);
+  template<typename SubsetMatType>
+  inline SubsetMatType GetValidationSubset(
+      SubsetMatType& m,
+      const size_t i,
+      const typename std::enable_if_t<IsMatrix<SubsetMatType>::value>* = 0);
 
   /**
    * Get the ith validation subset from a variable of a row type.
    */
-  template<typename ElementType>
-  inline arma::Row<ElementType> GetValidationSubset(arma::Row<ElementType>& r,
-                                                    const size_t i);
+  template<typename SubsetRowType>
+  inline SubsetRowType GetValidationSubset(
+      SubsetRowType& r,
+      const size_t i,
+      const typename std::enable_if_t<IsRow<SubsetRowType>::value>* = 0);
 };
 
 } // namespace mlpack

mlpack/include/mlpack/core/cv/k_fold_cv_impl.hpp

@@ -58,7 +58,7 @@ KFoldCV<MLAlgorithm,
         PredictionsType,
         WeightsType>::KFoldCV(const size_t k,
                               const MatType& xs,
-                              const data::DatasetInfo& datasetInfo,
+                              const DatasetInfo& datasetInfo,
                               const PredictionsType& ys,
                               const size_t numClasses,
                               const bool shuffle) :
@@ -111,7 +111,7 @@ KFoldCV<MLAlgorithm,
         PredictionsType,
         WeightsType>::KFoldCV(const size_t k,
                               const MatType& xs,
-                              const data::DatasetInfo& datasetInfo,
+                              const DatasetInfo& datasetInfo,
                               const PredictionsType& ys,
                               const size_t numClasses,
                               const WeightsType& weights,
@@ -270,7 +270,7 @@ double KFoldCV<MLAlgorithm,
     return 0.0;
   }
 
-  return arma::mean(evaluations.elem(arma::find_finite(evaluations)));
+  return mean(evaluations.elem(find_finite(evaluations)));
 }
 
 template<typename MLAlgorithm,
@@ -300,7 +300,7 @@ double KFoldCV<MLAlgorithm,
       modelPtr.reset(new MLAlgorithm(std::move(model)));
   }
 
-  return arma::mean(evaluations);
+  return mean(evaluations);
 }
 
 template<typename MLAlgorithm,
@@ -375,14 +375,15 @@ template<typename MLAlgorithm,
          typename MatType,
          typename PredictionsType,
          typename WeightsType>
-template<typename ElementType>
-arma::Mat<ElementType> KFoldCV<MLAlgorithm,
-                               Metric,
-                               MatType,
-                               PredictionsType,
-                               WeightsType>::GetTrainingSubset(
-    arma::Mat<ElementType>& m,
-    const size_t i)
+template<typename SubsetMatType>
+SubsetMatType KFoldCV<MLAlgorithm,
+                      Metric,
+                      MatType,
+                      PredictionsType,
+                      WeightsType>::GetTrainingSubset(
+    SubsetMatType& m,
+    const size_t i,
+    const typename std::enable_if_t<IsMatrix<SubsetMatType>::value>*)
 {
   // If this is not the first fold, we have to handle it a little bit
   // differently, since the last fold may contain slightly more than 'binSize'
@@ -390,8 +391,9 @@ arma::Mat<ElementType> KFoldCV<MLAlgorithm,
   const size_t subsetSize = (i != 0) ? lastBinSize + (k - 2) * binSize :
       (k - 1) * binSize;
 
-  return arma::Mat<ElementType>(m.colptr(binSize * i), m.n_rows, subsetSize,
-      false, true);
+  SubsetMatType alias;
+  MakeAlias(alias, m, m.n_rows, subsetSize, m.n_rows * binSize * i);
+  return alias;
 }
 
 template<typename MLAlgorithm,
@@ -399,14 +401,15 @@ template<typename MLAlgorithm,
          typename MatType,
          typename PredictionsType,
          typename WeightsType>
-template<typename ElementType>
-arma::Row<ElementType> KFoldCV<MLAlgorithm,
-                               Metric,
-                               MatType,
-                               PredictionsType,
-                               WeightsType>::GetTrainingSubset(
-    arma::Row<ElementType>& r,
-    const size_t i)
+template<typename SubsetRowType>
+SubsetRowType KFoldCV<MLAlgorithm,
+                      Metric,
+                      MatType,
+                      PredictionsType,
+                      WeightsType>::GetTrainingSubset(
+    SubsetRowType& r,
+    const size_t i,
+    const typename std::enable_if_t<IsRow<SubsetRowType>::value>*)
 {
   // If this is not the first fold, we have to handle it a little bit
   // differently, since the last fold may contain slightly more than 'binSize'
@@ -414,7 +417,9 @@ arma::Row<ElementType> KFoldCV<MLAlgorithm,
   const size_t subsetSize = (i != 0) ? lastBinSize + (k - 2) * binSize :
       (k - 1) * binSize;
 
-  return arma::Row<ElementType>(r.colptr(binSize * i), subsetSize, false, true);
+  SubsetRowType alias;
+  MakeAlias(alias, r, subsetSize, r.n_rows * binSize * i);
+  return alias;
 }
 
 template<typename MLAlgorithm,
@@ -422,18 +427,21 @@ template<typename MLAlgorithm,
          typename MatType,
          typename PredictionsType,
          typename WeightsType>
-template<typename ElementType>
-arma::Mat<ElementType> KFoldCV<MLAlgorithm,
-                               Metric,
-                               MatType,
-                               PredictionsType,
-                               WeightsType>::GetValidationSubset(
-    arma::Mat<ElementType>& m,
-    const size_t i)
+template<typename SubsetMatType>
+SubsetMatType KFoldCV<MLAlgorithm,
+                      Metric,
+                      MatType,
+                      PredictionsType,
+                      WeightsType>::GetValidationSubset(
+    SubsetMatType& m,
+    const size_t i,
+    const typename std::enable_if_t<IsMatrix<SubsetMatType>::value>*)
 {
   const size_t subsetSize = (i == 0) ? lastBinSize : binSize;
-  return arma::Mat<ElementType>(m.colptr(ValidationSubsetFirstCol(i)), m.n_rows,
-      subsetSize, false, true);
+  SubsetMatType alias;
+  MakeAlias(alias, m, m.n_rows, subsetSize,
+      m.n_rows * ValidationSubsetFirstCol(i));
+  return alias;
 }
 
 template<typename MLAlgorithm,
@@ -441,18 +449,20 @@ template<typename MLAlgorithm,
          typename MatType,
          typename PredictionsType,
          typename WeightsType>
-template<typename ElementType>
-arma::Row<ElementType> KFoldCV<MLAlgorithm,
-                               Metric,
-                               MatType,
-                               PredictionsType,
-                               WeightsType>::GetValidationSubset(
-    arma::Row<ElementType>& r,
-    const size_t i)
+template<typename SubsetRowType>
+SubsetRowType KFoldCV<MLAlgorithm,
+                      Metric,
+                      MatType,
+                      PredictionsType,
+                      WeightsType>::GetValidationSubset(
+    SubsetRowType& r,
+    const size_t i,
+    const typename std::enable_if_t<IsRow<SubsetRowType>::value>*)
 {
   const size_t subsetSize = (i == 0) ? lastBinSize : binSize;
-  return arma::Row<ElementType>(r.colptr(ValidationSubsetFirstCol(i)),
-      subsetSize, false, true);
+  SubsetRowType alias;
+  MakeAlias(alias, r, subsetSize, r.n_rows * ValidationSubsetFirstCol(i));
+  return alias;
 }
 
 } // namespace mlpack