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

mlpack/include/mlpack/core/data/imputation_methods/median_imputation.hpp

@@ -15,13 +15,11 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
+
 /**
- * This is a class implementation of simple median imputation.
- * replace missing value with middle or average of middle values
- * @tparam T Type of armadillo matrix
+ * This is a class implementation of simple median imputation: replace missing
+ * value with the median of non-missing values.
  */
-template <typename T>
 class MedianImputation
 {
  public:
@@ -35,59 +33,62 @@ class MedianImputation
    * @param dimension Index of the dimension of the mappedValue.
    * @param columnMajor State of whether the input matrix is columnMajor or not.
    */
-  void Impute(arma::Mat<T>& input,
-              const T& mappedValue,
-              const size_t dimension,
-              const bool columnMajor = true)
+  template<typename MatType>
+  static void Impute(MatType& input,
+                     const typename MatType::elem_type& missingValue,
+                     const size_t dimension,
+                     const bool columnMajor = true)
   {
-    using PairType = std::pair<size_t, size_t>;
-    // dimensions and indexes are saved as pairs inside this vector.
-    std::vector<PairType> targets;
-    // good elements are kept inside this vector.
-    std::vector<double> elemsToKeep;
+    static_assert(!IsSparse<MatType>::value, "MedianImputation::Impute(): "
+        "sparse matrix imputation is not supported; use a dense matrix "
+        "instead!");
 
-    if (columnMajor)
+    typedef typename MatType::elem_type ElemType;
+
+    // If mappedValue is NaN, Armadillo does not quite provide the tools we need
+    // so we have to do our own implementation.  Otherwise, we can directly use
+    // Armadillo pretty easily.
+    ElemType medianValue;
+    MatType tmp;
+    if (std::isnan(missingValue))
     {
-      for (size_t i = 0; i < input.n_cols; ++i)
-      {
-        if (input(dimension, i) == mappedValue ||
-            std::isnan(input(dimension, i)))
-        {
-          targets.emplace_back(dimension, i);
-        }
-        else
-        {
-          elemsToKeep.push_back(input(dimension, i));
-        }
-      }
+      if (columnMajor)
+        tmp = input.row(dimension);
+      else
+        tmp = input.col(dimension).t();
+
+      tmp.shed_cols(find_nan(tmp));
     }
     else
     {
-      for (size_t i = 0; i < input.n_rows; ++i)
+      typedef typename GetUColType<MatType>::type UCol;
+      if (columnMajor)
       {
-        if (input(i, dimension) == mappedValue ||
-            std::isnan(input(i, dimension)))
-        {
-          targets.emplace_back(i, dimension);
-        }
-        else
-        {
-           elemsToKeep.push_back(input(i, dimension));
-        }
+        tmp = input.submat(UCol({ dimension }),
+            find(input.row(dimension) != missingValue));
+      }
+      else
+      {
+        tmp = input.submat(
+            find(input.col(dimension) != missingValue), UCol({ dimension }));
       }
     }
 
-    // calculate median
-    const double median = arma::median(arma::vec(elemsToKeep));
-
-    for (const PairType& target : targets)
+    // Compute the median on the extracted elements.
+    if (tmp.is_empty())
     {
-       input(target.first, target.second) = median;
+      throw std::invalid_argument("MedianImputation::Impute(): no non-missing "
+          "elements; cannot compute median!");
     }
+    medianValue = median(vectorise(tmp));
+
+    if (columnMajor)
+      input.row(dimension).replace(missingValue, medianValue);
+    else
+      input.col(dimension).replace(missingValue, medianValue);
   }
 }; // class MedianImputation
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -14,81 +14,73 @@
 #define MLPACK_CORE_DATA_IMPUTER_HPP
 
 #include <mlpack/prereqs.hpp>
