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

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

@@ -21,7 +21,7 @@
 namespace mlpack {
 
 template<typename MatType>
-PReLUType<MatType>::PReLUType(const double userAlpha) :
+PReLU<MatType>::PReLU(const double userAlpha) :
     Layer<MatType>(),
     userAlpha(userAlpha)
 {
@@ -29,8 +29,8 @@ PReLUType<MatType>::PReLUType(const double userAlpha) :
 }
 
 template<typename MatType>
-PReLUType<MatType>::PReLUType(
-    const PReLUType& other) :
+PReLU<MatType>::PReLU(
+    const PReLU& other) :
     Layer<MatType>(other),
     userAlpha(other.userAlpha)
 {
@@ -38,8 +38,8 @@ PReLUType<MatType>::PReLUType(
 }
 
 template<typename MatType>
-PReLUType<MatType>::PReLUType(
-    PReLUType&& other) :
+PReLU<MatType>::PReLU(
+    PReLU&& other) :
     Layer<MatType>(std::move(other)),
     userAlpha(std::move(other.userAlpha))
 {
@@ -47,8 +47,8 @@ PReLUType<MatType>::PReLUType(
 }
 
 template<typename MatType>
-PReLUType<MatType>&
-PReLUType<MatType>::operator=(const PReLUType& other)
+PReLU<MatType>&
+PReLU<MatType>::operator=(const PReLU& other)
 {
   if (&other != this)
   {
@@ -60,8 +60,8 @@ PReLUType<MatType>::operator=(const PReLUType& other)
 }
 
 template<typename MatType>
-PReLUType<MatType>&
-PReLUType<MatType>::operator=(PReLUType&& other)
+PReLU<MatType>&
+PReLU<MatType>::operator=(PReLU&& other)
 {
   if (&other != this)
   {
@@ -73,27 +73,27 @@ PReLUType<MatType>::operator=(PReLUType&& other)
 }
 
 template<typename MatType>
-void PReLUType<MatType>::SetWeights(const MatType& weightsIn)
+void PReLU<MatType>::SetWeights(const MatType& weightsIn)
 {
   MakeAlias(alpha, weightsIn, 1, 1);
 }
 
 template<typename MatType>
-void PReLUType<MatType>::CustomInitialize(
+void PReLU<MatType>::CustomInitialize(
     MatType& W,
     const size_t elements)
 {
   if (elements != 1)
   {
-    throw std::invalid_argument("PReLUType::CustomInitialize(): wrong "
+    throw std::invalid_argument("PReLU::CustomInitialize(): wrong "
         "elements size!");
   }
 
-  W(0) = userAlpha;
+  W(0) = ElemType(userAlpha);
 }
 
 template<typename MatType>
-void PReLUType<MatType>::Forward(
+void PReLU<MatType>::Forward(
     const MatType& input, MatType& output)
 {
   output = input;
@@ -103,14 +103,14 @@ void PReLUType<MatType>::Forward(
 }
 
 template<typename MatType>
-void PReLUType<MatType>::Backward(
+void PReLU<MatType>::Backward(
     const MatType& input,
     const MatType& /* output */,
     const MatType& gy,
     MatType& g)
 {
   MatType derivative;
-  derivative.set_size(arma::size(input));
+  derivative.set_size(size(input));
   #pragma omp for
   for (size_t i = 0; i < input.n_elem; ++i)
     derivative(i) = (input(i) >= 0) ? 1 : alpha(0);
@@ -119,7 +119,7 @@ void PReLUType<MatType>::Backward(
 }
 
 template<typename MatType>
-void PReLUType<MatType>::Gradient(
+void PReLU<MatType>::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
@@ -131,7 +131,7 @@ void PReLUType<MatType>::Gradient(
 
 template<typename MatType>
 template<typename Archive>
-void PReLUType<MatType>::serialize(
+void PReLU<MatType>::serialize(
     Archive& ar,
     const uint32_t /* version */)
 {

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

@@ -21,7 +21,7 @@
 namespace mlpack {
 
 /**
- * Implementation of the Radial Basis Function layer. The RBFType class, when
+ * Implementation of the Radial Basis Function layer. The RBF class, when
  * used with a non-linear activation function, acts as a Radial Basis Function
  * which can be used with a feed-forward neural network.
  *
@@ -45,11 +45,14 @@ template <
     typename MatType = arma::mat,
     typename Activation = GaussianFunction
 >
-class RBFType : public Layer<MatType>
+class RBF : public Layer<MatType>
 {
  public:
-  //! Create the RBFType object.
-  RBFType();
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
+  // Create the RBF object.
+  RBF();
 
   /**
    * Create the Radial Basis Function layer object using the specified
@@ -59,24 +62,36 @@ class RBFType : public Layer<MatType>
    * @param centres The centres calculated using k-means of data.
    * @param betas The beta value to be used with centres.
    */
-  RBFType(const size_t outSize,
-          MatType& centres,
-          double betas = 0);
+  RBF(const size_t outSize,
+      const MatType& centres,
+      double betas = 0);
 
-  //! Clone the LinearType object. This handles polymorphism correctly.
-  RBFType* Clone() const { return new RBFType(*this); }
+  /**
+   * Create the Radial Basis Function layer object using the specified
+   * parameters.
+   *
+   * @param outSize The number of output units.
+   * @param centres The centres calculated using k-means of data.
+   * @param betas The beta value to be used with centres.
+   */
+  RBF(const size_t outSize,
+      MatType&& centres,
+      double betas = 0);
+
+  // Clone the RBF object. This handles polymorphism correctly.
+  RBF* Clone() const { return new RBF(*this); }
 
   // Virtual destructor.
-  virtual ~RBFType() { }
+  virtual ~RBF() { }
 
-  //! Copy the given RBFType layer.
-  RBFType(const RBFType& other);
-  //! Take ownership of the given RBFType layer.
-  RBFType(RBFType&& other);
-  //! Copy the given RBFType layer.
-  RBFType& operator=(const RBFType& other);
-  //! Take ownership of the given RBFType layer.
-  RBFType& operator=(RBFType&& other);
+  // Copy the given RBF layer.
+  RBF(const RBF& other);
+  // Take ownership of the given RBF layer.
+  RBF(RBF&& other);
+  // Copy the given RBF layer.
+  RBF& operator=(const RBF& other);
+  // Take ownership of the given RBF layer.
+  RBF& operator=(RBF&& other);
 
   /**
    * Ordinary feed forward pass of the radial basis function.
@@ -94,11 +109,11 @@ class RBFType : public Layer<MatType>
                 const MatType& /* gy */,
                 MatType& /* g */);
 
-  //! Compute the output dimensions of the layer given `InputDimensions()`.  The
-  //! RBFType layer flattens the input.
+  // Compute the output dimensions of the layer given `InputDimensions()`.  The
+  // RBF layer flattens the input.
   void ComputeOutputDimensions();
 
-  //! Get the size of the weights.
+  // Get the size of the weights.
   size_t WeightSize() const { return 0; }
 
   /**
@@ -108,20 +123,18 @@ class RBFType : public Layer<MatType>
   void serialize(Archive& ar, const uint32_t /* version */);
 
  private:
-  //! Locally-stored number of output units.
+  // Locally-stored number of output units.
   size_t outSize;
 
-  //! Locally-stored the betas values.
+  // Locally-stored the betas values.
   double betas;
 
-  //! Locally-stored the learnable centre of the shape.
+  // Locally-stored the learnable centre of the shape.
   MatType centres;
 
-  //! Locally-stored the output distances of the shape.
+  // Locally-stored the output distances of the shape.
   MatType distances;
-}; // class RBFType
-
-using RBF = RBFType<arma::mat>;
+}; // class RBF
 
 } // namespace mlpack
 

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

@@ -16,7 +16,7 @@
 namespace mlpack {
 
 template<typename MatType, typename Activation>
-RBFType<MatType, Activation>::RBFType() :
+RBF<MatType, Activation>::RBF() :
     Layer<MatType>(),
     outSize(0),
     betas(0)
@@ -25,9 +25,9 @@ RBFType<MatType, Activation>::RBFType() :
 }
 
 template<typename MatType, typename Activation>
-RBFType<MatType, Activation>::RBFType(
+RBF<MatType, Activation>::RBF(
     const size_t outSize,
-    MatType& centres,
+    const MatType& centres,
     double betas) :
     Layer<MatType>(),
     outSize(outSize),
@@ -41,7 +41,32 @@ RBFType<MatType, Activation>::RBFType(
     {
       double maxDis = 0;
       MatType temp = centres.each_col() - centres.col(i);
-      maxDis = max(pow(sum(pow((temp), 2), 0), 0.5).t());
+      maxDis = max(sqrt(sum(square(temp), 0)).t());
+      if (maxDis > sigmas)
+        sigmas = maxDis;
+    }
+    this->betas = std::pow(2 * outSize, 0.5) / sigmas;
+  }
+}
+
+template<typename MatType, typename Activation>
+RBF<MatType, Activation>::RBF(
+    const size_t outSize,
+    MatType&& centres,
+    double betas) :
+    Layer<MatType>(),
+    outSize(outSize),
+    betas(betas),
+    centres(std::move(centres))
+{
+  double sigmas = 0;
+  if (betas == 0)
+  {
+    for (size_t i = 0; i < centres.n_cols; i++)
+    {
+      double maxDis = 0;
+      MatType temp = centres.each_col() - centres.col(i);
+      maxDis = max(sqrt(sum(square(temp), 0)).t());
       if (maxDis > sigmas)
         sigmas = maxDis;
     }
@@ -51,7 +76,7 @@ RBFType<MatType, Activation>::RBFType(
 
 template<typename MatType,
          typename Activation>
-RBFType<MatType, Activation>::RBFType(const RBFType& other) :
+RBF<MatType, Activation>::RBF(const RBF& other) :
     Layer<MatType>(other),
     outSize(other.outSize),
     betas(other.betas),
@@ -62,7 +87,7 @@ RBFType<MatType, Activation>::RBFType(const RBFType& other) :
 
 template<typename MatType,
          typename Activation>
-RBFType<MatType, Activation>::RBFType(RBFType&& other) :
+RBF<MatType, Activation>::RBF(RBF&& other) :
     Layer<MatType>(other),
     outSize(other.outSize),
     betas(other.betas),
@@ -72,8 +97,8 @@ RBFType<MatType, Activation>::RBFType(RBFType&& other) :
 }
 
 template<typename MatType, typename Activation>
-RBFType<MatType, Activation>&
-RBFType<MatType, Activation>::operator=(const RBFType& other)
+RBF<MatType, Activation>&
+RBF<MatType, Activation>::operator=(const RBF& other)
 {
   if (&other != this)
   {
@@ -87,8 +112,8 @@ RBFType<MatType, Activation>::operator=(const RBFType& other)
 }
 
 template<typename MatType, typename Activation>
-RBFType<MatType, Activation>&
-RBFType<MatType, Activation>::operator=(RBFType&& other)
+RBF<MatType, Activation>&
+RBF<MatType, Activation>::operator=(RBF&& other)
 {
   if (&other != this)
   {
@@ -102,14 +127,14 @@ RBFType<MatType, Activation>::operator=(RBFType&& other)
 }
 
 template<typename MatType, typename Activation>
-void RBFType<MatType, Activation>::Forward(
+void RBF<MatType, Activation>::Forward(
     const MatType& input,
     MatType& output)
 {
   // Sanity check: make sure the dimensions are right.
   if (input.n_rows != centres.n_rows)
   {
-    Log::Fatal << "RBFType::Forward(): input size (" << input.n_rows << ") does"
+    Log::Fatal << "RBF::Forward(): input size (" << input.n_rows << ") does"
         << " not match given center size (" << centres.n_rows << ")!"
         << std::endl;
   }
@@ -119,14 +144,14 @@ void RBFType<MatType, Activation>::Forward(
   for (size_t i = 0; i < input.n_cols; i++)
   {
     MatType temp = centres.each_col() - input.col(i);
-    distances.col(i) = pow(sum(pow((temp), 2), 0), 0.5).t();
+    distances.col(i) = sqrt(sum(square(temp), 0)).t();
   }
-  Activation::Fn(distances * std::pow(betas, 0.5), output);
+  Activation::Fn(distances * ElemType(std::pow(betas, 0.5)), output);
 }
 
 
 template<typename MatType, typename Activation>
-void RBFType<MatType, Activation>::Backward(
+void RBF<MatType, Activation>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& /* gy */,
@@ -136,7 +161,7 @@ void RBFType<MatType, Activation>::Backward(
 }
 
 template<typename MatType, typename Activation>
-void RBFType<MatType, Activation>::ComputeOutputDimensions()
+void RBF<MatType, Activation>::ComputeOutputDimensions()
 {
   this->outputDimensions = std::vector<size_t>(this->inputDimensions.size(), 1);
 
@@ -146,7 +171,7 @@ void RBFType<MatType, Activation>::ComputeOutputDimensions()
 
 template<typename MatType, typename Activation>
 template<typename Archive>
-void RBFType<MatType, Activation>::serialize(
+void RBF<MatType, Activation>::serialize(
     Archive& ar,
     const uint32_t /* version */)
 {

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

@@ -58,7 +58,10 @@ template<typename MatType = arma::mat>
 class RecurrentLayer : public Layer<MatType>
 {
  public:
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
+
   /**
    * Create the RecurrentLayer.
    */
@@ -124,6 +127,16 @@ class RecurrentLayer : public Layer<MatType>
   // meant to be done by the enclosing network.)
   void CurrentStep(const size_t& step, const bool end = false);
 
+  /**
+   * Update the internal state of the layer when the step changes. This is
+   * meant to be called by the enclosing network. A child recurrent class
+   * should override this.
+   */
+  virtual void OnStepChanged(const size_t /* step */,
+                             const size_t /* batchSize */,
+                             const size_t /* activeBatchSize */,
+                             const bool /* backwards */) { }
+
   // Get the previous step.  This is a very simple function but can lead to
   // slightly more readable code in Forward(), Backward(), and Gradient()
   // implementations.

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

@@ -14,7 +14,7 @@
  *  url = {https://arxiv.org/pdf/1704.04861}
  * }
  * @endcode
- * 
+ *
  * 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
@@ -33,28 +33,31 @@ namespace mlpack {
  *         (Default: arma::mat).
  */
 template<typename MatType = arma::mat>
-class ReLU6Type : public Layer<MatType>
+class ReLU6 : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
-   * Create the ReLU6Type object.
+   * Create the ReLU6 object.
    */
-  ReLU6Type();
+  ReLU6();
 
-  //! Clone the ReLU6Type object. This handles polymorphism correctly.
-  ReLU6Type* Clone() const { return new ReLU6Type(*this); }
+  // Clone the ReLU6 object. This handles polymorphism correctly.
+  ReLU6* Clone() const { return new ReLU6(*this); }
 
   // Virtual destructor.
-  virtual ~ReLU6Type() { }
+  virtual ~ReLU6() { }
 
-  //! Copy the given ReLU6Type.
-  ReLU6Type(const ReLU6Type& other);
-  //! Take ownership of the given ReLU6Type.
-  ReLU6Type(ReLU6Type&& other);
-  //! Copy the given ReLU6Type.
-  ReLU6Type& operator=(const ReLU6Type& other);
-  //! Take ownership of the given ReLU6Type.
-  ReLU6Type& operator=(ReLU6Type&& other);
+  // Copy the given ReLU6.
+  ReLU6(const ReLU6& other);
+  // Take ownership of the given ReLU6.
+  ReLU6(ReLU6&& other);
+  // Copy the given ReLU6.
+  ReLU6& operator=(const ReLU6& other);
+  // Take ownership of the given ReLU6.
+  ReLU6& operator=(ReLU6&& other);
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -80,7 +83,7 @@ class ReLU6Type : public Layer<MatType>
                 const MatType& gy,
                 MatType& g);
 
-  //! Get size of weights.
+  // Get size of weights.
   size_t WeightSize() const { return 0; }
 
   /**
@@ -90,11 +93,6 @@ class ReLU6Type : public Layer<MatType>
   void serialize(Archive& /* ar */, const uint32_t /* version */);
 }; // class ReLU6
 
-// Convenience typedefs.
-
-// Standard ReLU6 layer.
-using ReLU6 = ReLU6Type<arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.

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

@@ -29,31 +29,31 @@
 namespace mlpack {
 
 template<typename MatType>
-ReLU6Type<MatType>::ReLU6Type() :
+ReLU6<MatType>::ReLU6() :
     Layer<MatType>()
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-ReLU6Type<MatType>::ReLU6Type(
-    const ReLU6Type& other) :
+ReLU6<MatType>::ReLU6(
+    const ReLU6& other) :
     Layer<MatType>(other)
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-ReLU6Type<MatType>::ReLU6Type(
-    ReLU6Type&& other) :
+ReLU6<MatType>::ReLU6(
+    ReLU6&& other) :
     Layer<MatType>(std::move(other))
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-ReLU6Type<MatType>&
-ReLU6Type<MatType>::operator=(const ReLU6Type& other)
+ReLU6<MatType>&
+ReLU6<MatType>::operator=(const ReLU6& other)
 {
   if (&other != this)
   {
@@ -64,8 +64,8 @@ ReLU6Type<MatType>::operator=(const ReLU6Type& other)
 }
 
 template<typename MatType>
-ReLU6Type<MatType>&
-ReLU6Type<MatType>::operator=(ReLU6Type&& other)
+ReLU6<MatType>&
+ReLU6<MatType>::operator=(ReLU6&& other)
 {
   if (&other != this)
   {
@@ -76,14 +76,14 @@ ReLU6Type<MatType>::operator=(ReLU6Type&& other)
 }
 
 template<typename MatType>
-void ReLU6Type<MatType>::Forward(
+void ReLU6<MatType>::Forward(
     const MatType& input, MatType& output)
 {
-  output = arma::clamp(input, 0.0, 6.0);
+  output = arma::clamp(input, 0, 6);
 }
 
 template<typename MatType>
-void ReLU6Type<MatType>::Backward(
+void ReLU6<MatType>::Backward(
     const MatType& input,
     const MatType& /* output */,
     const MatType& gy,
@@ -95,13 +95,13 @@ void ReLU6Type<MatType>::Backward(
     if (input(i) < 6 && input(i) > 0)
       g(i) = gy(i);
     else
-      g(i) = 0.0;
+      g(i) = 0;
   }
 }
 
 template<typename MatType>
 template<typename Archive>
-void ReLU6Type<MatType>::serialize(
+void ReLU6<MatType>::serialize(
     Archive& /* ar */,
     const uint32_t /* version */)
 {

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

@@ -30,18 +30,20 @@ namespace mlpack {
  *    computation.
  */
 template <typename MatType = arma::mat>
-class RepeatType : public Layer<MatType>
+class Repeat : public Layer<MatType>
 {
  public:
-  //! Get Specific Col type, not only arma
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using UintCol = typename GetUColType<MatType>::type;
   using UintMat = typename GetUDenseMatType<MatType>::type;
+
   /**
    * Create the Repeat object.  Multiples will be empty (e.g. 1s for all
    * dimensions), so this is the equivalent of an Identity Layer.
    * Interleave will be false (e.g. repeat in blocks).
    */
-  RepeatType();
+  Repeat();
 
   /**
    * Create the Repeat object, specifying the number of times to repeat
@@ -53,24 +55,24 @@ class RepeatType : public Layer<MatType>
    * @apram interleave If true, the output will be interleaved (similar to
    *        arma::repelem).  If false, the output will be repeated in blocks.
    */
-  RepeatType(std::vector<size_t> multiples, bool interleave = false);
+  Repeat(std::vector<size_t> multiples, bool interleave = false);
 
   /**
    * Destroy the layers held by the model.
    */
-  virtual ~RepeatType() { }
+  virtual ~Repeat() { }
 
-  //! Clone the RepeatType object. This handles polymorphism correctly.
-  RepeatType* Clone() const override { return new RepeatType(*this); }
+  // Clone the Repeat object. This handles polymorphism correctly.
+  Repeat* Clone() const override { return new Repeat(*this); }
 
-  //! Copy the given RepeatType layer.
-  RepeatType(const RepeatType& other);
-  //! Take ownership of the given RepeatType layer.
-  RepeatType(RepeatType&& other) noexcept;
-  //! Copy the given RepeatType layer.
-  RepeatType& operator=(const RepeatType& other);
-  //! Take ownership of the given RepeatType layer.
-  RepeatType& operator=(RepeatType&& other) noexcept;
+  // Copy the given Repeat layer.
+  Repeat(const Repeat& other);
+  // Take ownership of the given Repeat layer.
+  Repeat(Repeat&& other) noexcept;
+  // Copy the given Repeat layer.
+  Repeat& operator=(const Repeat& other);
+  // Take ownership of the given Repeat layer.
+  Repeat& operator=(Repeat&& other) noexcept;
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -96,20 +98,20 @@ class RepeatType : public Layer<MatType>
                 const MatType& gy,
                 MatType& g) override;
 
-  //! Get the repeat multiples
+  // Get the repeat multiples
   const std::vector<size_t>& Multiples() const { return multiples; }
 
-  //! Get the repeat multiples for modification
+  // Get the repeat multiples for modification
   std::vector<size_t>& Multiples()
   {
     this->validOutputDimensions = false;
     return multiples;
   }
 
-  //! Get the interleave parameter
+  // Get the interleave parameter
   bool Interleave() const { return interleave; }
 
-  //! Get the interleave parameter for modification
+  // Get the interleave parameter for modification
   bool& Interleave() { return interleave; }
 
   /**
@@ -130,10 +132,10 @@ class RepeatType : public Layer<MatType>
   void serialize(Archive& ar, const uint32_t /* version */);
 
  private:
-  //! Parameter to indicate number of times to repeat along each dimension
+  // Parameter to indicate number of times to repeat along each dimension
   std::vector<size_t> multiples;
 
-  //! Parameter to indicate whether to interleave the output
+  // Parameter to indicate whether to interleave the output
   bool interleave;
 
   // Cache the target indices for a single tensor for use
@@ -144,10 +146,7 @@ class RepeatType : public Layer<MatType>
   // input elements for use in the backward pass.
   size_t sizeMult;
   UintMat backIdxs;
-}; // class RepeatType.
-
-// Standard Repeat layer.
-using Repeat = RepeatType<arma::mat>;
+}; // class Repeat.
 
 } // namespace mlpack