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

mlpack/include/mlpack/core/data/utilities.hpp

@@ -1,158 +1,158 @@
-/**
- * @file core/data/utilities.hpp
- * @author Ryan Curtin
- * @author Omar Shrit
- * @author Gopi Tatiraju
- *
- * Utilities functions that can be used during loading and saving the data..
- *
- * 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_UTILITIES_HPP
-#define MLPACK_CORE_DATA_UTILITIES_HPP
-
-#include <mlpack/prereqs.hpp>
-
-#include "detect_file_type.hpp"
-
-namespace mlpack {
-namespace data {
-
-namespace details {
-
-template<typename Tokenizer>
-std::vector<std::string> ToTokens(Tokenizer& lineTok)
-{
-  std::vector<std::string> tokens;
-  std::transform(std::begin(lineTok), std::end(lineTok),
-                 std::back_inserter(tokens),
-                 [&tokens](std::string const &str)
-  {
-    std::string trimmedToken(str);
-    Trim(trimmedToken);
-    return std::move(trimmedToken);
-  });
-
-  return tokens;
-}
-
-inline
-void TransposeTokens(std::vector<std::vector<std::string>> const &input,
-                     std::vector<std::string>& output,
-                     size_t index)
-{
-  output.clear();
-  for (size_t i = 0; i != input.size(); ++i)
-  {
-    output.emplace_back(input[i][index]);
-  }
-}
-} // namespace details
-
-template<typename DataOptionsType>
-bool OpenFile(const std::string& filename,
-              DataOptionsType& opts,
-              bool isLoading,
-              std::fstream& stream)
-{
-  if (isLoading)
-  {
-#ifdef  _WIN32 // Always open in binary mode on Windows.
-    stream.open(filename.c_str(), std::fstream::in
-        | std::fstream::binary);
-#else
-    stream.open(filename.c_str(), std::fstream::in);
-#endif
-  }
-  // Add here and else if for ModelOptions in a couple of stages.
-  else
-  {
-#ifdef  _WIN32 // Always open in binary mode on Windows.
-    stream.open(filename.c_str(), std::fstream::out
-        | std::fstream::binary);
-#else
-    stream.open(filename.c_str(), std::fstream::out);
-#endif
-  }
-
-  if (!stream.is_open())
-  {
-    if (opts.Fatal() && isLoading)
-      Log::Fatal << "Cannot open file '" << filename << "' for loading.  "
-          << "Please check if the file exists." << std::endl;
-
-    else if (!opts.Fatal() && isLoading)
-      Log::Warn << "Cannot open file '" << filename << "' for loading.  "
-          << "Please check if the file exists." << std::endl;
-
-    else if (opts.Fatal() && !isLoading)
-      Log::Fatal << "Cannot open file '" << filename << "' for saving.  "
-          << "Please check if you have permissions for writing." << std::endl;
-
-    else if (!opts.Fatal() && !isLoading)
-      Log::Warn << "Cannot open file '" << filename << "' for saving.  "
-          << "Please check if you have permissions for writing." << std::endl;
-
-    return false;
-  }
-  return true;
-}
-
-template<typename MatType, typename DataOptionsType>
-bool DetectFileType(const std::string& filename,
-                    DataOptionsType& opts,
-                    bool isLoading,
-                    std::fstream* stream = nullptr)
-{
-  // Add if for ModelOptions in a couple of stages
-  if (opts.Format() == FileType::AutoDetect)
-  {
-    if (isLoading)
-      // Attempt to auto-detect the type from the given file.
-      opts.Format() = AutoDetect(*stream, filename);
-    else
-      DetectFromExtension<MatType>(filename, opts);
-    // Provide error if we don't know the type.
-    if (opts.Format() == FileType::FileTypeUnknown)
-    {
-      if (opts.Fatal())
-        Log::Fatal << "Unable to detect type of '" << filename << "'; "
-            << "Incorrect extension?" << std::endl;
-      else
-        Log::Warn << "Unable to detect type of '" << filename << "'; "
-            << "Incorrect extension?" << std::endl;
-
-      return false;
-    }
-  }
-  return true;
-}
-
-template<typename MatType, typename DataOptionsType>
-bool SaveMatrix(const MatType& matrix,
-                const DataOptionsType& opts,
-                const std::string& filename,
-                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, ToArmaFileType(opts.Format()))
-#endif
-  }
-  else
-  {
-    success = matrix.save(stream, ToArmaFileType(opts.Format()));
-  }
-  return success;
-}
-
-} //namespace data
-} //namespace mlpack
-
-#endif
+/**
+ * @file core/data/utilities.hpp
+ * @author Ryan Curtin
+ * @author Omar Shrit
+ * @author Gopi Tatiraju
+ *
+ * Utilities functions that can be used during loading and saving the data..
+ *
+ * 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_UTILITIES_HPP
+#define MLPACK_CORE_DATA_UTILITIES_HPP
+
+#include <mlpack/prereqs.hpp>
+
+#include "detect_file_type.hpp"
+
+namespace mlpack {
+namespace data {
+
+namespace details {
+
+template<typename Tokenizer>
+std::vector<std::string> ToTokens(Tokenizer& lineTok)
+{
+  std::vector<std::string> tokens;
+  std::transform(std::begin(lineTok), std::end(lineTok),
+                 std::back_inserter(tokens),
+                 [&tokens](std::string const &str)
+  {
+    std::string trimmedToken(str);
+    Trim(trimmedToken);
+    return std::move(trimmedToken);
+  });
+
+  return tokens;
+}
+
+inline
+void TransposeTokens(std::vector<std::vector<std::string>> const &input,
+                     std::vector<std::string>& output,
+                     size_t index)
+{
+  output.clear();
+  for (size_t i = 0; i != input.size(); ++i)
+  {
+    output.emplace_back(input[i][index]);
+  }
+}
+} // namespace details
+
+template<typename DataOptionsType>
+bool OpenFile(const std::string& filename,
+              DataOptionsType& opts,
+              bool isLoading,
+              std::fstream& stream)
+{
+  if (isLoading)
+  {
+#ifdef  _WIN32 // Always open in binary mode on Windows.
+    stream.open(filename.c_str(), std::fstream::in
+        | std::fstream::binary);
+#else
+    stream.open(filename.c_str(), std::fstream::in);
+#endif
+  }
+  // Add here and else if for ModelOptions in a couple of stages.
+  else
+  {
+#ifdef  _WIN32 // Always open in binary mode on Windows.
+    stream.open(filename.c_str(), std::fstream::out
+        | std::fstream::binary);
+#else
+    stream.open(filename.c_str(), std::fstream::out);
+#endif
+  }
+
+  if (!stream.is_open())
+  {
+    if (opts.Fatal() && isLoading)
+      Log::Fatal << "Cannot open file '" << filename << "' for loading.  "
+          << "Please check if the file exists." << std::endl;
+
+    else if (!opts.Fatal() && isLoading)
+      Log::Warn << "Cannot open file '" << filename << "' for loading.  "
+          << "Please check if the file exists." << std::endl;
+
+    else if (opts.Fatal() && !isLoading)
+      Log::Fatal << "Cannot open file '" << filename << "' for saving.  "
+          << "Please check if you have permissions for writing." << std::endl;
+
+    else if (!opts.Fatal() && !isLoading)
+      Log::Warn << "Cannot open file '" << filename << "' for saving.  "
+          << "Please check if you have permissions for writing." << std::endl;
+
+    return false;
+  }
+  return true;
+}
+
+template<typename MatType, typename DataOptionsType>
+bool DetectFileType(const std::string& filename,
+                    DataOptionsType& opts,
+                    bool isLoading,
+                    std::fstream* stream = nullptr)
+{
+  // Add if for ModelOptions in a couple of stages
+  if (opts.Format() == FileType::AutoDetect)
+  {
+    if (isLoading)
+      // Attempt to auto-detect the type from the given file.
+      opts.Format() = AutoDetect(*stream, filename);
+    else
+      DetectFromExtension<MatType>(filename, opts);
+    // Provide error if we don't know the type.
+    if (opts.Format() == FileType::FileTypeUnknown)
+    {
+      if (opts.Fatal())
+        Log::Fatal << "Unable to detect type of '" << filename << "'; "
+            << "Incorrect extension?" << std::endl;
+      else
+        Log::Warn << "Unable to detect type of '" << filename << "'; "
+            << "Incorrect extension?" << std::endl;
+
+      return false;
+    }
+  }
+  return true;
+}
+
+template<typename MatType, typename DataOptionsType>
+bool SaveMatrix(const MatType& matrix,
+                const DataOptionsType& opts,
+                const std::string& filename,
+                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, ToArmaFileType(opts.Format()));
+#endif
+  }
+  else
+  {
+    success = matrix.save(stream, ToArmaFileType(opts.Format()));
+  }
+  return success;
+}
+
+} //namespace data
+} //namespace mlpack
+
+#endif

mlpack/include/mlpack/core/math/ccov.hpp

@@ -15,6 +15,7 @@
 #define MLPACK_CORE_MATH_CCOV_HPP
 
 #include <mlpack/prereqs.hpp>
+#include <mlpack/core/math/make_alias.hpp>
 
 namespace mlpack {
 

mlpack/include/mlpack/core/math/ccov_impl.hpp

@@ -31,11 +31,10 @@ inline arma::Mat<eT> ColumnCovariance(const arma::Mat<eT>& x,
 
   if (x.n_elem > 0)
   {
-    const arma::Mat<eT>& xAlias = (x.n_cols == 1) ?
-        arma::Mat<eT>(const_cast<eT*>(x.memptr()), x.n_cols, x.n_rows, false,
-            false) :
-        arma::Mat<eT>(const_cast<eT*>(x.memptr()), x.n_rows, x.n_cols, false,
-            false);
+    const arma::Mat<eT> xAlias;
+    MakeAlias(const_cast<arma::Mat<eT>&>(xAlias), x,
+        (x.n_cols == 1) ? x.n_cols : x.n_rows,
+        (x.n_cols == 1) ? x.n_rows : x.n_cols, 0, false);
 
     const size_t n = xAlias.n_cols;
     const eT normVal = (normType == 0) ? ((n > 1) ? eT(n - 1) : eT(1)) : eT(n);

mlpack/include/mlpack/core/math/make_alias.hpp

@@ -26,7 +26,9 @@ void MakeAlias(OutVecType& v,
                const size_t offset = 0,
                const bool strict = true,
                const typename std::enable_if_t<
-                   IsVector<OutVecType>::value>* = 0)
+                   IsVector<OutVecType>::value &&
+                   IsArma<InVecType>::value &&
+                   IsArma<OutVecType>::value>* = 0)
 {
   // We use placement new to reinitialize the object, since the copy and move
   // assignment operators in Armadillo will end up copying memory instead of
@@ -49,7 +51,9 @@ void MakeAlias(OutMatType& m,
                const size_t offset = 0,
                const bool strict = true,
                const typename std::enable_if_t<
-                   IsMatrix<OutMatType>::value>* = 0)
+                   IsMatrix<OutMatType>::value &&
+                   IsArma<InMatType>::value &&
+                   IsArma<OutMatType>::value>* = 0)
 {
   // We use placement new to reinitialize the object, since the copy and move
   // assignment operators in Armadillo will end up copying memory instead of
@@ -72,7 +76,10 @@ void MakeAlias(OutCubeType& c,
                const size_t numSlices,
                const size_t offset = 0,
                const bool strict = true,
-               const typename std::enable_if_t<IsCube<OutCubeType>::value>* = 0)
+               const typename std::enable_if_t<
+                   IsCube<OutCubeType>::value &&
+                   IsArma<InCubeType>::value &&
+                   IsArma<OutCubeType>::value>* = 0)
 {
   // We use placement new to reinitialize the object, since the copy and move
   // assignment operators in Armadillo will end up copying memory instead of
@@ -119,6 +126,94 @@ void ClearAlias(arma::SpMat<ElemType>& /* mat */)
   // We cannot make aliases of sparse matrices, so, nothing to do.
 }
 
