mlpack 4.6.2__cp38-cp38-win_amd64.whl → 4.7.0__cp38-cp38-win_amd64.whl

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

@@ -16,10 +16,9 @@
 #include <mlpack/prereqs.hpp>
 #include <mlpack/core/stb/stb.hpp>
 
-#include "image_info.hpp"
+#include "image_options.hpp"
 
 namespace mlpack {
-namespace data {
 
 /**
  * Image resize/crop interfaces.
@@ -42,8 +41,9 @@ namespace data {
  * @param newHeight The new requested height for the resized image.
  */
 template<typename eT>
-inline void ResizeImages(arma::Mat<eT>& images, data::ImageInfo& info,
-    const size_t newWidth, const size_t newHeight)
+void ResizeImages(arma::Mat<eT>& images, ImageOptions& opts,
+    const size_t newWidth, const size_t newHeight,
+    const typename std::enable_if_t<std::is_floating_point<eT>::value>* = 0)
 {
   // First check if we are resizing one image or a group of images, the check
   // is going to be different depending on the dimension.
@@ -52,7 +52,7 @@ inline void ResizeImages(arma::Mat<eT>& images, data::ImageInfo& info,
   // assume that all images have identical dimension and need to be resized.
   if (images.n_cols == 1)
   {
-    if (images.n_elem != (info.Width() * info.Height() * info.Channels()))
+    if (images.n_elem != (opts.Width() * opts.Height() * opts.Channels()))
     {
       Log::Fatal << "ResizeImages(): dimensions mismatch: the number of pixels "
           << "is not equal to the dimension provided by the given ImageInfo."
@@ -61,7 +61,7 @@ inline void ResizeImages(arma::Mat<eT>& images, data::ImageInfo& info,
   }
   else
   {
-    if (images.n_rows != (info.Width() * info.Height() * info.Channels()))
+    if (images.n_rows != (opts.Width() * opts.Height() * opts.Channels()))
     {
       Log::Fatal << "ResizeImages(): dimension mismatch: in the case of "
           << "several images, please check that all the images have the same "
@@ -71,61 +71,127 @@ inline void ResizeImages(arma::Mat<eT>& images, data::ImageInfo& info,
   }
 
   stbir_pixel_layout channels;
-  if (info.Channels() == 1)
+  if (opts.Channels() == 1)
   {
     channels = STBIR_1CHANNEL;
   }
-  else if (info.Channels() == 3)
+  else if (opts.Channels() == 3)
   {
     channels = STBIR_RGB;
   }
+  else
+  {
+    Log::Fatal << "ResizeImages(): number of channels should be either 1 or 3,"
+        << " not " << opts.Channels() << "." << std::endl;
+  }
 
-  // This is required since STB only accept unsigned chars.
-  // set the new matrix size for copy
-  size_t newDimension = newWidth * newHeight * info.Channels();
+  size_t newDimension = newWidth * newHeight * opts.Channels();
+  arma::Mat<float> originalImagesFloat;
   arma::Mat<float> resizedFloatImages;
-  arma::Mat<unsigned char> resizedImages;
 
-  // This is not optimal, but I do not want to allocate memory for nothing.
-  if (std::is_same<eT, float>::value)
-    resizedFloatImages.set_size(newDimension, images.n_cols);
+  // We need to covert to a float if we are resizing a double.
+  if constexpr (std::is_same_v<eT, float>)
+  {
+    MakeAlias(originalImagesFloat, images, images.n_rows, images.n_cols);
+  }
   else
-    resizedImages.set_size(newDimension, images.n_cols);
+  {
+    originalImagesFloat =
+        arma::conv_to<arma::Mat<float>>::from(std::move(images));
+  }
+
+  // recover the original min/max values for clamping.
+  float minOriginal = images.min();
+  float maxOriginal = images.max();
 
+  resizedFloatImages.set_size(newDimension, images.n_cols);
   for (size_t i = 0; i < images.n_cols; ++i)
   {
-    if constexpr (std::is_same<eT, unsigned char>::value)
+    stbir_resize_float_linear(originalImagesFloat.colptr(i), opts.Width(),
+          opts.Height(), 0, resizedFloatImages.colptr(i), newWidth, newHeight,
+          0, channels);
+  }
+
+  images = arma::conv_to<arma::Mat<eT>>::from(std::move(resizedFloatImages));
+
+  images.clamp(minOriginal, maxOriginal);
+
+  opts.Width() = newWidth;
+  opts.Height() = newHeight;
+}
+
+template<typename eT>
+void ResizeImages(arma::Mat<eT>& images, ImageOptions& opts,
+    const size_t newWidth, const size_t newHeight,
+    const typename std::enable_if_t<std::is_integral_v<eT>>* = 0)
+{
+  // First check if we are resizing one image or a group of images, the check
+  // is going to be different depending on the dimension.
+  // If the user would like to resize a set of images of different dimensions,
+  // then they need to consider passing them image by image. Otherwise, as
+  // assume that all images have identical dimension and need to be resized.
+  if (images.n_cols == 1)
+  {
+    if (images.n_elem != (opts.Width() * opts.Height() * opts.Channels()))
     {
-      stbir_resize_uint8_linear(images.colptr(i), info.Width(), info.Height(),
-          0, resizedImages.colptr(i), newWidth, newHeight, 0, channels);
+      Log::Fatal << "ResizeImages(): dimensions mismatch: the number of pixels "
+          << "is not equal to the dimension provided by the given ImageInfo."
+          << std::endl;
     }
-    else if constexpr (std::is_same<eT, float>::value)
+  }
+  else
+  {
+    if (images.n_rows != (opts.Width() * opts.Height() * opts.Channels()))
     {
-      stbir_resize_float_linear(images.colptr(i), info.Width(), info.Height(),
-          0, resizedFloatImages.colptr(i), newWidth, newHeight, 0, channels);
+      Log::Fatal << "ResizeImages(): dimension mismatch: in the case of "
+          << "several images, please check that all the images have the same "
+          << "dimensions; if not, load each image in one column and call this "
+          << "function iteratively." << std::endl;
     }
-    else
-    {
-      arma::Mat<unsigned char> tempSrc =
-          arma::conv_to<arma::Mat<unsigned char>>::from(images);
+  }
 
-      stbir_resize_uint8_linear(tempSrc.colptr(i), info.Width(), info.Height(),
-          0, resizedImages.colptr(i), newWidth, newHeight, 0, channels);
-    }
+  stbir_pixel_layout channels;
+  if (opts.Channels() == 1)
+  {
+    channels = STBIR_1CHANNEL;
+  }
+  else if (opts.Channels() == 3)
+  {
+    channels = STBIR_RGB;
+  }
+  else
+  {
+    Log::Fatal << "ResizeImages(): number of channels should be either 1 or 3,"
+        << " not " << opts.Channels() << "." << std::endl;
   }
 
-  if (std::is_same<eT, float>::value)
+  // This is required since STB only accept unsigned chars.
+  // set the new matrix size for copy
+  size_t newDimension = newWidth * newHeight * opts.Channels();
+  arma::Mat<unsigned char> resizedImages;
+  arma::Mat<unsigned char> originalImages;
+  if constexpr (std::is_same_v<eT, unsigned char>)
   {
-    // The conv_to is needed here so that this code compiles even when this
-    // branch isn't taken.
-    images = arma::conv_to<arma::Mat<eT>>::from(std::move(resizedFloatImages));
+    MakeAlias(originalImages, images, images.n_rows, images.n_cols);
   }
   else
   {
-    images = arma::conv_to<arma::Mat<eT>>::from(std::move(resizedImages));
+    originalImages =
+        arma::conv_to<arma::Mat<unsigned char>>::from(std::move(images));
   }
-  info.Width() = newWidth;
-  info.Height() = newHeight;
+
+  resizedImages.set_size(newDimension, images.n_cols);
+
+  for (size_t i = 0; i < images.n_cols; ++i)
+  {
+    stbir_resize_uint8_linear(originalImages.colptr(i), opts.Width(),
+        opts.Height(), 0, resizedImages.colptr(i), newWidth, newHeight, 0,
+        channels);
+  }
+
+  images = arma::conv_to<arma::Mat<eT>>::from(std::move(resizedImages));
+  opts.Width() = newWidth;
+  opts.Height() = newHeight;
 }
 
 /**
@@ -145,17 +211,17 @@ inline void ResizeImages(arma::Mat<eT>& images, data::ImageInfo& info,
  * @param newHeight The new requested height for the resized image.
  */
 template<typename eT>
-inline void ResizeCropImages(arma::Mat<eT>& images, data::ImageInfo& info,
+void ResizeCropImages(arma::Mat<eT>& images, ImageOptions& opts,
     const size_t newWidth, const size_t newHeight)
 {
   float ratioW = static_cast<float>(newWidth)  /
-      static_cast<float>(info.Width());
+      static_cast<float>(opts.Width());
   float ratioH = static_cast<float>(newHeight) /
-      static_cast<float>(info.Height());
+      static_cast<float>(opts.Height());
 
   float largestRatio = ratioW > ratioH ? ratioW : ratioH;
-  int midWidth = static_cast<int>(largestRatio * info.Width());
-  int midHeight = static_cast<int>(largestRatio * info.Height());
+  int midWidth = static_cast<int>(largestRatio * opts.Width());
+  int midHeight = static_cast<int>(largestRatio * opts.Height());
 
   // Edge cases, what if the width / height value is odd ? then increase the
   // resize value to the closest pair number.
@@ -169,16 +235,16 @@ inline void ResizeCropImages(arma::Mat<eT>& images, data::ImageInfo& info,
     if (midWidth % 2 != 0)
       midWidth = midWidth + 1;
 
-    ResizeImages(images, info, midWidth, midHeight);
+    ResizeImages(images, opts, midWidth, midHeight);
     int nColsCrop = midWidth > midHeight ? (midWidth - midHeight) : 0;
     int nRowsCrop = midHeight > midWidth ? (midHeight - midWidth) : 0;
 
     //temporary matrix to hold the images while being resized.
-    arma::Mat<eT> tmpImages(newHeight * newWidth * info.Channels(),
+    arma::Mat<eT> tmpImages(newHeight * newWidth * opts.Channels(),
         images.n_cols);
     if (nRowsCrop != 0)
     {
-      int cropUpDownEqually = (nRowsCrop / 2) * info.Channels() * midWidth;
+      int cropUpDownEqually = (nRowsCrop / 2) * opts.Channels() * midWidth;
       tmpImages = images.rows(cropUpDownEqually,
           images.n_rows - cropUpDownEqually - 1);
     }
@@ -194,7 +260,7 @@ inline void ResizeCropImages(arma::Mat<eT>& images, data::ImageInfo& info,
         // B into Row 3.
         // Cols are the Width, no change
         // Slices are the Height of the image instead of rows.
-        arma::Cube<eT> cube(images.colptr(u), info.Channels(), midWidth,
+        arma::Cube<eT> cube(images.colptr(u), opts.Channels(), midWidth,
             midHeight, false, false);
         tmpImages.col(u) = vectorise(cube.cols((nColsCrop / 2),
               (cube.n_cols  - (nColsCrop / 2) - 1)));
@@ -205,11 +271,10 @@ inline void ResizeCropImages(arma::Mat<eT>& images, data::ImageInfo& info,
       images = std::move(tmpImages);
     }
   }
-  info.Width() = newWidth;
-  info.Height() = newHeight;
+  opts.Width() = newWidth;
+  opts.Height() = newHeight;
 }
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -15,17 +15,17 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
+
 /**
- * A simple custom imputation class
- * @tparam T Type of armadillo matrix
+ * A simple custom imputation class, which replaces missing values with a
+ * predefined value.
  */
-template <typename T>
+template<typename ElemType = double>
 class CustomImputation
 {
  public:
-  CustomImputation(T customValue):
-      customValue(std::move(customValue))
+  CustomImputation(const ElemType customValue):
+      customValue(customValue)
   {
     // nothing to initialize here
   }
@@ -41,42 +41,26 @@ class CustomImputation
    * @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,
+  template<typename MatType>
+  void Impute(MatType& input,
+              const typename MatType::elem_type& missingValue,
               const size_t dimension,
               const bool columnMajor = true)
   {
-    // replace the target value to custom value
+    typedef typename MatType::elem_type T;
+
+    // Here we can use .replace() directly.
     if (columnMajor)
-    {
-      for (size_t i = 0; i < input.n_cols; ++i)
-      {
-        if (input(dimension, i) == mappedValue ||
-            std::isnan(input(dimension, i)))
-        {
-          input(dimension, i) = customValue;
-        }
-      }
-    }
+      input.row(dimension).replace(missingValue, (T) customValue);
     else
-    {
-      for (size_t i = 0; i < input.n_rows; ++i)
-      {
-        if (input(i, dimension) == mappedValue ||
-            std::isnan(input(i, dimension)))
-        {
-          input(i, dimension) = customValue;
-        }
-      }
-    }
+      input.col(dimension).replace(missingValue, (T) customValue);
   }
 
  private:
-  //! A user-defined value that the user wants to replace missing values with.
-  T customValue;
+  // A user-defined value that the user wants to replace missing values with.
+  ElemType customValue;
 }; // class CustomImputation
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -15,13 +15,11 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
+
 /**
- * A complete-case analysis to remove the values containing mappedValue.
+ * A complete-case analysis to remove the columns containing missingValue.
  * Removes all data for a case that has one or more missing values.
- * @tparam T Type of armadillo matrix
  */
-template <typename T>
 class ListwiseDeletion
 {
  public:
@@ -30,45 +28,37 @@ class ListwiseDeletion
    * remove the whole row or column. The result is overwritten to the input.
    *
    * @param input Matrix that contains mappedValue.
-   * @param mappedValue Value that the user wants to get rid of.
-   * @param dimension Index of the dimension of the mappedValue.
+   * @param missingValue Value that the user wants to get rid of.
+   * @param dimension Index of the dimension to search for missingValue.
    * @param columnMajor State of whether the input matrix is columnMajor or not.
    */
-  void Impute(arma::Mat<T>& input,
-              const T& mappedValue,
+  template<typename MatType>
+  void Impute(MatType& input,
+              const typename MatType::elem_type& missingValue,
               const size_t dimension,
               const bool columnMajor = true)
   {
-    std::vector<arma::uword> colsToKeep;
+    static_assert(!IsSparse<MatType>::value, "ListwiseDeletion::Impute(): "
+        "sparse matrix imputation is not supported; use a dense matrix "
+        "instead!");
 
-    if (columnMajor)
+    if (std::isnan(missingValue))
     {
-      for (size_t i = 0; i < input.n_cols; ++i)
-      {
-         if (!(input(dimension, i) == mappedValue ||
-             std::isnan(input(dimension, i))))
-         {
-           colsToKeep.push_back(i);
-         }
-      }
-      input = input.cols(arma::uvec(colsToKeep));
+      if (columnMajor)
+        input.shed_cols(find_nan(input.row(dimension)));
+      else
+        input.shed_rows(find_nan(input.col(dimension)));
     }
     else
     {
-      for (size_t i = 0; i < input.n_rows; ++i)
-      {
-        if (!(input(i, dimension) == mappedValue ||
-             std::isnan(input(i, dimension))))
-        {
-           colsToKeep.push_back(i);
-        }
-      }
-      input = input.rows(arma::uvec(colsToKeep));
+      if (columnMajor)
+        input.shed_cols(find(input.row(dimension) == missingValue));
+      else
+        input.shed_rows(find(input.col(dimension) == missingValue));
     }
   }
 }; // class ListwiseDeletion
 
-} // namespace data
 } // namespace mlpack
 
 #endif

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

@@ -15,12 +15,10 @@
 #include <mlpack/prereqs.hpp>
 
 namespace mlpack {
-namespace data {
+
 /**
- * A simple mean imputation class
- * @tparam T Type of armadillo matrix
+ * A simple mean imputation class.
  */
-template <typename T>
 class MeanImputation
 {
  public:
@@ -29,76 +27,147 @@ class MeanImputation
    * replaces it with the mean of the given dimension. The result is overwritten
    * to the input matrix.
    *
-   * @param input Matrix that contains mappedValue.
-   * @param mappedValue Value that the user wants to get rid of.
-   * @param dimension Index of the dimension of the mappedValue.
-   * @param columnMajor State of whether the input matrix is columnMajor or not.
+   * @param input Matrix that contains missingValue.
+   * @param missingValue Value to replace with the mean.
+   * @param dimension Index of the dimension to impute.
+   * @param columnMajor If true, `input` is column major.
    */
-  void Impute(arma::Mat<T>& input,
-              const T& mappedValue,
-              const size_t dimension,
-              const bool columnMajor = true)
+  template<typename T>
+  static void Impute(arma::Mat<T>& input,
+                     const T& missingValue,
+                     const size_t dimension,
+                     const bool columnMajor = true)
   {
-    double sum = 0;
-    size_t elems = 0; // excluding nan or missing target
-
-    using PairType = std::pair<size_t, size_t>;
-    // dimensions and indexes are saved as pairs inside this vector.
-    std::vector<PairType> targets;
+    T sum = 0;
+    size_t elems = 0; // Excluding missingValue.
 
-
-    // calculate number of elements and sum of them excluding mapped value or
-    // nan. while doing that, remember where mappedValue or NaN exists.
-    if (columnMajor)
+    // Different implementations if we are searching for NaN.
+    if (std::isnan(missingValue))
     {
-      for (size_t i = 0; i < input.n_cols; ++i)
+      if (columnMajor)
       {
-        if (input(dimension, i) == mappedValue ||
-            std::isnan(input(dimension, i)))
+        #pragma omp parallel for schedule(static)
+        for (size_t i = 0; i < input.n_cols; ++i)
         {
-          targets.emplace_back(dimension, i);
+          if (!std::isnan(input(dimension, i)))
+          {
+            ++elems;
+            sum += input(dimension, i);
+          }
         }
-        else
+      }
+      else
+      {
+        #pragma omp parallel for schedule(static)
+        for (size_t i = 0; i < input.n_rows; ++i)
         {
-          elems++;
-          sum += input(dimension, i);
+          if (!std::isnan(input(i, dimension)))
+          {
+            ++elems;
+            sum += input(i, dimension);
+          }
         }
       }
     }
     else
     {
-      for (size_t i = 0; i < input.n_rows; ++i)
+      if (columnMajor)
       {
-        if (input(i, dimension) == mappedValue ||
-            std::isnan(input(i, dimension)))
+        #pragma omp parallel for schedule(static)
+        for (size_t i = 0; i < input.n_cols; ++i)
         {
-          targets.emplace_back(i, dimension);
+          if (input(dimension, i) != missingValue)
+          {
+            ++elems;
+            sum += input(dimension, i);
+          }
         }
-        else
+      }
+      else
+      {
+        #pragma omp parallel for schedule(static)
+        for (size_t i = 0; i < input.n_rows; ++i)
         {
-          elems++;
-          sum += input(i, dimension);
+          if (input(i, dimension) != missingValue)
+          {
+            ++elems;
+            sum += input(i, dimension);
+          }
         }
       }
     }
 
     if (elems == 0)
-      Log::Fatal << "it is impossible to calculate mean; no valid elements in "
-          << "the dimension" << std::endl;
+    {
+      throw std::invalid_argument("MeanImputation::Impute(): no non-missing "
+          "elements; cannot compute mean!");
+    }
 
-    // calculate mean;
+    // Now compute the mean.
     const double mean = sum / elems;
 
-    // Now replace the calculated mean to the missing variables
-    // It only needs to loop through targets vector, not the whole matrix.
-    for (const PairType& target : targets)
+    // Replace all values with the computed mean.
+    if (columnMajor)
+      input.row(dimension).replace(missingValue, mean);
+    else
+      input.col(dimension).replace(missingValue, mean);
+  }
+
+  template<typename MatType>
+  static void Impute(MatType& input,
+                     const typename MatType::elem_type& missingValue,
+                     const size_t dimension,
+                     const bool columnMajor = true)
+  {
+    static_assert(!IsSparse<MatType>::value, "MeanImputation::Impute(): sparse "
+        "matrix imputation is not supported; use a dense matrix instead!");
+
+    typedef typename MatType::elem_type ElemType;
+
+    // This less efficient implementation uses Armadillo (or Bandicoot)
+    // directly, but at the cost of more memory.
+    ElemType meanValue;
+    MatType tmp;
+    if (std::isnan(missingValue))
     {
-      input(target.first, target.second) = mean;
+      if (columnMajor)
+        tmp = input.row(dimension);
+      else
+        tmp = input.col(dimension).t(); // make sure it is a row vector
+
+      tmp.shed_cols(find_nan(tmp));
     }
+    else
+    {
+      typedef typename GetUColType<MatType>::type UCol;
+      if (columnMajor)
+      {
+        tmp = input.submat(UCol({ dimension }),
+            find(input.row(dimension) != missingValue));
+      }
+      else
+      {
+        tmp = input.submat(
+            find(input.col(dimension) != missingValue), UCol({ dimension }));
+      }
+    }
+
+    // Compute the mean on the subset of valid elements.
+    if (tmp.is_empty())
+    {
+      throw std::invalid_argument("MeanImputation::Impute(): no non-missing "
+          "elements; cannot compute mean!");
+    }
+    meanValue = mean(vectorise(tmp));
+
+    // Now impute the computed mean value.
+    if (columnMajor)
+      input.row(dimension).replace(missingValue, meanValue);
+    else
+      input.col(dimension).replace(missingValue, meanValue);
   }
 }; // class MeanImputation
 
-} // namespace data
 } // namespace mlpack
 
 #endif