mlpack 4.6.0__cp311-cp311-win_amd64.whl → 4.6.2__cp311-cp311-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_0():
+def _delvewheel_patch_1_10_1():
     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_0()
-del _delvewheel_patch_1_10_0
+_delvewheel_patch_1_10_1()
+del _delvewheel_patch_1_10_1
 # 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.0'
+__version__='4.6.2'

mlpack/include/mlpack/base.hpp

@@ -33,6 +33,7 @@
 #include <numeric>
 #include <vector>
 #include <queue>
+#include <string>
 
 // But if it's not defined, we'll do it.
 #ifndef M_PI

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 {
 
@@ -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

@@ -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

mlpack/include/mlpack/core/data/data.hpp

@@ -12,7 +12,6 @@
 #ifndef MLPACK_CORE_DATA_DATA_HPP
 #define MLPACK_CORE_DATA_DATA_HPP
 
-#include "detect_file_type.hpp"
 #include "extension.hpp"
 #include "format.hpp"
 #include "has_serialize.hpp"
@@ -30,14 +29,19 @@
 #include "check_categorical_param.hpp"
 #include "confusion_matrix.hpp"
 #include "dataset_mapper.hpp"
+#include "data_options.hpp"
+#include "detect_file_type.hpp"
 #include "image_info.hpp"
 #include "image_resize_crop.hpp"
 #include "imputer.hpp"
 #include "is_naninf.hpp"
+#include "matrix_options.hpp"
 #include "normalize_labels.hpp"
 #include "one_hot_encoding.hpp"
 #include "split_data.hpp"
 #include "string_algorithms.hpp"
+#include "text_options.hpp"
 #include "types.hpp"
+#include "utilities.hpp"
 
 #endif

mlpack/include/mlpack/core/data/data_options.hpp

@@ -0,0 +1,219 @@
+/**
+ * @file core/data/data_options.hpp
+ * @author Ryan Curtin
+ * @author Omar Shrit
+ *
+ * Data options, all possible options to load different data types and format
+ * with specific settings into mlpack.
+ *
+ * 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_DATA_DATA_OPTIONS_HPP
+#define MLPACK_CORE_DATA_DATA_OPTIONS_HPP
+
+#include <mlpack/prereqs.hpp>
+
+#include "types.hpp"
+#include "dataset_mapper.hpp"
+#include "map_policies/map_policies.hpp"
+#include "format.hpp"
+#include "image_info.hpp"
+
+namespace mlpack {
+namespace data {
+
+/**
+ * All possible DataOptions grouped under one class.
+ * This will allow us to have consistent data API for mlpack. If new data
+ * options might be necessary, then they should be added in the following.
+ */
+
+template<typename Derived>
+class DataOptionsBase
+{
+ public:
+  DataOptionsBase(const bool fatal = defaultFatal,
+                  const FileType format = defaultFormat) :
+      fatal(fatal),
+      format(format)
+  {
+    // Do nothing.
+  }
+
+  template<typename Derived2>
+  explicit DataOptionsBase(const DataOptionsBase<Derived2>& opts)
+  {
+    CopyOptions(opts);
+  }
+
+  template<typename Derived2>
+  explicit DataOptionsBase(DataOptionsBase<Derived2>&& opts)
+  {
+    MoveOptions(std::move(opts));
+  }
+
+  // Convert any other DataOptions type to this DataOptions type, printing
+  // warnings for any members that cannot be converted.  If this object and
+  // `opts` are of the same type, then the constructor for that type will be
+  // called instead.
+  template<typename Derived2>
+  DataOptionsBase& operator=(const DataOptionsBase<Derived2>& other)
+  {
+    if ((void*) &other == (void*) this)
+      return *this;
+
+    // Print warnings for any members that cannot be converted.
+    const char* dataDesc = static_cast<const Derived&>(*this).DataDescription();
+    static_cast<const Derived2&>(other).WarnBaseConversion(dataDesc);
+
+    CopyOptions(other);
+    return *this;
+  }
+
+  // Take ownership of the options of another `DataOptionsBase` type.
+  template<typename Derived2>
+  DataOptionsBase& operator=(DataOptionsBase<Derived2>&& other)
+  {
+    if ((void*) &other != (void*) this)
+      return *this;
+
+    // Print warnings for any members that cannot be converted.
+    const char* dataDesc = static_cast<const Derived&>(*this).DataDescription();
+    static_cast<const Derived2&>(other).WarnBaseConversion(dataDesc);
+
+    MoveOptions(std::move(other));
+    return *this;
+  }
+
+  template<typename Derived2>
+  void CopyOptions(const DataOptionsBase<Derived2>& other)
+  {
+    // Only copy options that have been set in the other object.
+    if (other.fatal.has_value())
+      fatal = *other.fatal;
+    if (other.format.has_value())
+      format = *other.format;
+  }
+
+  template<typename Derived2>
+  void MoveOptions(DataOptionsBase<Derived2>&& other)
+  {
+    fatal = std::move(other.fatal);
+    format = std::move(other.format);
+
+    // Reset all of the options in the other object.
+    other.Reset();
+  }
+
+  void Reset()
+  {
+    fatal.reset();
+    format.reset();
+
+    // Reset any child members.
+    static_cast<Derived&>(*this).Reset();
+  }
+
+  // If true, then exceptions are thrown on failures.
+  const bool& Fatal() const { return AccessMember(fatal, defaultFatal); }
+  // Modify whether or not exceptions are thrown on failures.
+  bool& Fatal() { return ModifyMember(fatal, defaultFatal); }
+
+  // Get the type of the file that will be loaded.
+  const FileType& Format() const { return AccessMember(format, defaultFormat); }
+  // Modify the file format to load.
+  FileType& Format() { return ModifyMember(format, defaultFormat); }
+
+  /**
+   * Given a file type, return a logical name corresponding to that file type.
+   */
+  const std::string FileTypeToString() const
+  {
+    FileType f = format.has_value() ? *format : defaultFormat;
+    switch (f)
+    {
+      case FileType::CSVASCII:    return "CSV data";
+      case FileType::RawASCII:    return "raw ASCII formatted data";
+      case FileType::RawBinary:   return "raw binary formatted data";
+      case FileType::ArmaASCII:   return "Armadillo ASCII formatted data";
+      case FileType::ArmaBinary:  return "Armadillo binary formatted data";
+      case FileType::PGMBinary:   return "PGM data";
+      case FileType::PPMBinary:   return "PGM data";
+      case FileType::HDF5Binary:  return "HDF5 data";
+      case FileType::CoordASCII:
+          return "ASCII formatted sparse coordinate data";
+      case FileType::AutoDetect:  return "Detect automatically data type";
+      case FileType::FileTypeUnknown: return "Unknown data type";
+      default:                    return "";
+    }
+  }
+
+ protected:
+  template<typename T>
+  const T& AccessMember(const std::optional<T>& value,
+                        const T& defaultValue) const
+  {
+    if (value.has_value())
+      return *value;
+    else
+      return defaultValue;
+  }
+
+  template<typename T>
+  T& ModifyMember(std::optional<T>& value, const T defaultValue)
+  {
+    // Set the default value if needed so that (*value) has defined behavior
+    // according to the spec.
+    if (!value.has_value())
+      value = defaultValue;
+
+    return *value;
+  }
+
+  void WarnOptionConversion(const char* optionName, const char* dataType) const
+  {
+    if (fatal.has_value() && *fatal)
+    {
+      Log::Fatal << "Option '" << optionName << "' cannot be specified when "
+          << dataType << " is being loaded!" << std::endl;
+    }
+    else
+    {
+      Log::Warn << "Option '" << optionName << "' ignored; not applicable when "
+          << dataType << " is being loaded!" << std::endl;
+    }
+  }
+
+ private:
+  std::optional<bool> fatal;
+  std::optional<FileType> format;
+
+  constexpr static const bool defaultFatal = false;
+  constexpr static const FileType defaultFormat = FileType::AutoDetect;
+
+  // For access to internal optional members.
+  template<typename Derived2>
+  friend class DataOptionsBase;
+};
+
+// This utility class is meant to be used as the Derived parameter for an option
+// that is not actually a derived type.  It provides the WarnBaseConversion()
+// member, which does nothing.
+class EmptyOptions : public DataOptionsBase<EmptyOptions>
+{
+ public:
+  void WarnBaseConversion(const char* /* dataDescription */) const { }
+  static const char* DataDescription() { return "general data"; }
+  void Reset() { }
+};
+
+using DataOptions = DataOptionsBase<EmptyOptions>;
+
+
+} // namespace data
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/core/data/detect_file_type.hpp

@@ -16,17 +16,13 @@
 #define MLPACK_CORE_DATA_DETECT_FILE_TYPE_HPP
 
 #include "types.hpp"
+#include "extension.hpp"
+#include "string_algorithms.hpp"
+#include "text_options.hpp"
 
 namespace mlpack {
 namespace data {
 
-/**
- * Given a file type, return a logical name corresponding to that file type.
- *
- * @param type Type to get the logical name of.
- */
-inline std::string GetStringType(const FileType& type);
-
 /**
  * Given an istream, attempt to guess the file type.  This is taken originally
  * from Armadillo's function guess_file_type_internal(), but we avoid using
@@ -62,7 +58,9 @@ inline FileType AutoDetect(std::fstream& stream,
  * @param filename Name of the file whose type we should detect.
  * @return Detected type of file.  arma::file_type_unknown if unknown.
  */
-inline FileType DetectFromExtension(const std::string& filename);
+template<typename MatType, typename DataOptionsType>
+void DetectFromExtension(const std::string& filename,
+                         DataOptionsType& opts);
 
 /**
  * Count the number of columns in the file.  The file must be a CSV/TSV/TXT file