+#if defined(MLPACK_HAS_COOT)
+
+/**
+ * Reconstruct `v` as an alias around the memory `newMem`, with size `numRows` x
+ * `numCols`.
+ */
+template<typename InVecType, typename OutVecType>
+void MakeAlias(OutVecType& v,
+               const InVecType& oldVec,
+               const size_t numElems,
+               const size_t offset = 0,
+               const bool strict = true,
+               const typename std::enable_if_t<
+                   IsVector<OutVecType>::value &&
+                   IsCoot<InVecType>::value &&
+                   IsCoot<OutVecType>::value>* = 0)
+{
+  // We use placement new to reinitialize the object, since the copy and move
+  // assignment operators in Bandicoot will end up copying memory instead of
+  // making an alias.
+  coot::dev_mem_t<InVecType::elem_type> newMem = oldVec.get_dev_mem() + offset;
+  v.~OutVecType();
+  new (&v) OutVecType(newMem, numElems, false, strict);
+}
+
+/**
+ * Reconstruct `m` as an alias around the memory `newMem`, with size `numRows` x
+ * `numCols`.
+ */
+template<typename InMatType, typename OutMatType>
+void MakeAlias(OutMatType& m,
+               const InMatType& oldMat,
+               const size_t numRows,
+               const size_t numCols,
+               const size_t offset = 0,
+               const bool strict = true,
+               const typename std::enable_if_t<
+                   IsMatrix<OutMatType>::value &&
+                   IsCoot<InMatType>::value &&
+                   IsCoot<OutMatType>::value>* = 0)
+{
+  // We use placement new to reinitialize the object, since the copy and move
+  // assignment operators in Bandicoot will end up copying memory instead of
+  // making an alias.
+  coot::dev_mem_t<InMatType::elem_type> newMem = oldMat.get_dev_mem() + offset;
+  m.~OutMatType();
+  new (&m) OutMatType(newMem, numRows, numCols);
+}
+
+/**
+ * Reconstruct `c` as an alias around the memory` newMem`, with size `numRows` x
+ * `numCols` x `numSlices`.
+ */
+template<typename InCubeType, typename OutCubeType>
+void MakeAlias(OutCubeType& c,
+               const InCubeType& oldCube,
+               const size_t numRows,
+               const size_t numCols,
+               const size_t numSlices,
+               const size_t offset = 0,
+               const bool strict = true,
+               const typename std::enable_if_t<
+                   IsCube<OutCubeType>::value &&
+                   IsCoot<InCubeType>::value &&
+                   IsCoot<OutCubeType>::value>* = 0)
+{
+  // We use placement new to reinitialize the object, since the copy and move
+  // assignment operators in Bandicoot will end up copying memory instead of
+  // making an alias.
+  coot::dev_mem_t<InCubeType::elem_type> newMem =
+      oldCube.get_dev_mem() + offset;
+  c.~OutCubeType();
+  new (&c) OutCubeType(newMem, numRows, numCols, numSlices);
+}
+
+/**
+ * Clear an alias so that no data is overwritten.  This resets the matrix if it
+ * is an alias (and does nothing otherwise).
+ */
+template<typename ElemType>
+void ClearAlias(coot::Mat<ElemType>& mat)
+{
+  if (mat.mem_state >= 1)
+    mat.reset();
+}
+
+#endif // defined(MLPACK_HAS_COOT)
+
 } // namespace mlpack
 
 #endif

