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

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

@@ -26,38 +26,41 @@ namespace mlpack {
  *    computation.
  */
 template<typename MatType = arma::mat>
-class NoisyLinearType : public Layer<MatType>
+class NoisyLinear : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the NoisyLinear layer object using the specified number of units.
    *
    * @param outSize The number of output units.
    */
-  NoisyLinearType(const size_t outSize = 0);
+  NoisyLinear(const size_t outSize = 0);
 
-  //! Clone the NoisyLinearType object. This handles polymorphism correctly.
-  NoisyLinearType* Clone() const { return new NoisyLinearType(*this); }
+  // Clone the NoisyLinear object. This handles polymorphism correctly.
+  NoisyLinear* Clone() const { return new NoisyLinear(*this); }
 
   // Virtual destructor.
-  virtual ~NoisyLinearType() { }
-
-  //! Copy the given NoisyLinear layer (but not weights).
-  NoisyLinearType(const NoisyLinearType& other);
-  //! Take ownership of the given NoisyLinear layer (but not weights).
-  NoisyLinearType(NoisyLinearType&& other);
-  //! Copy the given NoisyLinear layer (but not weights).
-  NoisyLinearType& operator=(const NoisyLinearType& other);
-  //! Take ownership of the given NoisyLinear layer (but not weights).
-  NoisyLinearType& operator=(NoisyLinearType&& other);
-
-  //! Reset the layer parameter.
+  virtual ~NoisyLinear() { }
+
+  // Copy the given NoisyLinear layer (but not weights).
+  NoisyLinear(const NoisyLinear& other);
+  // Take ownership of the given NoisyLinear layer (but not weights).
+  NoisyLinear(NoisyLinear&& other);
+  // Copy the given NoisyLinear layer (but not weights).
+  NoisyLinear& operator=(const NoisyLinear& other);
+  // Take ownership of the given NoisyLinear layer (but not weights).
+  NoisyLinear& operator=(NoisyLinear&& other);
+
+  // Reset the layer parameter.
   void SetWeights(const MatType& weightsIn);
 
-  //! Reset the noise parameters (epsilons).
+  // Reset the noise parameters (epsilons).
   void ResetNoise();
 
-  //! Reset the values of layer parameters (factorized gaussian noise).
+  // Reset the values of layer parameters (factorized gaussian noise).
   void ResetParameters();
 
   /**
@@ -95,64 +98,58 @@ class NoisyLinearType : public Layer<MatType>
                 const MatType& error,
                 MatType& gradient);
 
-  //! Get the parameters.
+  // Get the parameters.
   MatType const& Parameters() const { return weights; }
-  //! Modify the parameters.
+  // Modify the parameters.
   MatType& Parameters() { return weights; }
 
-  //! Get the shape of the input.
-  //! Modify the bias weights of the layer.
+  // Modify the bias weights of the layer.
   MatType& Bias() { return bias; }
 
-  //! Compute the number of parameters in the layer.
+  // Compute the number of parameters in the layer.
   size_t WeightSize() const { return (outSize * inSize + outSize) * 2; }
 
-  //! Compute the output dimensions of the layer given `InputDimensions()`.
+  // Compute the output dimensions of the layer given `InputDimensions()`.
   void ComputeOutputDimensions();
 
-  //! Serialize the layer.
+  // Serialize the layer.
   template<typename Archive>
   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 number of input units.
+  // Locally stored number of input units.
   size_t inSize;
 
-  //! Locally-stored weight object.
+  // Locally-stored weight object.
   MatType weights;
 
-  //! Locally-stored weight parameters.
+  // Locally-stored weight parameters.
   MatType weight;
 
-  //! Locally-stored weight-mean parameters.
+  // Locally-stored weight-mean parameters.
   MatType weightMu;
 
-  //! Locally-stored weight-standard-deviation parameters.
+  // Locally-stored weight-standard-deviation parameters.
   MatType weightSigma;
 
-  //! Locally-stored weight-epsilon parameters.
+  // Locally-stored weight-epsilon parameters.
   MatType weightEpsilon;
 
-  //! Locally-stored bias parameters.
+  // Locally-stored bias parameters.
   MatType bias;
 
-  //! Locally-stored bias-mean parameters.
+  // Locally-stored bias-mean parameters.
   MatType biasMu;
 
-  //! Locally-stored bias-standard-deviation parameters.
+  // Locally-stored bias-standard-deviation parameters.
   MatType biasSigma;
 
-  //! Locally-stored bias-epsilon parameters.
+  // Locally-stored bias-epsilon parameters.
   MatType biasEpsilon;
-}; // class NoisyLinearType
-
-// Convenience typedefs.
-
-// Standard noisy linear layer.
-using NoisyLinear = NoisyLinearType<arma::mat>;
+}; // class NoisyLinear
 
 } // namespace mlpack
 

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

@@ -18,7 +18,7 @@
 namespace mlpack {
 
 template<typename MatType>
-NoisyLinearType<MatType>::NoisyLinearType(const size_t outSize) :
+NoisyLinear<MatType>::NoisyLinear(const size_t outSize) :
     Layer<MatType>(),
     outSize(outSize),
     inSize(0)
@@ -27,7 +27,7 @@ NoisyLinearType<MatType>::NoisyLinearType(const size_t outSize) :
 }
 
 template<typename MatType>
-NoisyLinearType<MatType>::NoisyLinearType(const NoisyLinearType& other) :
+NoisyLinear<MatType>::NoisyLinear(const NoisyLinear& other) :
     Layer<MatType>(other),
     outSize(other.outSize),
     inSize(other.inSize)
@@ -36,7 +36,7 @@ NoisyLinearType<MatType>::NoisyLinearType(const NoisyLinearType& other) :
 }
 
 template<typename MatType>
-NoisyLinearType<MatType>::NoisyLinearType(NoisyLinearType&& other) :
+NoisyLinear<MatType>::NoisyLinear(NoisyLinear&& other) :
     Layer<MatType>(std::move(other)),
     outSize(std::move(other.outSize)),
     inSize(std::move(other.inSize))
@@ -45,8 +45,8 @@ NoisyLinearType<MatType>::NoisyLinearType(NoisyLinearType&& other) :
 }
 
 template<typename MatType>
-NoisyLinearType<MatType>&
-NoisyLinearType<MatType>::operator=(const NoisyLinearType& other)
+NoisyLinear<MatType>&
+NoisyLinear<MatType>::operator=(const NoisyLinear& other)
 {
   if (&other != this)
   {
@@ -59,8 +59,8 @@ NoisyLinearType<MatType>::operator=(const NoisyLinearType& other)
 }
 
 template<typename MatType>
-NoisyLinearType<MatType>&
-NoisyLinearType<MatType>::operator=(NoisyLinearType&& other)
+NoisyLinear<MatType>&
+NoisyLinear<MatType>::operator=(NoisyLinear&& other)
 {
   if (&other != this)
   {
@@ -73,7 +73,7 @@ NoisyLinearType<MatType>::operator=(NoisyLinearType&& other)
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::SetWeights(const MatType& weightsIn)
+void NoisyLinear<MatType>::SetWeights(const MatType& weightsIn)
 {
   MakeAlias(weights, weightsIn, 1, (outSize * inSize + outSize) * 2);
   MakeAlias(weightMu, weightsIn, outSize, inSize);
@@ -87,7 +87,7 @@ void NoisyLinearType<MatType>::SetWeights(const MatType& weightsIn)
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::ResetNoise()
+void NoisyLinear<MatType>::ResetNoise()
 {
   MatType epsilonIn;
   epsilonIn.randn(inSize, 1);
@@ -102,19 +102,19 @@ void NoisyLinearType<MatType>::ResetNoise()
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::ResetParameters()
+void NoisyLinear<MatType>::ResetParameters()
 {
-  const double muRange = 1 / std::sqrt(inSize);
+  const ElemType muRange = 1 / std::sqrt(ElemType(inSize));
   weightMu.randu();
   weightMu = muRange * (weightMu * 2 - 1);
   biasMu.randu();
   biasMu = muRange * (biasMu * 2 - 1);
-  weightSigma.fill(0.5 / std::sqrt(inSize));
-  biasSigma.fill(0.5 / std::sqrt(outSize));
+  weightSigma.fill(1 / (2 * std::sqrt(ElemType(inSize))));
+  biasSigma.fill(1 / (2 * std::sqrt(ElemType(outSize))));
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::Forward(const MatType& input, MatType& output)
+void NoisyLinear<MatType>::Forward(const MatType& input, MatType& output)
 {
   weight = weightMu + weightSigma % weightEpsilon;
   bias = biasMu + biasSigma % biasEpsilon;
@@ -123,7 +123,7 @@ void NoisyLinearType<MatType>::Forward(const MatType& input, MatType& output)
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::Backward(
+void NoisyLinear<MatType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -133,7 +133,7 @@ void NoisyLinearType<MatType>::Backward(
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::Gradient(
+void NoisyLinear<MatType>::Gradient(
     const MatType& input, const MatType& error, MatType& gradient)
 {
   // Locally stored to prevent multiplication twice.
@@ -151,7 +151,7 @@ void NoisyLinearType<MatType>::Gradient(
 }
 
 template<typename MatType>
-void NoisyLinearType<MatType>::ComputeOutputDimensions()
+void NoisyLinear<MatType>::ComputeOutputDimensions()
 {
   inSize = this->inputDimensions[0];
   for (size_t i = 1; i < this->inputDimensions.size(); ++i)
@@ -166,7 +166,7 @@ void NoisyLinearType<MatType>::ComputeOutputDimensions()
 
 template<typename MatType>
 template<typename Archive>
-void NoisyLinearType<MatType>::serialize(
+void NoisyLinear<MatType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));

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

@@ -25,10 +25,13 @@ namespace mlpack {
  *    computation.
  */
 template<typename MatType = arma::mat>
-class PaddingType : public Layer<MatType>
+class Padding : public Layer<MatType>
 {
  public:
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
+
   /**
    * Create the Padding object using the specified number of output units.
    *
@@ -37,25 +40,26 @@ class PaddingType : public Layer<MatType>
    * @param padHTop Top padding height of the input.
    * @param padHBottom Bottom padding height of the input.
    */
-  PaddingType(const size_t padWLeft = 0,
+  Padding(const size_t padWLeft = 0,
               const size_t padWRight = 0,
               const size_t padHTop = 0,
-              const size_t padHBottom = 0);
+              const size_t padHBottom = 0,
+              const typename MatType::elem_type fillValue = 0);
 
-  //! Clone the PaddingType object. This handles polymorphism correctly.
-  PaddingType* Clone() const { return new PaddingType(*this); }
+  //! Clone the Padding object. This handles polymorphism correctly.
+  Padding* Clone() const { return new Padding(*this); }
 
   //! Virtual destructor.
-  virtual ~PaddingType() { }
+  virtual ~Padding() { }
 
-  //! Copy the given PaddingType.
-  PaddingType(const PaddingType& other);
-  //! Take ownership of the given PaddingType.
-  PaddingType(PaddingType&& other);
-  //! Copy the given PaddingType.
-  PaddingType& operator=(const PaddingType& other);
-  //! Take ownership of the given PaddingType.
-  PaddingType& operator=(PaddingType&& other);
+  //! Copy the given Padding.
+  Padding(const Padding& other);
+  //! Take ownership of the given Padding.
+  Padding(Padding&& other);
+  //! Copy the given Padding.
+  Padding& operator=(const Padding& other);
+  //! Take ownership of the given Padding.
+  Padding& operator=(Padding&& other);
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -125,10 +129,10 @@ class PaddingType : public Layer<MatType>
 
   //! Cached number of input maps.
   size_t totalInMaps;
-}; // class PaddingType
 
-// Standard Padding layer.
-using Padding = PaddingType<arma::mat>;
+  //! Pad the input with this value.
+  ElemType fillValue;
+}; // class Padding
 
 } // namespace mlpack
 

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

