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

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

@@ -18,7 +18,7 @@ namespace mlpack {
 
 // Create the LinearRecurrent layer.
 template<typename MatType, typename RegularizerType>
-LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType() :
+LinearRecurrent<MatType, RegularizerType>::LinearRecurrent() :
     RecurrentLayer<MatType>(),
     inSize(0),
     outSize(0)
@@ -27,7 +27,7 @@ LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType() :
 }
 
 template<typename MatType, typename RegularizerType>
-LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType(
+LinearRecurrent<MatType, RegularizerType>::LinearRecurrent(
     const size_t outSize,
     RegularizerType regularizer) :
     RecurrentLayer<MatType>(),
@@ -40,8 +40,8 @@ LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType(
 
 // Copy constructor.
 template<typename MatType, typename RegularizerType>
-LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType(
-    const LinearRecurrentType& layer) :
+LinearRecurrent<MatType, RegularizerType>::LinearRecurrent(
+    const LinearRecurrent& layer) :
     RecurrentLayer<MatType>(layer),
     inSize(layer.inSize),
     outSize(layer.outSize),
@@ -52,8 +52,8 @@ LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType(
 
 // Move constructor.
 template<typename MatType, typename RegularizerType>
-LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType(
-    LinearRecurrentType&& layer) :
+LinearRecurrent<MatType, RegularizerType>::LinearRecurrent(
+    LinearRecurrent&& layer) :
     RecurrentLayer<MatType>(std::move(layer)),
     inSize(std::move(layer.inSize)),
     outSize(std::move(layer.outSize)),
@@ -66,9 +66,9 @@ LinearRecurrentType<MatType, RegularizerType>::LinearRecurrentType(
 
 // Copy operator.
 template<typename MatType, typename RegularizerType>
-LinearRecurrentType<MatType, RegularizerType>&
-LinearRecurrentType<MatType, RegularizerType>::operator=(
-    const LinearRecurrentType& layer)
+LinearRecurrent<MatType, RegularizerType>&
+LinearRecurrent<MatType, RegularizerType>::operator=(
+    const LinearRecurrent& layer)
 {
   if (&layer != this)
   {
@@ -83,9 +83,9 @@ LinearRecurrentType<MatType, RegularizerType>::operator=(
 
 // Move operator.
 template<typename MatType, typename RegularizerType>
-LinearRecurrentType<MatType, RegularizerType>&
-LinearRecurrentType<MatType, RegularizerType>::operator=(
-    LinearRecurrentType&& layer)
+LinearRecurrent<MatType, RegularizerType>&
+LinearRecurrent<MatType, RegularizerType>::operator=(
+    LinearRecurrent&& layer)
 {
   if (&layer != this)
   {
@@ -104,7 +104,7 @@ LinearRecurrentType<MatType, RegularizerType>::operator=(
 
 // Set the parameters of the layer.
 template<typename MatType, typename RegularizerType>
-void LinearRecurrentType<MatType, RegularizerType>::SetWeights(
+void LinearRecurrent<MatType, RegularizerType>::SetWeights(
     const MatType& weightsIn)
 {
   MakeAlias(parameters, weightsIn, WeightSize(), 1);
@@ -116,7 +116,7 @@ void LinearRecurrentType<MatType, RegularizerType>::SetWeights(
 
 // Forward pass of linear recurrent layer.
 template<typename MatType, typename RegularizerType>
-void LinearRecurrentType<MatType, RegularizerType>::Forward(
+void LinearRecurrent<MatType, RegularizerType>::Forward(
     const MatType& input, MatType& output)
 {
   // Take the forward step: f(x) = Wx + Uh + b.
@@ -127,7 +127,7 @@ void LinearRecurrentType<MatType, RegularizerType>::Forward(
   else
   {
     output = weights * input +
-        recurrentWeights * this->RecurrentState(this->PreviousStep());
+        recurrentWeights * previousOutput;
   }
 
   #pragma omp for
@@ -136,12 +136,12 @@ void LinearRecurrentType<MatType, RegularizerType>::Forward(
 
   // Update the recurrent state if needed.
   if (!this->AtFinalStep())
-    this->RecurrentState(this->CurrentStep()) = output;
+    currentOutput = output;
 }
 
 // Backward pass of linear recurrent layer.
 template<typename MatType, typename RegularizerType>
-void LinearRecurrentType<MatType, RegularizerType>::Backward(
+void LinearRecurrent<MatType, RegularizerType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -159,7 +159,7 @@ void LinearRecurrentType<MatType, RegularizerType>::Backward(
   {
     // Via the recurrence, the result is equivalent, just with the recurrent
     // gradient as the gy parameter.
-    g += weights.t() * this->RecurrentGradient(this->CurrentStep());
+    g += weights.t() * currentGradient;
   }
 
   if (this->HasPreviousStep())
@@ -169,20 +169,19 @@ void LinearRecurrentType<MatType, RegularizerType>::Backward(
     //
     // With respect to the output, we can just propagate back through the
     // recurrent weights.
-    this->RecurrentGradient(this->PreviousStep()) = recurrentWeights.t() * gy;
+    previousGradient = recurrentWeights.t() * gy;
 
     if (!this->AtFinalStep())
     {
       // If we also have a path from dz/dh^t, this can be added.
-      this->RecurrentGradient(this->PreviousStep()) +=
-          recurrentWeights.t() * this->RecurrentGradient(this->CurrentStep());
+      previousGradient += recurrentWeights.t() * currentGradient;
     }
   }
 }
 
 // Compute the gradient with respect to the input.
 template<typename MatType, typename RegularizerType>
-void LinearRecurrentType<MatType, RegularizerType>::Gradient(
+void LinearRecurrent<MatType, RegularizerType>::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
@@ -204,7 +203,7 @@ void LinearRecurrentType<MatType, RegularizerType>::Gradient(
   if (this->HasPreviousStep())
   {
     gradient.submat(whOffset, 0, bOffset - 1, 0) =
-        vectorise(error * this->RecurrentState(this->PreviousStep()).t());
+        vectorise(error * previousOutput.t());
   }
   gradient.submat(bOffset, 0, gradient.n_rows - 1, 0) = sum(error, 1);
 
@@ -215,15 +214,14 @@ void LinearRecurrentType<MatType, RegularizerType>::Gradient(
   if (!this->AtFinalStep())
   {
     gradient.submat(0, 0, whOffset - 1, 0) +=
-        vectorise(this->RecurrentGradient(this->CurrentStep()) * input.t());
+        vectorise(currentGradient * input.t());
     if (this->HasPreviousStep())
     {
       gradient.submat(whOffset, 0, bOffset - 1, 0) +=
-          vectorise(this->RecurrentGradient(this->CurrentStep()) *
-                    this->RecurrentState(this->PreviousStep()).t());
+          vectorise(currentGradient * previousOutput.t());
     }
     gradient.submat(bOffset, 0, gradient.n_rows - 1, 0) += sum(
-        this->RecurrentGradient(this->CurrentStep()), 1);
+        currentGradient, 1);
 
     // this->HiddenDeriv(this->PreviousStep()) was already computed in
     // Backward(), so no need to do it here.
@@ -232,7 +230,7 @@ void LinearRecurrentType<MatType, RegularizerType>::Gradient(
 
 // Get the total number of trainable parameters.
 template<typename MatType, typename RegularizerType>
-size_t LinearRecurrentType<MatType, RegularizerType>::WeightSize() const
+size_t LinearRecurrent<MatType, RegularizerType>::WeightSize() const
 {
   return (inSize * outSize) /* weight matrix */ +
       (outSize * outSize) /* recurrent state matrix */ +
@@ -240,7 +238,7 @@ size_t LinearRecurrentType<MatType, RegularizerType>::WeightSize() const
 }
 
 template<typename MatType, typename RegularizerType>
-size_t LinearRecurrentType<MatType, RegularizerType>::RecurrentSize() const
+size_t LinearRecurrent<MatType, RegularizerType>::RecurrentSize() const
 {
   return outSize;
 }
@@ -248,7 +246,7 @@ size_t LinearRecurrentType<MatType, RegularizerType>::RecurrentSize() const
 // Compute the output dimensions of the layer, assuming that inputDimension has
 // been set.
 template<typename MatType, typename RegularizerType>
-void LinearRecurrentType<MatType, RegularizerType>::ComputeOutputDimensions()
+void LinearRecurrent<MatType, RegularizerType>::ComputeOutputDimensions()
 {
   // Compute the total number of input dimensions.
   inSize = this->inputDimensions[0];
@@ -261,10 +259,41 @@ void LinearRecurrentType<MatType, RegularizerType>::ComputeOutputDimensions()
   this->outputDimensions[0] = outSize;
 }
 
+template<typename MatType, typename RegularizerType>
+void LinearRecurrent<MatType, RegularizerType>::OnStepChanged(
+    const size_t step,
+    const size_t /* batchSize */,
+    const size_t activeBatchSize,
+    const bool backwards)
+{
+  // Make aliases for the output from the recurrent state.
+  MakeAlias(currentOutput, this->RecurrentState(step),
+      outSize, activeBatchSize);
+
+  if (this->HasPreviousStep())
+  {
+    MakeAlias(previousOutput, this->RecurrentState(this->PreviousStep()),
+        outSize, activeBatchSize);
+  }
+
+  // Make aliases for the gradient from the recurrent gradient.
+  if (backwards)
+  {
+    MakeAlias(currentGradient, this->RecurrentGradient(step),
+        outSize, activeBatchSize);
+
+    if (this->HasPreviousStep())
+    {
+      MakeAlias(previousGradient, this->RecurrentGradient(this->PreviousStep()),
+          outSize, activeBatchSize);
+    }
+  }
+}
+
 // Serialize the layer.
 template<typename MatType, typename RegularizerType>
 template<typename Archive>
-void LinearRecurrentType<MatType, RegularizerType>::serialize(
+void LinearRecurrent<MatType, RegularizerType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<RecurrentLayer<MatType>>(this));

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

@@ -29,37 +29,31 @@ namespace mlpack {
  *    computation.
  */
 template <typename MatType = arma::mat>
-class LogSoftMaxType : public Layer<MatType>
+class LogSoftMax : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the LogSoftmax layer.
    */
-  LogSoftMaxType();
+  LogSoftMax();
 
-  //! Clone the LogSoftMaxType object. This handles polymorphism correctly.
-  LogSoftMaxType* Clone() const { return new LogSoftMaxType(*this); }
+  //! Clone the LogSoftMax object. This handles polymorphism correctly.
+  LogSoftMax* Clone() const { return new LogSoftMax(*this); }
 
   // Virtual destructor.
-  virtual ~LogSoftMaxType() { }
+  virtual ~LogSoftMax() { }
 
-  //! Copy the given LogSoftMaxType.
-  LogSoftMaxType(const LogSoftMaxType& other);
-  //! Take ownership of the given LogSoftMaxType.
-  LogSoftMaxType(LogSoftMaxType&& other);
-  //! Copy the given LogSoftMaxType.
-  LogSoftMaxType& operator=(const LogSoftMaxType& other);
-  //! Take ownership of the given LogSoftMaxType.
-  LogSoftMaxType& operator=(LogSoftMaxType&& other);
-
-  /**
-   * A wrapper function to call the correct implementation according to the
-   * specific matrix type (e.g., arma, coot).
-   *
-   * @param input Input data used for evaluating the specified function.
-   * @param output Resulting output activation.
-   */
-  void Forward(const MatType& input, MatType& output);
+  //! Copy the given LogSoftMax.
+  LogSoftMax(const LogSoftMax& other);
+  //! Take ownership of the given LogSoftMax.
+  LogSoftMax(LogSoftMax&& other);
+  //! Copy the given LogSoftMax.
+  LogSoftMax& operator=(const LogSoftMax& other);
+  //! Take ownership of the given LogSoftMax.
+  LogSoftMax& operator=(LogSoftMax&& other);
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -68,15 +62,7 @@ class LogSoftMaxType : public Layer<MatType>
    * @param input Input data used for evaluating the specified function.
    * @param output Resulting output activation.
    */
-  void ForwardImpl(const MatType& input, MatType& output,
-                   const typename std::enable_if_t<
-                       arma::is_arma_type<MatType>::value>* = 0);
-
-#ifdef MLPACK_HAS_COOT
-  void ForwardImpl(const MatType& input, MatType& output,
-                   const typename std::enable_if_t<
-                       coot::is_coot_type<MatType>::value>* = 0);
-#endif
+  void Forward(const MatType& input, MatType& output);
 
   /**
    * Ordinary feed backward pass of a neural network, calculating the function
@@ -101,11 +87,6 @@ class LogSoftMaxType : public Layer<MatType>
   }
 }; // class LogSoftmaxType
 
-// Convenience typedefs.
-
-// Standard Linear layer using no regularization.
-using LogSoftMax = LogSoftMaxType<arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.

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

@@ -18,29 +18,29 @@
 namespace mlpack {
 
 template<typename MatType>
-LogSoftMaxType<MatType>::LogSoftMaxType() :
+LogSoftMax<MatType>::LogSoftMax() :
     Layer<MatType>()
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-LogSoftMaxType<MatType>::LogSoftMaxType(const LogSoftMaxType& other) :
+LogSoftMax<MatType>::LogSoftMax(const LogSoftMax& other) :
     Layer<MatType>(other)
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-LogSoftMaxType<MatType>::LogSoftMaxType(LogSoftMaxType&& other) :
+LogSoftMax<MatType>::LogSoftMax(LogSoftMax&& other) :
     Layer<MatType>(std::move(other))
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-LogSoftMaxType<MatType>&
-LogSoftMaxType<MatType>::operator=(const LogSoftMaxType& other)
+LogSoftMax<MatType>&
+LogSoftMax<MatType>::operator=(const LogSoftMax& other)
 {
   if (&other != this)
   {
@@ -51,8 +51,8 @@ LogSoftMaxType<MatType>::operator=(const LogSoftMaxType& other)
 }
 
 template<typename MatType>
-LogSoftMaxType<MatType>&
-LogSoftMaxType<MatType>::operator=(LogSoftMaxType&& other)
+LogSoftMax<MatType>&
+LogSoftMax<MatType>::operator=(LogSoftMax&& other)
 {
   if (&other != this)
   {
@@ -63,85 +63,69 @@ LogSoftMaxType<MatType>::operator=(LogSoftMaxType&& other)
 }
 
 template<typename MatType>
-void LogSoftMaxType<MatType>::Forward(const MatType& input, MatType& output)
+void LogSoftMax<MatType>::Forward(const MatType& input, MatType& output)
 {
-  ForwardImpl(input, output);
-}
-
-template<typename MatType>
-void LogSoftMaxType<MatType>::ForwardImpl(
-    const MatType& input,
-    MatType& output,
-    const typename std::enable_if_t<arma::is_arma_type<MatType>::value>*)
-{
-  MatType maxInput = repmat(max(input, 0), input.n_rows, 1);
-  output = (maxInput - input);
-
-  // Approximation of the base-e exponential function. The accuracy, however, is
-  // about 0.00001 lower than using exp. Credits go to Leon Bottou.
-  #pragma omp parallel for
-  for (size_t i = 0; i < output.n_elem; ++i)
+  if constexpr (IsArma<MatType>::value)
   {
-    double x = output(i);
-    //! Fast approximation of exp(-x) for x positive.
-    static constexpr double A0 = 1.0;
-    static constexpr double A1 = 0.125;
-    static constexpr double A2 = 0.0078125;
-    static constexpr double A3 = 0.00032552083;
-    static constexpr double A4 = 1.0172526e-5;
-
-    if (x < 13.0)
+    MatType maxInput = repmat(max(input, 0), input.n_rows, 1);
+    output = (maxInput - input);
+
+    // Approximation of the base-e exponential function. The accuracy, however,
+    // is about 0.00001 lower than using exp. Credits go to Leon Bottou.
+    #pragma omp parallel for
+    for (size_t i = 0; i < output.n_elem; ++i)
     {
-      double y = A0 + x * (A1 + x * (A2 + x * (A3 + x * A4)));
-      y *= y;
-      y *= y;
-      y *= y;
-      y = 1 / y;
-      output(i) = y;
+      double x = output(i);
+      //! Fast approximation of exp(-x) for x positive.
+      static constexpr double A0 = 1.0;
+      static constexpr double A1 = 0.125;
+      static constexpr double A2 = 0.0078125;
+      static constexpr double A3 = 0.00032552083;
+      static constexpr double A4 = 1.0172526e-5;
+
+      if (x < 13.0)
+      {
+        double y = A0 + x * (A1 + x * (A2 + x * (A3 + x * A4)));
+        y *= y;
+        y *= y;
+        y *= y;
+        y = 1 / y;
+        output(i) = ElemType(y);
+      }
+      else
+      {
+        output(i) = 0;
+      }
     }
-    else
+
+    #pragma omp parallel for
+    for (size_t col = 0; col < maxInput.n_cols; ++col)
     {
-      output(i) = 0.0;
+      ElemType colSum = 0;
+      for (size_t row = 0; row < output.n_rows; ++row)
+      {
+        colSum += output(row, col);
+      }
+      ElemType logSum = std::log(colSum);
+      for (size_t row = 0; row < maxInput.n_rows; ++row)
+      {
+        maxInput(row, col) += logSum;
+      }
     }
+    output = input - maxInput;
   }
-
-  #pragma omp parallel for
-  for (size_t col = 0; col < maxInput.n_cols; ++col)
+  else if constexpr (IsCoot<MatType>::value)
   {
-    double colSum = 0.0;
-    for (size_t row = 0; row < output.n_rows; ++row)
-    {
-      colSum += output(row, col);
-    }
-    double logSum = std::log(colSum);
-    for (size_t row = 0; row < maxInput.n_rows; ++row)
-    {
-      maxInput(row, col) += logSum;
-    }
+    MatType maxInput = repmat(max(input), input.n_rows, 1);
+    output = (maxInput - input);
+    output = exp(-output);
+    maxInput.each_row() += log(sum(output));
+    output = input - maxInput;
   }
-
-  output = input - maxInput;
-}
-
-#ifdef MLPACK_HAS_COOT
-
-template<typename MatType>
-void LogSoftMaxType<MatType>::ForwardImpl(
-    const MatType& input,
-    MatType& output,
-    const typename std::enable_if_t<coot::is_coot_type<MatType>::value>*)
-{
-  MatType maxInput = repmat(max(input), input.n_rows, 1);
-  output = (maxInput - input);
-  output = exp(output * -1);
-  maxInput.each_row() += log(sum(output));
-  output = input - maxInput;
 }
 
-#endif
-
 template<typename MatType>
-void LogSoftMaxType<MatType>::Backward(
+void LogSoftMax<MatType>::Backward(
     const MatType& /* input */,
     const MatType& output,
     const MatType& gy,

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

@@ -53,11 +53,14 @@ namespace mlpack {
  *    computation.
  */
 template<typename MatType = arma::mat>
-class LSTMType : public RecurrentLayer<MatType>
+class LSTM : public RecurrentLayer<MatType>
 {
  public:
-  //! Create the LSTM object.
-  LSTMType();
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
+  // Create the LSTM object.
+  LSTM();
 
   /**
    * Create the LSTM layer object using the specified parameters.
@@ -65,21 +68,21 @@ class LSTMType : public RecurrentLayer<MatType>
    * @param outSize The number of output units.
    * @param rho Maximum number of steps to backpropagate through time (BPTT).
    */
-  LSTMType(const size_t outSize);
+  LSTM(const size_t outSize);
 
-  //! Clone the LSTMType object. This handles polymorphism correctly.
-  LSTMType* Clone() const { return new LSTMType(*this); }
+  // Clone the LSTM object. This handles polymorphism correctly.
+  LSTM* Clone() const { return new LSTM(*this); }
 
-  //! Copy the given LSTMType object.
-  LSTMType(const LSTMType& other);
-  //! Take ownership of the given LSTMType object's data.
-  LSTMType(LSTMType&& other);
-  //! Copy the given LSTMType object.
-  LSTMType& operator=(const LSTMType& other);
-  //! Take ownership of the given LSTMType object's data.
-  LSTMType& operator=(LSTMType&& other);
+  // Copy the given LSTM object.
+  LSTM(const LSTM& other);
+  // Take ownership of the given LSTM object's data.
+  LSTM(LSTM&& other);
+  // Copy the given LSTM object.
+  LSTM& operator=(const LSTM& other);
+  // Take ownership of the given LSTM object's data.
+  LSTM& operator=(LSTM&& other);
 
-  virtual ~LSTMType() { }
+  virtual ~LSTM() { }
 
   /**
    * Reset the layer parameter. The method is called to
@@ -217,6 +220,12 @@ class LSTMType : public RecurrentLayer<MatType>
     this->outputDimensions[0] = outSize;
   }
 
+  // Update the internal aliases of the layer when the step changes.
+  void OnStepChanged(const size_t step,
+                     const size_t batchSize,
+                     const size_t activeBatchSize,
+                     const bool backwards);
+
   /**
    * Serialize the layer.
    */
@@ -287,20 +296,8 @@ class LSTMType : public RecurrentLayer<MatType>
   MatType nextDeltaForgetGate;
   MatType nextDeltaOutputGate;
   MatType nextDeltaCell;
-
-  // Calling this function will set all the aliases for the functions above to
-  // the correct places in the current recurrent state methods.
-  void SetInternalAliases(const size_t batchSize);
-
-  // Calling this function will set up workspace memory for the backward pass,
-  // if necessary.
-  void SetBackwardWorkspace(const size_t batchSize);
-}; // class LSTMType
-
-// Convenience typedefs.
-
-// Standard LSTM layer.
-using LSTM = LSTMType<arma::mat>;
+  MatType nextForgetGate;
+}; // class LSTM
 
 } // namespace mlpack