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

mlpack/include/mlpack/core/data/save_image.hpp

@@ -1,8 +1,9 @@
 /**
  * @file core/data/save_image.hpp
  * @author Ryan Curtin
+ * @author Omar Shrit
  *
- * Implementation of save functionality.
+ * Implementation of save image functionality.
  *
  * 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
@@ -13,54 +14,93 @@
 #define MLPACK_CORE_DATA_SAVE_IMAGE_HPP
 
 #include <mlpack/core/stb/stb.hpp>
-
-#include "image_info.hpp"
+#include <mlpack/core/math/make_alias.hpp>
 
 namespace mlpack {
-namespace data {
 
-/**
- * Save the image file from the given matrix.
- *
- * @param filename Name of the image file.
- * @param matrix Matrix to save the image from.
- * @param info An object of ImageInfo class.
- * @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 Save(const std::string& filename,
-          arma::Mat<eT>& matrix,
-          ImageInfo& info,
-          const bool fatal = false);
+bool SaveImage(const std::vector<std::string>& files,
+               const arma::Mat<eT>& matrix,
+               ImageOptions& opts)
+{
+  if (files.empty())
+  {
+    std::stringstream oss;
+    oss << "Save(): vector of image files is empty; nothing to save.";
+    return HandleError(oss, opts);
+  }
 
-/**
- * Save the image file from the given matrix.
- *
- * @param files A vector consisting of filenames.
- * @param matrix Matrix to save the image from.
- * @param info An object of ImageInfo class.
- * @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 Save(const std::vector<std::string>& files,
-          arma::Mat<eT>& matrix,
-          ImageInfo& info,
-          const bool fatal = false);
+  // Check if we do have any type that is not supported.
+  if (opts.Format() == FileType::ImageType ||
+      opts.Format() == FileType::AutoDetect)
+  {
+    for (size_t i = 0; i < files.size() ; ++i)
+    {
+      if (!opts.saveType.count(Extension(files.at(i))))
+      {
+        std::stringstream oss;
+        oss << "Save(): file type " << opts.FileTypeToString()
+            << " isn't supported. Currently image saving supports: ";
+        for (const auto& x : opts.saveType)
+          oss << "  " << x;
+        oss << "." << std::endl;
+        return HandleError(oss, opts);
+      }
+    }
+  }
 
-/**
- * Helper function to save files.  Implementation in save_image.hpp.
- */
-inline bool SaveImage(const std::string& filename,
-                      arma::Mat<unsigned char>& image,
-                      ImageInfo& info,
-                      const bool fatal = false);
+  size_t dimension = opts.Width() * opts.Height() * opts.Channels() *
+      files.size();
+  // We only need to check the rows since it is a matrix.
+  if (dimension != matrix.n_rows * matrix.n_cols)
+  {
+    std::stringstream oss;
+    oss << "Save(): The given image dimensions, Width: " << opts.Width()
+        << ", Height: " << opts.Height() << ", Channels: "<< opts.Channels()
+        << " do not match the dimensions of the matrix to be saved!";
+    return HandleError(oss, opts);
+  }
+  // Unfortunately we cannot move because matrix is const.
+  arma::Mat<unsigned char> tempMatrix =
+      arma::conv_to<arma::Mat<unsigned char>>::from(matrix);
+  bool success = false;
+  for (size_t i = 0; i < files.size() ; ++i)
+  {
+    // Update opts.Format() at each iteration.
+    DetectFromExtension<arma::Mat<eT>, ImageOptions>(files.at(i), opts);
+    if (opts.Format() == FileType::PNG)
+    {
+      success = stbi_write_png(files.at(i).c_str(), opts.Width(), opts.Height(),
+          opts.Channels(), tempMatrix.colptr(i),
+          opts.Width() * opts.Channels());
+    }
+    else if (opts.Format() == FileType::BMP)
+    {
+      success = stbi_write_bmp(files.at(i).c_str(), opts.Width(), opts.Height(),
+          opts.Channels(), tempMatrix.colptr(i));
+    }
+    else if (opts.Format() == FileType::TGA)
+    {
+      success = stbi_write_tga(files.at(i).c_str(), opts.Width(), opts.Height(),
+          opts.Channels(), tempMatrix.colptr(i));
+    }
+    else if (opts.Format() == FileType::JPG)
+    {
+      success = stbi_write_jpg(files.at(i).c_str(), opts.Width(), opts.Height(),
+          opts.Channels(), tempMatrix.colptr(i), opts.Quality());
+    }
+
+    if (!success)
+    {
+      std::stringstream oss;
+      oss << "Save(): error saving image to '" << files.at(i) << "'.";
+      return HandleError(oss, opts);
+    }
+  }
 