-#include "dataset_mapper.hpp"
-#include "map_policies/missing_policy.hpp"
-#include "map_policies/increment_policy.hpp"
 
 namespace mlpack {
-namespace data {
 
 /**
  * Given a dataset of a particular datatype, replace user-specified missing
- * value with a variable dependent on the StrategyType and MapperType.
+ * value with a variable dependent on the StrategyType.
  *
- * @tparam T Type of armadillo matrix used for imputation strategy.
- * @tparam MapperType DatasetMapper that is used to hold dataset information.
  * @tparam StrategyType Imputation strategy used.
  */
-template<typename T, typename MapperType, typename StrategyType>
+template<typename StrategyType = MeanImputation>
 class Imputer
 {
  public:
-  Imputer(MapperType mapper, bool columnMajor = true):
-      mapper(std::move(mapper)),
-      columnMajor(columnMajor)
+  // Create an imputer, optionally specifying an instantiated imputation
+  // strategy.
+  Imputer(StrategyType strategy = StrategyType()) :
+      strategy(std::move(strategy))
   {
-    // Nothing to initialize here.
-  }
-
-  Imputer(MapperType mapper, StrategyType strategy, bool columnMajor = true):
-      strategy(std::move(strategy)),
-      mapper(std::move(mapper)),
-      columnMajor(columnMajor)
-  {
-    // Nothing to initialize here.
+    // Nothing to do.
   }
 
   /**
-  * Given an input dataset, replace missing values of a dimension with given
-  * imputation strategy. This function does not produce output matrix, but
-  * overwrites the result into the input matrix.
-  *
-  * @param input Input dataset to apply imputation.
-  * @param missingValue User defined missing value; it can be anything.
-  * @param dimension Dimension to apply the imputation.
-  */
-  void Impute(arma::Mat<T>& input,
-              const std::string& missingValue,
-              const size_t dimension)
+   * Given an input dataset, replace missing values of a dimension with given
+   * imputation strategy. This function does not produce an output matrix, but
+   * overwrites the result into the input matrix.
+   *
+   * @param input Input dataset to apply imputation.
+   * @param missingValue User defined missing value; it can be anything.
+   * @param dimension Dimension to apply the imputation.
+   */
+  template<typename MatType>
+  void Impute(MatType& input,
+              const typename MatType::elem_type& missingValue,
+              const size_t dimension,
+              const bool columnMajor = true,
+              const std::enable_if_t<IsArma<MatType>::value>* = 0)
   {
-    T mappedValue = static_cast<T>(mapper.UnmapValue(missingValue, dimension));
-    strategy.Impute(input, mappedValue, dimension, columnMajor);
+    if (columnMajor && (dimension >= input.n_rows))
+    {
+      std::ostringstream oss;
+      oss << "Imputer::Impute(): given dimension to impute (" << dimension
+          << ") must be less than the number of rows in the matrix ("
+          << input.n_rows << ")!" << std::endl;
+      throw std::invalid_argument(oss.str());
+    }
+    else if (!columnMajor && (dimension >= input.n_cols))
+    {
+      std::ostringstream oss;
+      oss << "Imputer::Impute(): given dimension to impute (" << dimension
+          << ") must be less than the number of columns in the matrix ("
+          << input.n_cols << ")!" << std::endl;
+      throw std::invalid_argument(oss.str());
+    }
+
+    strategy.Impute(input, missingValue, dimension, columnMajor);
   }
 
-  //! Get the strategy.
+  // Get the strategy.
   const StrategyType& Strategy() const { return strategy; }
-
-  //! Modify the given strategy.
+  // Modify the given strategy.
   StrategyType& Strategy() { return strategy; }
 
-  //! Get the mapper.
-  const MapperType& Mapper() const { return mapper; }
-
-  //! Modify the given mapper.
-  MapperType& Mapper() { return mapper; }
-
  private:
   // StrategyType
   StrategyType strategy;
-
-  // DatasetMapperType<MapPolicy>
-  MapperType mapper;
-
-  // save columnMajor as a member variable since it is rarely changed.
-  bool columnMajor;
 }; // class Imputer
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -17,7 +17,6 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
 
 /**
  * See if the token is a NaN or an Inf, and if so, set the value accordingly and
@@ -66,7 +65,6 @@ inline bool IsNaNInf(T& val, const std::string& token)
   return false;
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -3,9 +3,10 @@
  * @author Ryan Curtin
  * @author Omar Shrit
  *
- * Load an Armadillo matrix from file.  This is necessary because Armadillo does
- * not transpose matrices on input, and it allows us to give better error
- * output.
+ * mlpack Load function interface from a file.
+ *
+ * This Load interface allows to load numeric / image / models from disk into
+ * an Armadillo matrix or mlpack object.
  *
  * 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
@@ -17,19 +18,16 @@
 
 #include <mlpack/prereqs.hpp>
 
+#include "image_options.hpp"
 #include "text_options.hpp"
-#include "format.hpp"
-#include "dataset_mapper.hpp"
 #include "detect_file_type.hpp"
-#include "image_info.hpp"
+#include "load_deprecated.hpp"
 #include "load_arff.hpp"
 #include "load_numeric.hpp"
-#include "load_categorical.hpp"
 #include "load_image.hpp"
-#include "utilities.hpp"
+#include "load_model.hpp"
 
 namespace mlpack {
-namespace data /** Functions to load and save matrices and models. */ {
 
 /**
  * Loads a matrix from file, guessing the filetype from the extension.  This
@@ -44,9 +42,9 @@ template<typename MatType, typename DataOptionsType>
 bool Load(const std::string& filename,
           MatType& matrix,
           DataOptionsType& opts,
-          std::enable_if_t<IsArma<MatType>::value ||
-              IsSparseMat<MatType>::value>* = 0,
-          std::enable_if_t<!std::is_same_v<DataOptionsType, bool>>* = 0);
+          const bool copyBack = true,
+          const typename std::enable_if_t<
+              IsDataOptions<DataOptionsType>::value>* = 0);
 
 /**
  * Loads a matrix from file, guessing the filetype from the extension.  This
@@ -57,247 +55,65 @@ bool Load(const std::string& filename,
  * @param opts Non-modifiable DataOptions to be passed to the function
  * @return Boolean value indicating success or failure of load.
  */
-template<typename MatType, typename DataOptionsType>
+template<typename MatType, typename DataOptionsType = PlainDataOptions>
 bool Load(const std::string& filename,
           MatType& matrix,
-          const DataOptionsType& opts,
-          std::enable_if_t<IsArma<MatType>::value ||
-              IsSparseMat<MatType>::value>* = 0,
-          std::enable_if_t<!std::is_same_v<DataOptionsType, bool>>* = 0);
-
+          const DataOptionsType& opts = DataOptionsType(),
+          const typename std::enable_if_t<
+              IsDataOptions<DataOptionsType>::value>* = 0);
 /**
- * Loads a matrix from file, guessing the filetype from the extension.  This
- * will transpose the matrix at load time (unless the transpose parameter is set
- * to false).
- *
- * The supported types of files are the same as found in Armadillo:
- *
- *  - CSV (arma::csv_ascii), denoted by .csv, or optionally .txt
- *  - TSV (arma::raw_ascii), denoted by .tsv, .csv, or .txt
- *  - ASCII (arma::raw_ascii), denoted by .txt
- *  - Armadillo ASCII (arma::arma_ascii), also denoted by .txt
- *  - PGM (arma::pgm_binary), denoted by .pgm
- *  - PPM (arma::ppm_binary), denoted by .ppm
- *  - Raw binary (arma::raw_binary), denoted by .bin
- *  - Armadillo binary (arma::arma_binary), denoted by .bin
- *  - HDF5 (arma::hdf5_binary), denoted by .hdf, .hdf5, .h5, or .he5
- *
- * By default, this function will try to automatically determine the type of
- * file to load based on its extension and by inspecting the file.  If you know
- * the file type and want to specify it manually, override the default
- * `inputLoadType` parameter with the correct type above (e.g.
- * `arma::csv_ascii`.)
+ * This function loads a set of several dataset files into one matrix.
+ * This is usually the case if the dataset is collected on several occasions
+ * and not agglomerated into one file, or if the dataset has been partitioned
+ * into multiple files.
  *
- * If the detected file type is CSV (`arma::csv_ascii`), the first row will be
- * checked for a CSV header.  If a CSV header is not detected, the first row
- * will be treated as data; otherwise, the first row will be skipped.
+ * Note, the load will fail if the number of dimension (data points) in all
+ * files is not equal, or if the dataset does not have the same filetype. For
+ * example, the load will fail one file is CSV and the other is binary.
  *
- * If the parameter 'fatal' is set to true, a std::runtime_error exception will
- * be thrown if the matrix does not load successfully.  The parameter
- * 'transpose' controls whether or not the matrix is transposed after loading.
- * In most cases, because data is generally stored in a row-major format and
- * mlpack requires column-major matrices, this should be left at its default
- * value of 'true'.
+ * The user needs to specify all the filenames in one std::vector before using
+ * this function.
  *
- * @param filename Name of file to load.
- * @param matrix Matrix to load contents of file into.
- * @param fatal If an error should be reported as fatal (default false).
- * @param transpose If true, transpose the matrix after loading (default true).
- * @param inputLoadType Used to determine the type of file to load (default arma::auto_detect).
+ * @param filenames Names of files to load.
+ * @param matrix Matrix to load contents of files into.
+ * @param opts DataOptions to be passed to the function
  * @return Boolean value indicating success or failure of load.
  */
-template<typename eT>
-bool Load(const std::string& filename,
+template<typename eT, typename DataOptionsType>
+bool Load(const std::vector<std::string>& files,
           arma::Mat<eT>& matrix,
-          const bool fatal = false,
-          const bool transpose = true,
-          const FileType inputLoadType = FileType::AutoDetect);
-
-/**
- * Loads a sparse matrix from file, using arma::coord_ascii format.  This
- * will transpose the matrix at load time (unless the transpose parameter is set
- * to false).  If the filetype cannot be determined, an error will be given.
- *
- * The supported types of files are the same as found in Armadillo:
- *
- *  - CSV (coord_ascii), denoted by .csv or .txt
- *  - TSV (coord_ascii), denoted by .tsv or .txt
- *  - TXT (coord_ascii), denoted by .txt
- *  - Raw binary (raw_binary), denoted by .bin
- *  - Armadillo binary (arma_binary), denoted by .bin
- *
- * If the file extension is not one of those types, an error will be given.
- * This is preferable to Armadillo's default behavior of loading an unknown
- * filetype as raw_binary, which can have very confusing effects.
- *
- * If the parameter 'fatal' is set to true, a std::runtime_error exception will
- * be thrown if the matrix does not load successfully.  The parameter
- * 'transpose' controls whether or not the matrix is transposed after loading.
- * In most cases, because data is generally stored in a row-major format and
- * mlpack requires column-major matrices, this should be left at its default
- * value of 'true'.
- *
- * @param filename Name of file to load.
- * @param matrix Sparse matrix to load contents of file into.
- * @param fatal If an error should be reported as fatal (default false).
- * @param transpose If true, transpose the matrix after loading (default true).
- * @return Boolean value indicating success or failure of load.
- */
-template<typename eT>
-bool Load(const std::string& filename,
-          arma::SpMat<eT>& matrix,
-          const bool fatal = false,
-          const bool transpose = true,
-          const FileType inputLoadType = FileType::AutoDetect);
-
-/**
- * Load a column vector from a file, guessing the filetype from the extension.
- *
- * The supported types of files are the same as found in Armadillo:
- *
- *  - CSV (csv_ascii), denoted by .csv, or optionally .txt
- *  - TSV (raw_ascii), denoted by .tsv, .csv, or .txt
- *  - ASCII (raw_ascii), denoted by .txt
- *  - Armadillo ASCII (arma_ascii), also denoted by .txt
- *  - PGM (pgm_binary), denoted by .pgm
- *  - PPM (ppm_binary), denoted by .ppm
- *  - Raw binary (raw_binary), denoted by .bin
- *  - Armadillo binary (arma_binary), denoted by .bin
- *  - HDF5, denoted by .hdf, .hdf5, .h5, or .he5
- *
- * If the file extension is not one of those types, an error will be given.
- * This is preferable to Armadillo's default behavior of loading an unknown
- * filetype as raw_binary, which can have very confusing effects.
- *
- * If the parameter 'fatal' is set to true, a std::runtime_error exception will
- * be thrown if the matrix does not load successfully.
- *
- * @param filename Name of file to load.
- * @param vec Column vector to load contents of file into.
- * @param fatal If an error should be reported as fatal (default false).
- * @return Boolean value indicating success or failure of load.
- */
-template<typename eT>
-bool Load(const std::string& filename,
-          arma::Col<eT>& vec,
-          const bool fatal = false);
-
-/**
- * Load a row vector from a file, guessing the filetype from the extension.
- *
- * The supported types of files are the same as found in Armadillo:
- *
- *  - CSV (csv_ascii), denoted by .csv, or optionally .txt
- *  - TSV (raw_ascii), denoted by .tsv, .csv, or .txt
- *  - ASCII (raw_ascii), denoted by .txt
- *  - Armadillo ASCII (arma_ascii), also denoted by .txt
- *  - PGM (pgm_binary), denoted by .pgm
- *  - PPM (ppm_binary), denoted by .ppm
- *  - Raw binary (raw_binary), denoted by .bin
- *  - Armadillo binary (arma_binary), denoted by .bin
- *  - HDF5, denoted by .hdf, .hdf5, .h5, or .he5
- *
- * If the file extension is not one of those types, an error will be given.
- * This is preferable to Armadillo's default behavior of loading an unknown
- * filetype as raw_binary, which can have very confusing effects.
- *
- * If the parameter 'fatal' is set to true, a std::runtime_error exception will
- * be thrown if the matrix does not load successfully.
- *
- * @param filename Name of file to load.
- * @param rowvec Row vector to load contents of file into.
- * @param fatal If an error should be reported as fatal (default false).
- * @return Boolean value indicating success or failure of load.
- */
-template<typename eT>
-bool Load(const std::string& filename,
-          arma::Row<eT>& rowvec,
-          const bool fatal = false);
-
+          const DataOptionsType& opts,
+          const typename std::enable_if_t<
+              IsDataOptions<DataOptionsType>::value>* = 0);
 /**
- * Loads a matrix from a file, guessing the filetype from the extension and
- * mapping categorical features with a DatasetMapper object.  This will
- * transpose the matrix (unless the transpose parameter is set to false).
- * This particular overload of Load() can only load text-based formats, such as
- * those given below:
- *
- * - CSV (csv_ascii), denoted by .csv, or optionally .txt
- * - TSV (raw_ascii), denoted by .tsv, .csv, or .txt
- * - ASCII (raw_ascii), denoted by .txt
+ * This function loads a set of several dataset files into one matrix.
+ * This is usually the case if the dataset is collected on several occasions
+ * and not agglomerated into one file, or if the dataset has been partitioned
+ * into multiple files.
  *
- * If the file extension is not one of those types, an error will be given.
- * This is preferable to Armadillo's default behavior of loading an unknown
- * filetype as raw_binary, which can have very confusing effects.
+ * Note, the load will fail if the number of dimension (data points) in all
+ * files is not equal, or if the dataset does not have the same filetype. For
+ * example, the load will fail one file is CSV and the other is binary.
  *
- * If the parameter 'fatal' is set to true, a std::runtime_error exception will
- * be thrown if the matrix does not load successfully.  The parameter
- * 'transpose' controls whether or not the matrix is transposed after loading.
- * In most cases, because data is generally stored in a row-major format and
- * mlpack requires column-major matrices, this should be left at its default
- * value of 'true'.
+ * The user needs to specify all the filenames in one std::vector before using
+ * this function.
  *
- * If the given `info` has already been used with a different `data::Load()`
- * call where the dataset has the same dimensionality, then the mappings and
- * dimension types inside of `info` will be *re-used*.  If the given `info` is a
- * new `DatasetMapper` object (e.g. its dimensionality is 0), then new mappings
- * will be created.  If the given `info` has a different dimensionality of data
- * than what is present in `filename`, an exception will be thrown.
- *
- * @param filename Name of file to load.
- * @param matrix Matrix to load contents of file into.
- * @param info DatasetMapper object to populate with mappings and data types.
- * @param fatal If an error should be reported as fatal (default false).
- * @param transpose If true, transpose the matrix after loading.
+ * @param filenames Names of files to load.
+ * @param matrix Matrix to load contents of files into.
+ * @param opts DataOptions to be passed to the function
  * @return Boolean value indicating success or failure of load.
  */
-template<typename eT, typename PolicyType>
-bool Load(const std::string& filename,
+template<typename eT, typename DataOptionsType>
+bool Load(const std::vector<std::string>& files,
           arma::Mat<eT>& matrix,
-          DatasetMapper<PolicyType>& info,
-          const bool fatal = false,
-          const bool transpose = true);
-
-/**
- * Load a model from a file, guessing the filetype from the extension, or,
- * optionally, loading the specified format.  If automatic extension detection
- * is used and the filetype cannot be determined, an error will be given.
- *
- * The supported types of files are the same as what is supported by the
- * cereal library:
- *
- *  - json, denoted by .json
- *  - xml, denoted by .xml
- *  - binary, denoted by .bin
- *
- * The format parameter can take any of the values in the 'format' enum:
- * 'format::autodetect', 'format::json', 'format::xml', and 'format::binary'.
- * The autodetect functionality operates on the file extension (so, "file.txt"
- * would be autodetected as text).
- *
- * The name parameter should be specified to indicate the name of the structure
- * to be loaded.  This should be the same as the name that was used to save the
- * structure (otherwise, the loading procedure will fail).
- *
- * If the parameter 'fatal' is set to true, then an exception will be thrown in
- * the event of load failure.  Otherwise, the method will return false and the
- * relevant error information will be printed to Log::Warn.
- */
-template<typename T>
-bool Load(const std::string& filename,
-          const std::string& name,
-          T& t,
-          const bool fatal = false,
-          format f = format::autodetect,
-          std::enable_if_t<HasSerialize<T>::value>* = 0);
+          DataOptionsType& opts,
+          const bool copyBack = true,
+          const typename std::enable_if_t<
+              IsDataOptions<DataOptionsType>::value>* = 0);
 
-} // namespace data
 } // namespace mlpack
 
 // Include implementation of Load() for matrix.
 #include "load_impl.hpp"
