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

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

@@ -1,5 +1,5 @@
 /**
- * @file core/data/load.hpp
+ * @file core/data/load_numeric.hpp
  * @author Omar Shrit
  *
  * Load numeric csv using Armadillo parser. Distinguish between the cases, if
@@ -13,118 +13,155 @@
 #ifndef MLPACK_CORE_DATA_LOAD_NUMERIC_HPP
 #define MLPACK_CORE_DATA_LOAD_NUMERIC_HPP
 
-namespace mlpack {
-namespace data {
-
-// These help assemble the Armadillo csv_opts flags.
-inline const arma::csv_opts::opts& NoTransposeOpt(const bool noTranspose)
-{
-  if (noTranspose)
-    return arma::csv_opts::none;
-  else
-    return arma::csv_opts::trans;
-}
+#include "text_options.hpp"
+#include "load_categorical.hpp"
+#include "load_dense.hpp"
+#include "load_sparse.hpp"
 
-inline const arma::csv_opts::opts& HasHeadersOpt(const bool hasHeaders)
-{
-  if (hasHeaders)
-    return arma::csv_opts::with_header;
-  else
-    return arma::csv_opts::no_header;
-}
+namespace mlpack {
 
-inline const arma::csv_opts::opts& SemicolonOpt(const bool semicolon)
+template<typename MatType>
+bool LoadNumeric(const std::string& filename,
+                 MatType& matrix,
+                 std::fstream& stream,
+                 TextOptions& opts)
 {
-  if (semicolon)
-    return arma::csv_opts::semicolon;
-  else
-    return arma::csv_opts::none;
-}
+  bool success = false;
 
-inline const arma::csv_opts::opts& MissingToNanOpt(const bool missingToNan)
-{
-  if (missingToNan)
+  TextOptions txtOpts(std::move(opts));
+  if constexpr (IsSparseMat<MatType>::value)
+  {
+    success = LoadSparse(filename, matrix, txtOpts, stream);
+  }
+  else if (txtOpts.Categorical() ||
+      (txtOpts.Format() == FileType::ARFFASCII))
+  {
+    success = LoadCategorical(filename, matrix, txtOpts);
+  }
+  else if constexpr (IsCol<MatType>::value)
   {
-    #if ARMA_VERSION_MAJOR >= 12
-    return arma::csv_opts::strict;
-    #else
-    return arma::csv_opts::none;
-    #endif
+    success = LoadDenseCol(filename, matrix, txtOpts, stream);
+  }
+  else if constexpr (IsRow<MatType>::value)
+  {
+    success = LoadDenseRow(filename, matrix, txtOpts, stream);
+  }
+  else if constexpr (IsDense<MatType>::value)
+  {
+    success = LoadDense(filename, matrix, txtOpts, stream);
   }
   else
   {
-    return arma::csv_opts::none;
+    return HandleError("Load(): unknown matrix-like type given!",
+        txtOpts);
   }
+  opts = std::move(txtOpts);
+  return success;
 }
 
 template<typename MatType>
-bool LoadCSVASCII(const std::string& filename,
-                  MatType& matrix,
-                  TextOptions& opts)
+bool LoadNumericMultifile(const std::vector<std::string>& filenames,
+          MatType& matrix,
+          const TextOptions& opts)
+{
+  TextOptions copyOpts(opts);
+  return Load(filenames, matrix, copyOpts);
+}
+
+template<typename MatType>
+bool LoadNumericMultifile(const std::vector<std::string>& filenames,
+          MatType& matrix,
+          TextOptions& opts)
 {
   bool success = false;
+  MatType tmp;
+  arma::field<std::string> firstHeaders;
+  if (filenames.empty())
+  {
+    return HandleError("Load(): given set of filenames is empty;"
+        " loading failed.", opts);
+  }
 
-  // Show a warning if strict is not available.
-  #if ARMA_VERSION_MAJOR < 12
-  if (opts.MissingToNan())
+  for (size_t i = 0; i < filenames.size(); ++i)
   {
-    if (opts.Fatal())
+    success = Load(filenames.at(i), matrix, opts);
+    if (opts.HasHeaders())
     {
-      Log::Fatal << "data::Load(): MissingToNan() requires Armadillo version "
-          << ">= 12.0!" << std::endl;
+      if (i == 0)
+        firstHeaders = opts.Headers();
+      else
+      {
+        arma::field<std::string>& headers = opts.Headers();
+
+        // Make sure that the headers in this file match the first file's
+        // headers.
+        for (size_t j = 0; j < headers.size(); ++j)
+        {
+          if (firstHeaders.at(j) != headers.at(j))
+          {
+            std::stringstream oss;
+            oss << "Load(): header column " << j << " in file '"
+                << filenames[j] << "' ('" << headers[j] << "') does not match"
+                << " header column " << j << " in first file '"
+                << filenames[0] << "' ('" << firstHeaders[j] << "'); load "
+                << "failed.";
+            matrix.clear();
+            return HandleError(oss, opts);
+          }
+        }
+      }
     }
-    else
+
+    if (success)
     {
-      Log::Warn << "data::Load(): MissingToNan() requires Armadillo version "
-          << ">= 12.0!  Option ignored." << std::endl;
+      if (i == 0)
+      {
+        tmp = std::move(matrix);
+      }
+      else
+      {
+        if (!opts.NoTranspose()) // if transpose
+        {
+          if (tmp.n_rows != matrix.n_rows)
+          {
+            std::stringstream oss;
+            oss << "Load(): dimension mismatch; file '" << filenames[i]
+                << "' has " << matrix.n_rows << " dimensions, but first file "
+                << "'" << filenames[0] << "' has " << tmp.n_rows
+                << " dimensions.";
+            return HandleError(oss, opts);
+          }
+          else
+            tmp = join_rows(tmp, matrix);
+        }
+        else
+        {
+          if (tmp.n_cols != matrix.n_cols)
+          {
+            std::stringstream oss;
+            oss <<  "Load(): dimension mismatch; file '" << filenames[i]
+                << "' has " << matrix.n_cols << " dimensions, but first file "
+                << "'" << filenames[0] << "' has " << tmp.n_cols
+                << " dimensions.";
+            return HandleError(oss, opts);
+          }
+          else
+          {
+            tmp = join_cols(tmp, matrix);
+          }
+        }
+      }
     }
+    else
+      break;
   }
-  #endif
 
-  // Build Armadillo flags for loading based on our settings.
-  arma::csv_opts::opts flags =
-      NoTransposeOpt(opts.NoTranspose()) +
-      HasHeadersOpt(opts.HasHeaders()) +
-      SemicolonOpt(opts.Semicolon()) +
-      MissingToNanOpt(opts.MissingToNan());
-
-  if (opts.HasHeaders())
-  {
-    success = matrix.load(arma::csv_name(filename, opts.Headers(), flags),
-        arma::csv_ascii);
-  }
-  else
-  {
-    success = matrix.load(arma::csv_name(filename, flags), arma::csv_ascii);
-  }
+  if (success)
+    matrix = std::move(tmp);
 
   return success;
 }
 
-template<typename eT, typename DataOptionsType>
-bool LoadHDF5(const std::string& filename,
-              arma::Mat<eT>& matrix,
-              const DataOptionsBase<DataOptionsType>& opts)
-{
-#ifndef ARMA_USE_HDF5
-  // Ensure that HDF5 is supported.
-  Timer::Stop("loading_data");
-  if (opts.Fatal())
-    Log::Fatal << "Attempted to load '" << filename << "' as HDF5 data, but "
-        << "Armadillo was compiled without HDF5 support.  Load failed."
-        << std::endl;
-  else
-    Log::Warn << "Attempted to load '" << filename << "' as HDF5 data, but "
-        << "Armadillo was compiled without HDF5 support.  Load failed."
-        << std::endl;
-
-  return false;
-#endif
-
-  return matrix.load(filename, ToArmaFileType(opts.Format()));
-}
-
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -0,0 +1,91 @@
+/**
+ * @file core/data/load_sparse.hpp
+ * @author Omar Shrit
+ *
+ * Implementation of templatized load() function defined in load.hpp.
+ *
+ * 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_LOAD_SPARSE_HPP
+#define MLPACK_CORE_DATA_LOAD_SPARSE_HPP
+
+#include <mlpack/prereqs.hpp>
+
+#include "text_options.hpp"
+
+namespace mlpack {
+
+template <typename eT>
+bool LoadSparse(const std::string& filename,
+                arma::SpMat<eT>& matrix,
+                TextOptions& opts,
+                std::fstream& stream)
+{
+  bool success;
+  // There is still a small amount of differentiation that needs to be done:
+  // if we got a text type, it could be a coordinate list.  We will make an
+  // educated guess based on the shape of the input.
+  if (opts.Format() == FileType::RawASCII)
+  {
+    // Get the number of columns in the file.  If it is the right shape, we
+    // will assume it is sparse.
+    const size_t cols = CountCols(stream);
+    if (cols == 3)
+    {
+      // We have the right number of columns, so assume the type is a
+      // coordinate list.
+      opts.Format() = FileType::CoordASCII;
+    }
+  }
+
+  // Filter out invalid types.
+  if ((opts.Format() == FileType::PGMBinary) ||
+      (opts.Format() == FileType::PPMBinary) ||
+      (opts.Format() == FileType::ArmaASCII) ||
+      (opts.Format() == FileType::RawBinary))
+  {
+    std::stringstream oss;
+    oss << "Cannot load '" << filename << "' with type "
+        << opts.FileTypeToString() << " into a sparse matrix; format is "
+        << "only supported for dense matrices.";
+    return HandleError(oss, opts);
+  }
+  else if (opts.Format() == FileType::CSVASCII)
+  {
+    // Armadillo sparse matrices can't load CSVs, so we have to load a separate
+    // matrix to do that.  If the CSV has three columns, we assume it's a
+    // coordinate list.
+    arma::Mat<eT> dense;
+    success = dense.load(stream, opts.ArmaFormat());
+    if (dense.n_cols == 3)
+    {
+      arma::umat locations = arma::conv_to<arma::umat>::from(
+          dense.cols(0, 1).t());
+      matrix = arma::SpMat<eT>(locations, dense.col(2));
+    }
+    else
+    {
+      matrix = arma::conv_to<arma::SpMat<eT>>::from(dense);
+    }
+  }
+  else
+  {
+    success = matrix.load(stream, opts.ArmaFormat());
+  }
+
+  if (!opts.NoTranspose())
+  {
+    // It seems that there is no direct way to use inplace_trans() on
+    // sparse matrices.
+    matrix = matrix.t();
+  }
+
+  return success;
+}
+
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/core/data/map_policies/datatype.hpp

@@ -14,7 +14,6 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
 /**
  * The Datatype enum specifies the types of data mlpack algorithms can use.
  * The vast majority of mlpack algorithms can only use numeric data (i.e.
@@ -27,7 +26,6 @@ enum Datatype : bool /* [> bool is all the precision we need for two types <] */
   categorical = 1
 };
 