-} //namespace data
-} //namespace mlpack
+  return success;
+}
 
-// Include implementation of Save() for images.
-#include "save_image_impl.hpp"
+} // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/data/save_impl.hpp

@@ -15,164 +15,109 @@
 
 // In case it hasn't already been included.
 #include "save.hpp"
-#include "extension.hpp"
 
 namespace mlpack {
-namespace data {
-
-template<typename eT>
-bool Save(const std::string& filename,
-          const arma::Col<eT>& vec,
-          const bool fatal,
-          FileType inputSaveType)
-{
-  // Don't transpose: one observation per line (for CSVs at least).
-  return Save(filename, vec, fatal, false, inputSaveType);
-}
-
-template<typename eT>
-bool Save(const std::string& filename,
-          const arma::Row<eT>& rowvec,
-          const bool fatal,
-          FileType inputSaveType)
-{
-  return Save(filename, rowvec, fatal, true, inputSaveType);
-}
-
-// Save a Sparse Matrix
-template<typename eT>
-bool Save(const std::string& filename,
-          const arma::SpMat<eT>& matrix,
-          const bool fatal,
-          bool transpose)
-{
-  MatrixOptions opts;
-  opts.Fatal() = fatal;
-  opts.NoTranspose() = !transpose;
-
-  return Save(filename, matrix, opts);
-}
-
-template<typename eT>
-bool Save(const std::string& filename,
-          const arma::Mat<eT>& matrix,
-          const bool fatal,
-          bool transpose,
-          FileType inputSaveType)
-{
-  MatrixOptions opts;
-  opts.Fatal() = fatal;
-  opts.NoTranspose() = !transpose;
-  opts.Format() = inputSaveType;
-
-  return Save(filename, matrix, opts);
-}
 
 template<typename MatType, typename DataOptionsType>
 bool Save(const std::string& filename,
           const MatType& matrix,
           const DataOptionsType& opts,
-          std::enable_if_t<IsArma<MatType>::value ||
-              IsSparseMat<MatType>::value>*)
+          const typename std::enable_if_t<
+              IsDataOptions<DataOptionsType>::value>*)
 {
   //! just use default copy ctor with = operator and make a copy.
   DataOptionsType copyOpts(opts);
   return Save(filename, matrix, copyOpts);
 }
 
-/*
- * Add this SFINAE in here because the compiler is so stupid that it is not
- * able to distinguish between these two:
- *
- *  data::Save(filename, "model", *output);
- *
- *  and 
- *
- *  data::Save(filename, matrix, opts);
- *  
- * The second SFINAE is added because the compiler is bot able to see the
- * difference between:
- *
- *  data::Save(filename, Row/Col, fatal);
- *
- *  and 
- *
- *  data::Save(filename, Row/Col, Opts);
- *
- * This SFINAE is temporary and must be removed after the integration of stage 3 or
- * when the compiler becomes more intelligent.
- */
-template<typename MatType, typename DataOptionsType>
+template<typename ObjectType, typename DataOptionsType>
 bool Save(const std::string& filename,
-          const MatType& matrix,
+          const ObjectType& matrix,
           DataOptionsType& opts,
-          std::enable_if_t<IsArma<MatType>::value ||
-              IsSparseMat<MatType>::value>*,
-          std::enable_if_t<!std::is_same_v<DataOptionsType, bool>>*)
+          const typename std::enable_if_t<
+              IsDataOptions<DataOptionsType>::value>*)
 {
   Timer::Start("saving_data");
-
-  bool success = DetectFileType<MatType>(filename, opts, false);
+  static_assert(!IsArma<ObjectType>::value || !IsSparseMat<ObjectType>::value
+      || !HasSerialize<ObjectType>::value, "mlpack can save Armadillo"
+      " matrices or a serialized mlpack model only; please use a known type.");
+  const bool isMatrixType = IsArma<ObjectType>::value ||
+      IsSparseMat<ObjectType>::value;
+  const bool isSerializable = HasSerialize<ObjectType>::value;
+  const bool isSparseMatrixType = IsSparseMat<ObjectType>::value;
+
+  bool success = DetectFileType<ObjectType>(filename, opts, false);
   if (!success)
   {
     Timer::Stop("saving_data");
     return false;
   }
 
+  const bool isImageFormat = (opts.Format() == FileType::PNG ||
+      opts.Format() == FileType::JPG || opts.Format() == FileType::PNM ||
+      opts.Format() == FileType::BMP || opts.Format() == FileType::GIF ||
+      opts.Format() == FileType::PSD || opts.Format() == FileType::TGA ||
+      opts.Format() == FileType::PIC || opts.Format() == FileType::ImageType);
+
   std::fstream stream;
-  success = OpenFile(filename, opts, false, stream);
-  if (!success)
+  if (!isImageFormat)
   {
-    Timer::Stop("saving_data");
-    return false;
+    success = OpenFile(filename, opts, false, stream);
+    if (!success)
+    {
+      Timer::Stop("saving_data");
+      return false;
+    }
   }
 
   // Try to save the file.
   Log::Info << "Saving " << opts.FileTypeToString() << " to '" << filename
       << "'." << std::endl;
-  if constexpr (IsArma<MatType>::value || IsSparseMat<MatType>::value)
+  if constexpr (isMatrixType)
   {
-    TextOptions txtOpts(std::move(opts));
-    if constexpr (IsSparseMat<MatType>::value)
-    {
-      success = SaveSparse(matrix, txtOpts, filename, stream);
-    }
-    else if constexpr (IsCol<MatType>::value)
-    {
-      opts.NoTranspose() = true;
-      success = SaveDense(matrix, txtOpts, filename, stream);
-    }
-    else if constexpr (IsRow<MatType>::value)
+    if (isImageFormat)
     {
-      opts.NoTranspose() = false;
-      success = SaveDense(matrix, txtOpts, filename, stream);
+      if constexpr (isSparseMatrixType)
+      {
+        arma::Mat<typename ObjectType::elem_type> tmp =
+            arma::conv_to<arma::Mat<
+            typename ObjectType::elem_type>>::from(matrix);
+        ImageOptions imgOpts(std::move(opts));
+        std::vector<std::string> files;
+        files.push_back(filename);
+        success = SaveImage(files, tmp, imgOpts);
+        opts = std::move(imgOpts);
+      }
+      else
+      {
+        ImageOptions imgOpts(std::move(opts));
+        std::vector<std::string> files;
+        files.push_back(filename);
+        success = SaveImage(files, matrix, imgOpts);
+        opts = std::move(imgOpts);
+      }
     }
-    else if constexpr (IsDense<MatType>::value)
+    else
     {
-      success = SaveDense(matrix, txtOpts, filename, stream);
+      success = SaveNumeric(filename, matrix, stream, opts);
     }
-    opts = std::move(txtOpts);
+  }
+  else if constexpr (isSerializable)
+  {
+    success = SaveModel(matrix, opts, stream);
   }
   else
   {
-    if (opts.Fatal())
-      Log::Fatal << "DataOptionsType is unknown!  Please use a known type or "
-          << "or provide specific overloads." << std::endl;
-    else
-      Log::Warn << "DataOptionsType is unknown!  Please use a known type or "
-          << "or provide specific overloads." << std::endl;
-
-    return false;
+    return HandleError("DataOptionsType is unknown!  Please use a known type "
+        "or provide specific overloads.", opts);
   }
 
   if (!success)
   {
     Timer::Stop("saving_data");
-    if (opts.Fatal())
-      Log::Fatal << "Save to '" << filename << "' failed." << std::endl;
-    else
-      Log::Warn << "Save to '" << filename << "' failed." << std::endl;
-    return false;
+    std::stringstream oss;
+    oss << "Save to '" << filename << "' failed.";
+    return HandleError(oss, opts);
   }
 
   Timer::Stop("saving_data");
@@ -180,136 +125,6 @@ bool Save(const std::string& filename,
   return success;
 }
 
-template<typename eT>
-bool SaveDense(const arma::Mat<eT>& matrix,
-               TextOptions& opts,
-               const std::string& filename,
-               std::fstream& stream)
-{
-  bool success = false;
-  arma::Mat<eT> tmp;
-  // Transpose the matrix.
-  if (!opts.NoTranspose())
-  {
-    tmp = trans(matrix);
-    success = SaveMatrix(tmp, opts, filename, stream);
-  }
-  else
-    success = SaveMatrix(matrix, opts, filename, stream);
-
-  return success;
-}
-
-// Save a Sparse Matrix
-template<typename eT>
-bool SaveSparse(const arma::SpMat<eT>& matrix,
-                TextOptions& opts,
-                const std::string& filename,
-                std::fstream& stream)
-{
-  bool success = false;
-  arma::SpMat<eT> tmp;
-
-  // Transpose the matrix.
-  if (!opts.NoTranspose())
-  {
-    arma::SpMat<eT> tmp = trans(matrix);
-    success = SaveMatrix(tmp, opts, filename, stream);
-  }
-  else
-    success = SaveMatrix(matrix, opts, filename, stream);
-
-  return success;
-}
-
-//! Save a model to file.
-template<typename T>
-bool Save(const std::string& filename,
-          const std::string& name,
-          T& t,
-          const bool fatal,
-          format f,
-          std::enable_if_t<HasSerialize<T>::value>*)
-{
-  if (f == format::autodetect)
-  {
-    std::string extension = Extension(filename);
-
-    if (extension == "xml")
-      f = format::xml;
-    else if (extension == "bin")
-      f = format::binary;
-    else if (extension == "json")
-      f = format::json;
-    else
-    {
-      if (fatal)
-        Log::Fatal << "Unable to detect type of '" << filename << "'; incorrect"
-            << " extension? (allowed: xml/bin/json)" << std::endl;
-      else
-        Log::Warn << "Unable to detect type of '" << filename << "'; save "
-            << "failed.  Incorrect extension? (allowed: xml/bin/json)"
-            << std::endl;
-
-      return false;
-    }
-  }
-
-  // Open the file to save to.
-  std::ofstream ofs;
-#ifdef _WIN32
-  if (f == format::binary) // Open non-text types in binary mode on Windows.
-    ofs.open(filename, std::ofstream::out | std::ofstream::binary);
-  else
-    ofs.open(filename, std::ofstream::out);
-#else
-  ofs.open(filename, std::ofstream::out);
-#endif
-
-  if (!ofs.is_open())
-  {
-    if (fatal)
-      Log::Fatal << "Unable to open file '" << filename << "' to save object '"
-          << name << "'." << std::endl;
-    else
-      Log::Warn << "Unable to open file '" << filename << "' to save object '"
-          << name << "'." << std::endl;
-
-    return false;
-  }
-
-  try
-  {
-    if (f == format::xml)
-    {
-      cereal::XMLOutputArchive ar(ofs);
-      ar(cereal::make_nvp(name.c_str(), t));
-    }
-    else if (f == format::json)
-    {
-      cereal::JSONOutputArchive ar(ofs);
-      ar(cereal::make_nvp(name.c_str(), t));
-    }
-    else if (f == format::binary)
-    {
-      cereal::BinaryOutputArchive ar(ofs);
-      ar(cereal::make_nvp(name.c_str(), t));
-    }
-
-    return true;
-  }
-  catch (cereal::Exception& e)
-  {
-    if (fatal)
-      Log::Fatal << e.what() << std::endl;
-    else
-      Log::Warn << e.what() << std::endl;
-
-    return false;
-  }
-}
-
-} // namespace data
 } // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/data/save_matrix.hpp

