mlpack 4.6.0__cp310-cp310-win_amd64.whl → 4.6.1__cp310-cp310-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.1'

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

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

@@ -12,34 +12,11 @@
  * 3-clause BSD license along with mlpack.  If not, see
  * http://www.opensource.org/licenses/BSD-3-Clause for more information.
  */
-#include "extension.hpp"
 #include "detect_file_type.hpp"
-#include "string_algorithms.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)
-{
-  switch (type)
-  {
-    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::HDF5Binary:  return "HDF5 data";
-    case FileType::CoordASCII:  return "ASCII formatted sparse coordinate data";
-    default:                    return "";
-  }
-}
-
 /**
  * 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
@@ -292,6 +269,11 @@ inline FileType AutoDetect(std::fstream& stream, const std::string& filename)
   {
     detectedLoadType = FileType::HDF5Binary;
   }
+  else if (extension == "arff")
+  {
+    return FileType::ARFFASCII;
+  }
+
   else // Unknown extension...
   {
     detectedLoadType = FileType::FileTypeUnknown;
@@ -306,34 +288,43 @@ inline FileType AutoDetect(std::fstream& stream, const std::string& filename)
  * @param filename Name of the file whose type we should detect.
  * @return Detected type of file.
  */
-inline FileType DetectFromExtension(const std::string& filename)
+template<typename MatType, typename DataOptionsType>
+void DetectFromExtension(const std::string& filename,
+                         DataOptionsType& opts)
 {
   const std::string extension = Extension(filename);
 
   if (extension == "csv")
   {
-    return FileType::CSVASCII;
+    opts.Format() = FileType::CSVASCII;
   }
   else if (extension == "txt")
   {
-    return FileType::RawASCII;
+    if (IsSparseMat<MatType>::value)
+      opts.Format() = FileType::CoordASCII;
+    else
+      opts.Format() = FileType::RawASCII;
   }
   else if (extension == "bin")
   {
-    return FileType::ArmaBinary;
+    opts.Format() = FileType::ArmaBinary;
   }
   else if (extension == "pgm")
   {
-    return FileType::PGMBinary;
+    opts.Format() = FileType::PGMBinary;
   }
   else if (extension == "h5" || extension == "hdf5" || extension == "hdf" ||
            extension == "he5")
   {
-    return FileType::HDF5Binary;
+    opts.Format() = FileType::HDF5Binary;
+  }
+  else if (extension == "arff")
+  {
+    opts.Format() = FileType::ARFFASCII;
   }
   else
   {
-    return FileType::FileTypeUnknown;
+    opts.Format() = FileType::FileTypeUnknown;
   }
 }
 

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

@@ -1,6 +1,7 @@
 /**
  * @file core/data/load.hpp
  * @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
@@ -15,19 +16,55 @@
 #define MLPACK_CORE_DATA_LOAD_HPP
 
 #include <mlpack/prereqs.hpp>
-#include <string>
 
+#include "text_options.hpp"
 #include "format.hpp"
 #include "dataset_mapper.hpp"
 #include "detect_file_type.hpp"
 #include "image_info.hpp"
-#include "load_csv.hpp"
 #include "load_arff.hpp"
+#include "load_numeric.hpp"
+#include "load_categorical.hpp"
 #include "load_image.hpp"
+#include "utilities.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
+ * will load with the options specified in `opts`.
+ *
+ * @param filename Name of file to load.
+ * @param matrix Matrix to load contents of file into.
+ * @param opts DataOptions to be passed to the function
+ * @return Boolean value indicating success or failure of load.
+ */
+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);
+
+/**
+ * Loads a matrix from file, guessing the filetype from the extension.  This
+ * will load with the options specified in `opts`.
+ *
+ * @param filename Name of file to load.
+ * @param matrix Matrix to load contents of file into.
+ * @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>
+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);
+
 /**
  * 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
@@ -250,7 +287,8 @@ bool Load(const std::string& filename,
           const std::string& name,
           T& t,
           const bool fatal = false,
-          format f = format::autodetect);
+          format f = format::autodetect,
+          std::enable_if_t<HasSerialize<T>::value>* = 0);
 
 } // namespace data
 } // namespace mlpack

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

@@ -25,7 +25,7 @@ namespace data {
  * if any features are non-numeric.
  */
 template<typename eT>
-void LoadARFF(const std::string& filename, arma::Mat<eT>& matrix);
+bool LoadARFF(const std::string& filename, arma::Mat<eT>& matrix);
 
 /**
  * A utility function to load an ARFF dataset as numeric and categorical
@@ -50,9 +50,10 @@ void LoadARFF(const std::string& filename, arma::Mat<eT>& matrix);
  *     from another call to LoadARFF().
  */
 template<typename eT, typename PolicyType>
-void LoadARFF(const std::string& filename,
+bool LoadARFF(const std::string& filename,
               arma::Mat<eT>& matrix,
-              DatasetMapper<PolicyType>& info);
+              DatasetMapper<PolicyType>& info,
+              bool fatal);
 
 } // namespace data
 } // namespace mlpack