-} // namespace data
 } // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/data/map_policies/increment_policy.hpp

@@ -17,7 +17,6 @@
 #include <mlpack/core/data/map_policies/datatype.hpp>
 
 namespace mlpack {
-namespace data {
 
 /**
  * IncrementPolicy is used as a helper class for DatasetMapper. It tells how the
@@ -147,7 +146,6 @@ class IncrementPolicy
   bool forceAllMappings;
 }; // class IncrementPolicy
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -14,6 +14,5 @@
 
 #include "datatype.hpp"
 #include "increment_policy.hpp"
-#include "missing_policy.hpp"
 
 #endif

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

@@ -19,40 +19,42 @@
 #include "data_options.hpp"
 
 namespace mlpack {
-namespace data {
 
 template<typename Derived>
 class MatrixOptionsBase : public DataOptionsBase<MatrixOptionsBase<Derived>>
 {
- public:
-  MatrixOptionsBase(bool noTranspose = defaultNoTranspose) :
+ protected:
+  // Users should not construct a MatrixOptionsBase directly.
+  MatrixOptionsBase(std::optional<bool> noTranspose = std::nullopt) :
       DataOptionsBase<MatrixOptionsBase<Derived>>(),
       noTranspose(noTranspose)
-  {
-    // Do Nothing.
-  }
+  { }
 
-  template<typename Derived2>
-  explicit MatrixOptionsBase(const MatrixOptionsBase<Derived2>& opts) :
+ public:
+  //
+  // Handling for copying and moving MatrixOptionsBase of the exact same type.
+  //
+
+  MatrixOptionsBase(const DataOptionsBase<MatrixOptionsBase<Derived>>& opts) :
       DataOptionsBase<MatrixOptionsBase<Derived>>()
   {
     // Delegate to copy operator.
     *this = opts;
   }
 
-  template<typename Derived2>
-  explicit MatrixOptionsBase(MatrixOptionsBase<Derived2>&& opts) :
+  MatrixOptionsBase(DataOptionsBase<MatrixOptionsBase<Derived>>&& opts) :
       DataOptionsBase<MatrixOptionsBase<Derived>>()
   {
     // Delegate to move operator.
     *this = std::move(opts);
   }
 
-  // Inherit base class constructors.
-  using DataOptionsBase<MatrixOptionsBase<Derived>>::DataOptionsBase;
-
-  MatrixOptionsBase& operator=(const MatrixOptionsBase& other)
+  MatrixOptionsBase& operator=(
+      const DataOptionsBase<MatrixOptionsBase<Derived>>& otherIn)
   {
+    const MatrixOptionsBase& other =
+        static_cast<const MatrixOptionsBase&>(otherIn);
+
     if (&other == this)
       return *this;
 
@@ -63,8 +65,11 @@ class MatrixOptionsBase : public DataOptionsBase<MatrixOptionsBase<Derived>>
     return *this;
   }
 
-  MatrixOptionsBase& operator=(MatrixOptionsBase&& other)
+  MatrixOptionsBase& operator=(
+      DataOptionsBase<MatrixOptionsBase<Derived>>&& otherIn)
   {
+    MatrixOptionsBase&& other = static_cast<MatrixOptionsBase&&>(otherIn);
+
     if (&other == this)
       return *this;
 
@@ -74,9 +79,69 @@ class MatrixOptionsBase : public DataOptionsBase<MatrixOptionsBase<Derived>>
     return *this;
   }
 
+  //
+  // Handling for copying and moving entirely different DataOptionsBase types.
+  //
+
+  template<typename Derived2>
+  explicit MatrixOptionsBase(const DataOptionsBase<Derived2>& opts) :
+      DataOptionsBase<MatrixOptionsBase<Derived>>()
+  {
+    // Delegate to copy operator.
+    *this = opts;
+  }
+
   template<typename Derived2>
-  MatrixOptionsBase& operator=(const MatrixOptionsBase<Derived2>& other)
+  explicit MatrixOptionsBase(DataOptionsBase<Derived2>&& opts) :
+      DataOptionsBase<MatrixOptionsBase<Derived>>()
   {
+    // Delegate to move operator.
+    *this = std::move(opts);
+  }
+
+  template<typename Derived2>
+  MatrixOptionsBase& operator=(const DataOptionsBase<Derived2>& otherIn)
+  {
+    // Call out to base operator=.
+    return static_cast<MatrixOptionsBase&>(
+        DataOptionsBase<MatrixOptionsBase>::operator=(otherIn));
+  }
+
+  template<typename Derived2>
+  MatrixOptionsBase& operator=(DataOptionsBase<Derived2>&& otherIn)
+  {
+    // Call out to base operator=.
+    return static_cast<MatrixOptionsBase&>(
+        DataOptionsBase<MatrixOptionsBase>::operator=(std::move(otherIn)));
+  }
+
+  //
+  // Handling for copying and moving different child types of MatrixOptionsBase.
+  //
+
+  template<typename Derived2>
+  MatrixOptionsBase(const DataOptionsBase<MatrixOptionsBase<Derived2>>& opts) :
+      DataOptionsBase<MatrixOptionsBase<Derived>>()
+  {
+    // Delegate to copy operator.
+    *this = opts;
+  }
+
+  template<typename Derived2>
+  MatrixOptionsBase(DataOptionsBase<MatrixOptionsBase<Derived2>>&& opts) :
+      DataOptionsBase<MatrixOptionsBase<Derived>>()
+  {
+    // Delegate to move operator.
+    *this = std::move(opts);
+  }
+
+  template<typename Derived2>
+  MatrixOptionsBase& operator=(
+      const DataOptionsBase<MatrixOptionsBase<Derived2>>& otherIn)
+  {
+    const MatrixOptionsBase<Derived2>& other =
+        static_cast<const MatrixOptionsBase<Derived2>&>(otherIn);
+
     if ((void*) &other == (void*) this)
       return *this;
 
@@ -95,8 +160,12 @@ class MatrixOptionsBase : public DataOptionsBase<MatrixOptionsBase<Derived>>
   }
 
   template<typename Derived2>
-  MatrixOptionsBase& operator=(MatrixOptionsBase<Derived2>&& other)
+  MatrixOptionsBase& operator=(
+      DataOptionsBase<MatrixOptionsBase<Derived2>>&& otherIn)
   {
+    MatrixOptionsBase<Derived2>&& other =
+        static_cast<MatrixOptionsBase<Derived2>&&>(otherIn);
+
     if ((void*) this == (void*) &other)
       return *this;
 
@@ -112,6 +181,25 @@ class MatrixOptionsBase : public DataOptionsBase<MatrixOptionsBase<Derived>>
     return *this;
   }
 
+  // Augment with the options of the other `MatrixOptionsBase`.
+  template<typename Derived2>
+  void Combine(const MatrixOptionsBase<Derived2>& other)
+  {
+    // Combine the noTranspose option.
+    noTranspose =
+        DataOptionsBase<MatrixOptionsBase<Derived>>::CombineBooleanOption(
+        noTranspose, other.noTranspose, "NoTranspose()");
+
+    // If the derived type is the same, we can take any options from it.
+    if constexpr (std::is_same_v<Derived, Derived2>)
+    {
+      static_cast<Derived&>(*this).Combine(static_cast<const Derived2&>(other));
+    }
+
+    // If Derived is not the same as Derived2, we will have printed warnings in
+    // the standalone operator+().
+  }
+
   void WarnBaseConversion(const char* dataDescription) const
   {
     if (noTranspose.has_value() && noTranspose != defaultNoTranspose)
@@ -156,17 +244,61 @@ class MatrixOptionsBase : public DataOptionsBase<MatrixOptionsBase<Derived>>
 // This utility class is meant to be used as the Derived parameter for a matrix
 // option that is not actually a derived type.  It provides the
 // WarnBaseConversion() member, which does nothing.
-class EmptyMatrixOptions : public MatrixOptionsBase<EmptyMatrixOptions>
+class PlainMatrixOptions : public MatrixOptionsBase<PlainMatrixOptions>
 {
  public:
+  // Allow access to all public MatrixOptionsBase constructors and operators,
+  // but with the PlainMatrixOptions type name.
+  using MatrixOptionsBase::MatrixOptionsBase;
+  using MatrixOptionsBase::operator=;
+
+  // However, C++ does not allow inheriting copy and move constructors or
+  // operators, and the inherited protected constructor will still be protected,
+  // so forward those manually.
+  PlainMatrixOptions(const std::optional<bool> noTranspose = std::nullopt) :
+      MatrixOptionsBase(noTranspose) { }
+  PlainMatrixOptions(const MatrixOptionsBase<PlainMatrixOptions>& other) :
+      MatrixOptionsBase(other) { }
+  PlainMatrixOptions(MatrixOptionsBase<PlainMatrixOptions>&& other) :
+      MatrixOptionsBase(std::move(other)) { }
+
+  PlainMatrixOptions& operator=(
+      const MatrixOptionsBase<PlainMatrixOptions>& other)
+  {
+    return static_cast<PlainMatrixOptions&>(
+        MatrixOptionsBase::operator=(other));
+  }
+
+  PlainMatrixOptions& operator=(MatrixOptionsBase<PlainMatrixOptions>&& other)
+  {
+    return static_cast<PlainMatrixOptions&>(
+        MatrixOptionsBase::operator=(std::move(other)));
+  }
+
   void WarnBaseConversion(const char* /* dataDescription */) const { }
   static const char* DataDescription() { return "general data"; }
   void Reset() { }
+  void Combine(const PlainMatrixOptions&) { }
+};
+
+using MatrixOptions = PlainMatrixOptions;
+
+// Boolean options.
+static const MatrixOptions Transpose   = MatrixOptions(false);
+static const MatrixOptions NoTranspose = MatrixOptions(true);
+
+template<typename T>
+struct IsDataOptions<MatrixOptionsBase<T>>
+{
+  constexpr static bool value = true;
 };
 