mlpack/include/mlpack/core/util/arma_traits.hpp

@@ -239,6 +239,16 @@ struct GetCubeType<arma::Mat<eT>>
   using type = arma::Cube<eT>;
 };
 
+#if defined(MLPACK_HAS_COOT)
+
+template<typename eT>
+struct GetCubeType<coot::Mat<eT>>
+{
+  using type = coot::Cube<eT>;
+};
+
+#endif
+
 // Get the sparse matrix type corresponding to a given MatType.
 
 template<typename MatType>
@@ -346,18 +356,25 @@ struct IsDense<arma::Mat<eT>>
   constexpr static bool value = true;
 };
 
+// Get whether or not the given type is any non-field Armadillo type
+// This includes sparse, dense, and cube types
 template<typename T>
 struct IsArma
 {
-  constexpr static bool value = arma::is_arma_type<T>::value;
+  constexpr static bool value = arma::is_arma_type<T>::value ||
+                                arma::is_arma_cube_type<T>::value ||
+                                arma::is_arma_sparse_type<T>::value;
 };
 
 #if defined(MLPACK_HAS_COOT)
 
+// Get whether or not the given type is any Bandicoot type
+// This includes dense and cube types
 template<typename T>
 struct IsCoot
 {
-  constexpr static bool value = coot::is_coot_type<T>::value;
+  constexpr static bool value = coot::is_coot_type<T>::value ||
+                                coot::is_coot_cube_type<T>::value;
 };
 
 #else