@@ -19,48 +19,51 @@
 namespace mlpack {
 
 template<typename MatType>
-PaddingType<MatType>::PaddingType(
+Padding<MatType>::Padding(
     const size_t padWLeft,
     const size_t padWRight,
     const size_t padHTop,
-    const size_t padHBottom) :
+    const size_t padHBottom,
+    const typename MatType::elem_type fillValue) :
     Layer<MatType>(),
     padWLeft(padWLeft),
     padWRight(padWRight),
     padHTop(padHTop),
     padHBottom(padHBottom),
-    totalInMaps(0)
+    totalInMaps(0),
+    fillValue(fillValue)
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-PaddingType<MatType>::PaddingType(const PaddingType& other) :
+Padding<MatType>::Padding(const Padding& other) :
     Layer<MatType>(other),
     padWLeft(other.padWLeft),
     padWRight(other.padWRight),
     padHTop(other.padHTop),
     padHBottom(other.padHBottom),
-    totalInMaps(other.totalInMaps)
+    fillValue(other.fillValue)
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-PaddingType<MatType>::PaddingType(PaddingType&& other) :
+Padding<MatType>::Padding(Padding&& other) :
     Layer<MatType>(std::move(other)),
     padWLeft(std::move(other.padWLeft)),
     padWRight(std::move(other.padWRight)),
     padHTop(std::move(other.padHTop)),
     padHBottom(std::move(other.padHBottom)),
-    totalInMaps(std::move(other.totalInMaps))
+    totalInMaps(std::move(other.totalInMaps)),
+    fillValue(std::move(other.fillValue))
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-PaddingType<MatType>&
-PaddingType<MatType>::operator=(const PaddingType& other)
+Padding<MatType>&
+Padding<MatType>::operator=(const Padding& other)
 {
   if (this != &other)
   {
@@ -70,14 +73,15 @@ PaddingType<MatType>::operator=(const PaddingType& other)
     padHTop = other.padHTop;
     padHBottom = other.padHBottom;
     totalInMaps = other.totalInMaps;
+    fillValue = other.fillValue;
   }
 
   return *this;
 }
 
 template<typename MatType>
-PaddingType<MatType>&
-PaddingType<MatType>::operator=(PaddingType&& other)
+Padding<MatType>&
+Padding<MatType>::operator=(Padding&& other)
 {
   if (this != &other)
   {
@@ -87,13 +91,14 @@ PaddingType<MatType>::operator=(PaddingType&& other)
     padHTop = std::move(other.padHTop);
     padHBottom = std::move(other.padHBottom);
     totalInMaps = std::move(other.totalInMaps);
+    fillValue = std::move(other.fillValue);
   }
 
   return *this;
 }
 
 template<typename MatType>
-void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
+void Padding<MatType>::Forward(const MatType& input, MatType& output)
 {
   // Make an alias of the input and output so that we can deal with the first
   // two dimensions directly.
@@ -110,7 +115,7 @@ void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
     reshapedOutput.tube(0,
                         0,
                         reshapedOutput.n_rows - 1,
-                        padHTop - 1).zeros();
+                        padHTop - 1).fill(fillValue);
   }
 
   if (padWLeft > 0)