-using MatrixOptions = MatrixOptionsBase<EmptyMatrixOptions>;
+template<>
+struct IsDataOptions<PlainMatrixOptions>
+{
+  constexpr static bool value = true;
+};
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -17,7 +17,6 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
 
 /**
  * Given a set of labels of a particular datatype, convert them to unsigned
@@ -47,7 +46,6 @@ void RevertLabels(const arma::Row<size_t>& labels,
                   const arma::Col<eT>& mapping,
                   arma::Row<eT>& labelsOut);
 
-} // namespace data
 } // namespace mlpack
 
 // Include implementation.

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

@@ -17,7 +17,6 @@
 #include "normalize_labels.hpp"
 
 namespace mlpack {
-namespace data {
 
 /**
  * Given a set of labels of a particular datatype, convert them to unsigned
@@ -86,7 +85,6 @@ void RevertLabels(const arma::Row<size_t>& labels,
     labelsOut[i] = mapping[labels[i]];
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -17,7 +17,6 @@
 #include <mlpack/core.hpp>
 
 namespace mlpack {
-namespace data {
 
 /**
  * Given a set of labels of a particular datatype, convert them to binary
@@ -51,7 +50,7 @@ void OneHotEncoding(const arma::Mat<eT>& input,
  * Overloaded function for the above function, which takes a matrix as input
  * and also a DatasetInfo object and outputs a matrix.
  * This function encodes all the dimensions marked `Datatype::categorical`
- * in the data::DatasetInfo.
+ * in the DatasetInfo.
  *
  * @param input Input dataset to be encoded.
  * @param output Encoded matrix.
@@ -60,9 +59,8 @@ void OneHotEncoding(const arma::Mat<eT>& input,
 template<typename eT>
 void OneHotEncoding(const arma::Mat<eT>& input,
                     arma::Mat<eT>& output,
-                    const data::DatasetInfo& datasetInfo);
+                    const DatasetInfo& datasetInfo);
 
-} // namespace data
 } // namespace mlpack
 
 // Include implementation.