-// Include implementation of model-loading Load() overload.
-#include "load_model_impl.hpp"
-// Include implementation of Load() for vectors.
-#include "load_vec_impl.hpp"
 
 #endif

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

@@ -17,7 +17,6 @@
 #include "string_algorithms.hpp"
 
 namespace mlpack {
-namespace data {
 
 /**
  * A utility function to load an ARFF dataset as numeric features (that is, as
@@ -55,7 +54,6 @@ bool LoadARFF(const std::string& filename,
               DatasetMapper<PolicyType>& info,
               bool fatal);
 
-} // namespace data
 } // namespace mlpack
 
 // Include implementation.

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

@@ -18,7 +18,6 @@
 #include "is_naninf.hpp"
 
 namespace mlpack {
-namespace data {
 
 template<typename eT, typename PolicyType>
 bool LoadARFF(const std::string& filename,
@@ -158,11 +157,11 @@ bool LoadARFF(const std::string& filename,
   else if (info.Dimensionality() != dimensionality)
   {
     if (fatal)
-      Log::Fatal << "data::LoadARFF(): given DatasetInfo has dimensionality "
+      Log::Fatal << "LoadARFF(): given DatasetInfo has dimensionality "
           << info.Dimensionality() << ", but data has dimensionality "
           << dimensionality << std::endl;
     else
-      Log::Warn << "data::LoadARFF(): given DatasetInfo has dimensionality "
+      Log::Warn << "LoadARFF(): given DatasetInfo has dimensionality "
           << info.Dimensionality() << ", but data has dimensionality "
           << dimensionality << std::endl;
     return false;
@@ -336,7 +335,6 @@ bool LoadARFF(const std::string& filename,
   return true;
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif