mlpack 4.5.1__pp38-pypy38_pp73-win_amd64.whl → 4.6.2__pp38-pypy38_pp73-win_amd64.whl

mlpack/__init__.py

@@ -11,7 +11,7 @@ http://www.opensource.org/licenses/BSD-3-Clause for more information.
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_9_0():
+def _delvewheel_patch_1_10_0():
     import ctypes
     import os
     import platform
@@ -22,10 +22,10 @@ def _delvewheel_patch_1_9_0():
         if os.path.isdir(libs_dir):
             os.add_dll_directory(libs_dir)
     else:
-        load_order_filepath = os.path.join(libs_dir, '.load-order-mlpack-4.5.1')
+        load_order_filepath = os.path.join(libs_dir, '.load-order-mlpack-4.6.2')
         if os.path.isfile(load_order_filepath):
             import ctypes.wintypes
-            with open(os.path.join(libs_dir, '.load-order-mlpack-4.5.1')) as file:
+            with open(os.path.join(libs_dir, '.load-order-mlpack-4.6.2')) as file:
                 load_order = file.read().split()
             kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
             kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
@@ -36,8 +36,8 @@ def _delvewheel_patch_1_9_0():
                     raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
 
 
-_delvewheel_patch_1_9_0()
-del _delvewheel_patch_1_9_0
+_delvewheel_patch_1_10_0()
+del _delvewheel_patch_1_10_0
 # end delvewheel patch
 
 import warnings
@@ -58,6 +58,7 @@ from .hmm_generate import hmm_generate
 from .hmm_loglik import hmm_loglik
 from .hmm_viterbi import hmm_viterbi
 from .hoeffding_tree import hoeffding_tree
+from .image_converter import image_converter
 from .kde import kde
 from .kernel_pca import kernel_pca
 from .kmeans import kmeans
@@ -92,5 +93,4 @@ from .adaboost import *
 from .linear_regression_train import linear_regression_train
 from .linear_regression_predict import linear_regression_predict
 from .linear_regression import *
-from .image_converter import image_converter
-__version__='4.5.1'
+__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
@@ -93,11 +94,16 @@
   #pragma warning(disable : 4519)
 #endif
 
-// This can be removed when Visual Studio supports an OpenMP version with
-// unsigned loop variables.
+// OpenMP usage must be version 3.1 or newer, if it is being used.
 #if (defined(_OPENMP) && (_OPENMP >= 201107))
-  #undef  MLPACK_USE_OPENMP
+  #undef MLPACK_USE_OPENMP
   #define MLPACK_USE_OPENMP
+#elif defined(_OPENMP)
+  #ifdef _MSC_VER
+    #error "mlpack requires OpenMP 3.1+; compile without /OPENMP"
+  #else
+    #error "mlpack requires OpenMP 3.1+; disable OpenMP in your compiler"
+  #endif
 #endif
 
 #endif

mlpack/include/mlpack/config.hpp

@@ -23,29 +23,6 @@
 // #define MLPACK_HAS_BFD_DL
 #endif
 
-//
-// mlpack provides image loading and saving support via STB, if available.  STB
-// is an optional dependency of mlpack.  When STB is found on a system,
-// MLPACK_HAS_STB will be defined and the files `stb_image.h` and
-// `stb_image_write.h` are expected to be found in the compiler include path.
-//
-#ifndef MLPACK_HAS_STB
-// #define MLPACK_HAS_STB
-#endif
-
-//
-// If STB support is available but the STB headers do not live in an stb/
-// directory, then MLPACK_HAS_NO_STB_DIR should be defined.
-//
-// Note that this is ignored in newer compilers where __has_include is available
-// (C++17 and newer compilers support it).
-//
-#ifdef MLPACK_HAS_STB
-#ifndef MLPACK_HAS_NO_STB_DIR
-// #define MLPACK_HAS_NO_STB_DIR
-#endif
-#endif
-
 //
 // If the version of mlpack is built from a git repository and is not an
 // official release, then MLPACK_GIT_VERSION will be defined.  This causes
@@ -72,42 +49,28 @@
   #define MLPACK_CERR_STREAM std::cerr
 #endif
 
+
 //
-// Perform autodetection of STB if possible.
+// MLPACK_NO_STD_MUTEX is used to disable mutex usage inside mlpack. Assuming
+// the system has one core only.
 //
-#ifndef MLPACK_HAS_STB
-  #if defined __has_include
-    #if __has_include("stb_image.h")
-      #define MLPACK_HAS_STB_IMAGE
-    #elif __has_include("stb/stb_image.h")
-      #define MLPACK_HAS_STB_IMAGE
-    #endif
-
-    #if __has_include("stb_image_write.h")
-      #define MLPACK_HAS_STB_IMAGE_WRITE
-    #elif __has_include("stb/stb_image_write.h")
-      #define MLPACK_HAS_STB_IMAGE_WRITE
-    #endif
-
-    #if defined(MLPACK_HAS_STB_IMAGE) && defined(MLPACK_HAS_STB_IMAGE_WRITE)
-      #define MLPACK_HAS_STB
-    #endif
-
-    #undef MLPACK_HAS_STB_IMAGE
-    #undef MLPACK_HAS_STB_IMAGE_WRITE
-  #endif
+#ifdef MLPACK_NO_STD_MUTEX
+  #define ARMA_DONT_USE_STD_MUTEX
 #endif
 
 //
-// These macros can be defined to disable support that is defined above.  (This
-// is useful if you cannot or do not want to modify config.hpp.)
+// MLPACK_USE_SYSTEM_STB is used to enable usage of locally installed STB.
 //
-#ifdef MLPACK_DISABLE_STB
-  #undef MLPACK_HAS_STB
+#if !defined(MLPACK_USE_SYSTEM_STB)
+  // #define MLPACK_USE_SYSTEM_STB
 #endif
 
-#ifdef MLPACK_DISABLE_NO_STB_DIR
-  #undef MLPACK_HAS_NO_STB_DIR
+//
+// This is necessary if we would like to overwrite the default packaging
+// condition.
+//
+#if defined(MLPACK_DONT_USE_SYSTEM_STB) && defined(MLPACK_USE_SYSTEM_STB)
+  #undef MLPACK_USE_SYSTEM_STB
 #endif
 
 #ifdef MLPACK_DISABLE_BFD_DL

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,13 +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