@@ -0,0 +1,45 @@
+/**
+ * @file core/data/save_matrix.hpp
+ * @author Ryan Curtin
+ * @author Omar Shrit
+ *
+ * Internal implementation of matrix save function.
+ *
+ * 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_SAVE_MATRIX_HPP
+#define MLPACK_CORE_DATA_SAVE_MATRIX_HPP
+
+namespace mlpack {
+
+template<typename MatType, typename DataOptionsType>
+bool SaveMatrix(const MatType& matrix,
+                const DataOptionsType& opts,
+#ifdef ARMA_USE_HDF5
+                const std::string& filename,
+#else
+                const std::string& /* filename */,
+#endif
+                std::fstream& stream)
+{
+  bool success = false;
+  if (opts.Format() == FileType::HDF5Binary)
+  {
+#ifdef ARMA_USE_HDF5
+    // We can't save with streams for HDF5.
+    success = matrix.save(filename, opts.ArmaFormat());
+#endif
+  }
+  else
+  {
+    success = matrix.save(stream, opts.ArmaFormat());
+  }
+  return success;
+}
+
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/core/data/save_model.hpp

@@ -0,0 +1,61 @@
+/**
+ * @file core/data/save_model.hpp
+ * @author Ryan Curtin
+ * @author Omar Shrit
+ *
+ * Internal implementation of model save function.
+ *
+ * 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_SAVE_MODEL_HPP
+#define MLPACK_CORE_DATA_SAVE_MODEL_HPP
+
+#include <cereal/archives/xml.hpp>
+#include <cereal/archives/binary.hpp>
+#include <cereal/archives/json.hpp>
+
+#include "text_options.hpp"
+
+namespace mlpack {
+
+template<typename Object>
+bool SaveModel(Object& objectToSerialize,
+               const DataOptionsBase<PlainDataOptions>& opts,
+               std::fstream& stream)
+{
+  try
+  {
+    if (opts.Format() == FileType::XML)
+    {
+      cereal::XMLOutputArchive ar(stream);
+      ar(cereal::make_nvp("model", objectToSerialize));
+    }
+    else if (opts.Format() == FileType::JSON)
+    {
+      cereal::JSONOutputArchive ar(stream);
+      ar(cereal::make_nvp("model", objectToSerialize));
+    }
+    else if (opts.Format() == FileType::BIN)
+    {
+      cereal::BinaryOutputArchive ar(stream);
+      ar(cereal::make_nvp("model", objectToSerialize));
+    }
+    return true;
+  }
+  catch (cereal::Exception& e)
+  {
+    if (opts.Fatal())
+      Log::Fatal << e.what() << std::endl;
+    else
+      Log::Warn << e.what() << std::endl;
+
+    return false;
+  }
+}
+
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/core/data/save_numeric.hpp

@@ -0,0 +1,60 @@
+/**
+ * @file core/data/save_numeric.hpp
+ * @author Ryan Curtin
+ * @author Omar Shrit
+ *
+ * Internal implementation of numeric save function.
+ *
+ * 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_SAVE_NUMERIC_HPP
+#define MLPACK_CORE_DATA_SAVE_NUMERIC_HPP
+
+#include "text_options.hpp"
+#include "save_sparse.hpp"
+#include "save_dense.hpp"
+
+namespace mlpack {
+
+template<typename ObjectType, typename DataOptionsType>
+bool SaveNumeric(const std::string& filename,
+                 const ObjectType& matrix,
+                 std::fstream& stream,
+                 DataOptionsBase<DataOptionsType>& opts)
+{
+  bool success = false;
+
+  TextOptions txtOpts(std::move(opts));
+  if constexpr (IsSparseMat<ObjectType>::value)
+  {
+    success = SaveSparse(matrix, txtOpts, filename, stream);
+  }
+  else if constexpr (IsCol<ObjectType>::value)
+  {
+    const bool oldNoTranspose = txtOpts.NoTranspose();
+    txtOpts.NoTranspose() = true; // Force no transpose for a column.
+    success = SaveDense(matrix, txtOpts, filename, stream);
+    txtOpts.NoTranspose() = oldNoTranspose;
+  }
+  else if constexpr (IsRow<ObjectType>::value)
+  {
+    const bool oldNoTranspose = txtOpts.NoTranspose();
+    txtOpts.NoTranspose() = false; // Force transpose for a row.
+    success = SaveDense(matrix, txtOpts, filename, stream);
+    txtOpts.NoTranspose() = oldNoTranspose;
+  }
+  else if constexpr (IsDense<ObjectType>::value)
+  {
+    success = SaveDense(matrix, txtOpts, filename, stream);
+  }
+  static_cast<DataOptionsType&>(opts) = std::move(txtOpts);
+
+  return success;
+}
+
+} // namespace mlpack
+
+#endif