@@ -118,7 +123,7 @@ void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
     reshapedOutput.tube(0,
                         padHTop,
                         padWLeft - 1,
-                        padHTop + this->inputDimensions[1] - 1).zeros();
+                        padHTop + this->inputDimensions[1] - 1).fill(fillValue);
   }
 
   if (padHBottom > 0)
@@ -126,7 +131,7 @@ void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
     reshapedOutput.tube(0,
                         padHTop + this->inputDimensions[1],
                         reshapedOutput.n_rows - 1,
-                        reshapedOutput.n_cols - 1).zeros();
+                        reshapedOutput.n_cols - 1).fill(fillValue);
   }
 
   if (padWRight > 0)
@@ -134,7 +139,7 @@ void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
     reshapedOutput.tube(padWLeft + this->inputDimensions[0],
                         padHTop,
                         reshapedOutput.n_rows - 1,
-                        padHTop + this->inputDimensions[1] - 1).zeros();
+                        padHTop + this->inputDimensions[1] - 1).fill(fillValue);
   }
 
   // Copy the input matrix.
@@ -145,7 +150,7 @@ void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
 }
 
 template<typename MatType>
-void PaddingType<MatType>::Backward(
+void Padding<MatType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -167,7 +172,7 @@ void PaddingType<MatType>::Backward(
 }
 
 template<typename MatType>
-void PaddingType<MatType>::ComputeOutputDimensions()
+void Padding<MatType>::ComputeOutputDimensions()
 {
   this->outputDimensions = this->inputDimensions;
 
@@ -183,7 +188,7 @@ void PaddingType<MatType>::ComputeOutputDimensions()
 
 template<typename MatType>
 template<typename Archive>
-void PaddingType<MatType>::serialize(Archive& ar, const uint32_t /* version */)
+void Padding<MatType>::serialize(Archive& ar, const uint32_t version)
 {
   ar(cereal::base_class<Layer<MatType>>(this));
 
@@ -192,6 +197,15 @@ void PaddingType<MatType>::serialize(Archive& ar, const uint32_t /* version */)
   ar(CEREAL_NVP(padHTop));
   ar(CEREAL_NVP(padHBottom));
   ar(CEREAL_NVP(totalInMaps));
+
+  if (version == 0)
+  {
+    fillValue = 0;
+  }
+  else
+  {
+    ar(CEREAL_NVP(fillValue));
+  }
 }
 
 } // namespace mlpack

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

@@ -39,9 +39,12 @@ namespace mlpack {
  *         (Default: arma::mat).
  */
 template<typename MatType = arma::mat>
-class PReLUType : public Layer<MatType>
+class PReLU : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the PReLU object using the specified parameters.
    * The non zero gradient can be adjusted by specifying tha parameter
@@ -50,24 +53,24 @@ class PReLUType : public Layer<MatType>
    *
    * @param userAlpha Non zero gradient
    */
-  PReLUType(const double userAlpha = 0.03);
+  PReLU(const double userAlpha = 0.03);
 
-  //! Clone the PReLUType object. This handles polymorphism correctly.
-  PReLUType* Clone() const { return new PReLUType(*this); }
+  // Clone the PReLU object. This handles polymorphism correctly.
+  PReLU* Clone() const { return new PReLU(*this); }
 
   // Virtual destructor.
-  virtual ~PReLUType() { }
-
-  //! Copy the given PReLUType.
-  PReLUType(const PReLUType& other);
-  //! Take ownership of the given PReLUType.
-  PReLUType(PReLUType&& other);
-  //! Copy the given PReLUType.
-  PReLUType& operator=(const PReLUType& other);
-  //! Take ownership of the given PReLUType.
-  PReLUType& operator=(PReLUType&& other);
-
-  //! Reset the layer parameter.
+  virtual ~PReLU() { }
+
+  // Copy the given PReLU.
+  PReLU(const PReLU& other);
+  // Take ownership of the given PReLU.
+  PReLU(PReLU&& other);
+  // Copy the given PReLU.
+  PReLU& operator=(const PReLU& other);
+  // Take ownership of the given PReLU.
+  PReLU& operator=(PReLU&& other);
+
+  // Reset the layer parameter.
   void SetWeights(const MatType& weightsIn);
 
   /**
@@ -115,17 +118,17 @@ class PReLUType : public Layer<MatType>
                 const MatType& error,
                 MatType& gradient);
 
-  //! Get the parameters.
+  // Get the parameters.
   MatType const& Parameters() const { return alpha; }
-  //! Modify the parameters.
+  // Modify the parameters.
   MatType& Parameters() { return alpha; }
 
-  //! Get the non zero gradient.
+  // Get the non zero gradient.
   double const& Alpha() const { return alpha(0); }
-  //! Modify the non zero gradient.
+  // Modify the non zero gradient.
   double& Alpha() { return alpha(0); }
 
-  //! Get size of weights.
+  // Get size of weights.
   size_t WeightSize() const { return 1; }
 
   /**
@@ -135,18 +138,13 @@ class PReLUType : public Layer<MatType>
   void serialize(Archive& ar, const uint32_t /* version */);
 
  private:
-  //! Leakyness Parameter object.
+  // Leakyness parameter object.
   MatType alpha;
 
-  //! Leakyness Parameter given by user in the range 0 < alpha < 1.
+  // Leakyness parameter given by user in the range 0 < alpha < 1.
   double userAlpha;
 }; // class PReLU
 
-// Convenience typedefs.
-
-// Standard PReLU layer.
-using PReLU = PReLUType<arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.