mlpack/include/mlpack/core/util/gitversion.hpp

@@ -1 +1 @@
-return "mlpack git-0480311ab1";
+return "mlpack git-0fdccbfb21";

mlpack/include/mlpack/core/util/sfinae_utility.hpp

@@ -98,6 +98,28 @@ struct MethodFormDetector<Class, MethodForm, 7>
   void operator()(MethodForm<Class, T1, T2, T3, T4, T5, T6, T7>);
 };
 
+template<typename Class, template<typename...> class MethodForm>
+struct MethodFormDetector<Class, MethodForm, 8>
+{
+  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+           class T8>
+  void operator()(MethodForm<Class, T1, T2, T3, T4, T5, T6, T7, T8>);
+};
+template<typename Class, template<typename...> class MethodForm>
+struct MethodFormDetector<Class, MethodForm, 9>
+{
+  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+           class T8, class T9>
+  void operator()(MethodForm<Class, T1, T2, T3, T4, T5, T6, T7, T8, T9>);
+};
+template<typename Class, template<typename...> class MethodForm>
+struct MethodFormDetector<Class, MethodForm, 10>
+{
+  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+           class T8, class T9, class T10>
+  void operator()(MethodForm<Class, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>);
+};
+
 //! Utility struct for checking signatures.
 template<typename U, U> struct SigCheck : std::true_type {};
 
@@ -237,7 +259,7 @@ struct NAME                                                                   \
  * we can check whether the class A has a Train method of the specified form:
  *
  * HAS_METHOD_FORM(Train, HasTrain);
- * static_assert(HasTrain<A, TrainFrom>::value, "value should be true");
+ * static_assert(HasTrain<A, TrainForm>::value, "value should be true");
  *
  * The class generated by this will also return true values if the given class
  * has a method that also has extra parameters.
@@ -246,7 +268,7 @@ struct NAME                                                                   \
  * @param NAME The name of the struct to construct.
  */
 #define HAS_METHOD_FORM(METHOD, NAME) \
-    HAS_METHOD_FORM_BASE(SINGLE_ARG(METHOD), SINGLE_ARG(NAME), 7)
+    HAS_METHOD_FORM_BASE(SINGLE_ARG(METHOD), SINGLE_ARG(NAME), 10)
 
 /**
  * HAS_EXACT_METHOD_FORM generates a template that allows a compile time check

mlpack/include/mlpack/core/util/version.hpp

@@ -18,7 +18,7 @@
 // with higher number than the most recent release.
 #define MLPACK_VERSION_MAJOR 4
 #define MLPACK_VERSION_MINOR 6
-#define MLPACK_VERSION_PATCH 1
+#define MLPACK_VERSION_PATCH 2
 
 // The name of the version (for use by --version).
 namespace mlpack {

mlpack/include/mlpack/methods/ann/dists/bernoulli_distribution_impl.hpp

@@ -40,8 +40,7 @@ BernoulliDistribution<DataType>::BernoulliDistribution(
   }
   else
   {
-    probability = arma::mat(logits.memptr(), logits.n_rows,
-        logits.n_cols, false, false);
+    MakeAlias(probability, logits, logits.n_rows, logits.n_cols);
   }
 }
 

mlpack/include/mlpack/methods/ann/init_rules/network_init.hpp

@@ -48,9 +48,9 @@ class NetworkInitialization
    * @param parameter The network parameter.
    * @param parameterOffset Offset for network paramater, default 0.
    */
-  template <typename eT>
-  void Initialize(const std::vector<Layer<arma::Mat<eT>>*>& network,
-                  arma::Mat<eT>& parameters,
+  template <typename MatType>
+  void Initialize(const std::vector<Layer<MatType>*>& network,
+                  MatType& parameters,
                   size_t parameterOffset = 0)
   {
     // Determine the total number of parameters/weights of the given network.
@@ -71,8 +71,8 @@ class NetworkInitialization
         // Initialize the layer with the specified parameter/weight
         // initialization rule.
         const size_t weight = network[i]->WeightSize();
-        arma::Mat<eT> tmp = arma::Mat<eT>(parameters.memptr() + offset,
-            weight, 1, false, false);
+        MatType tmp;
+        MakeAlias(tmp, parameters, weight, 1, offset, false);
         initializeRule.Initialize(tmp, tmp.n_elem, 1);
 
         // Increase the parameter/weight offset for the next layer.

mlpack/include/mlpack/methods/ann/layer/batch_norm.hpp

@@ -53,6 +53,7 @@ template <typename MatType = arma::mat>
 class BatchNormType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   /**
    * Create the BatchNorm object.
    *
@@ -266,10 +267,10 @@ class BatchNormType : public Layer<MatType>
   MatType runningVariance;
 
   //! Locally-stored normalized input.
-  arma::Cube<typename MatType::elem_type> normalized;
+  CubeType normalized;
 
   //! Locally-stored zero mean input.
-  arma::Cube<typename MatType::elem_type> inputMean;
+  CubeType inputMean;
 }; // class BatchNorm
 
 // Convenience typedefs.