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

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

@@ -18,7 +18,7 @@
 namespace mlpack {
 
 template<typename MatType>
-LSTMType<MatType>::LSTMType() :
+LSTM<MatType>::LSTM() :
     RecurrentLayer<MatType>(),
     inSize(0),
     outSize(0)
@@ -27,7 +27,7 @@ LSTMType<MatType>::LSTMType() :
 }
 
 template<typename MatType>
-LSTMType<MatType>::LSTMType(const size_t outSize) :
+LSTM<MatType>::LSTM(const size_t outSize) :
     RecurrentLayer<MatType>(),
     inSize(0),
     outSize(outSize)
@@ -36,7 +36,7 @@ LSTMType<MatType>::LSTMType(const size_t outSize) :
 }
 
 template<typename MatType>
-LSTMType<MatType>::LSTMType(const LSTMType& layer) :
+LSTM<MatType>::LSTM(const LSTM& layer) :
     RecurrentLayer<MatType>(layer),
     inSize(layer.inSize),
     outSize(layer.outSize)
@@ -45,7 +45,7 @@ LSTMType<MatType>::LSTMType(const LSTMType& layer) :
 }
 
 template<typename MatType>
-LSTMType<MatType>::LSTMType(LSTMType&& layer) :
+LSTM<MatType>::LSTM(LSTM&& layer) :
     RecurrentLayer<MatType>(std::move(layer)),
     inSize(layer.inSize),
     outSize(layer.outSize)
@@ -55,7 +55,7 @@ LSTMType<MatType>::LSTMType(LSTMType&& layer) :
 }
 
 template<typename MatType>
-LSTMType<MatType>& LSTMType<MatType>::operator=(const LSTMType& layer)
+LSTM<MatType>& LSTM<MatType>::operator=(const LSTM& layer)
 {
   if (this != &layer)
   {
@@ -68,7 +68,7 @@ LSTMType<MatType>& LSTMType<MatType>::operator=(const LSTMType& layer)
 }
 
 template<typename MatType>
-LSTMType<MatType>& LSTMType<MatType>::operator=(LSTMType&& layer)
+LSTM<MatType>& LSTM<MatType>::operator=(LSTM&& layer)
 {
   if (this != &layer)
   {
@@ -84,7 +84,7 @@ LSTMType<MatType>& LSTMType<MatType>::operator=(LSTMType&& layer)
 }
 
 template<typename MatType>
-void LSTMType<MatType>::SetWeights(const MatType& weights)
+void LSTM<MatType>::SetWeights(const MatType& weights)
 {
   // Set the weight parameters for the inputs.
   const size_t inputWeightSize = outSize * inSize;
@@ -123,14 +123,10 @@ void LSTMType<MatType>::SetWeights(const MatType& weights)
 
 // Forward when cellState is not needed.
 template<typename MatType>
-void LSTMType<MatType>::Forward(const MatType& input, MatType& output)
+void LSTM<MatType>::Forward(const MatType& input, MatType& output)
 {
   // Convenience alias.
-  const size_t batchSize = input.n_cols;
-
-  // The internal quantities are stored as recurrent state; so, set aliases
-  // correctly for this time step.
-  SetInternalAliases(batchSize);
+  const size_t activeBatchSize = input.n_cols;
 
   // Compute internal state:
   //
@@ -142,25 +138,29 @@ void LSTMType<MatType>::Forward(const MatType& input, MatType& output)
   // y_t  =    tanh(c_t) % o_t
 
   // Start by computing all non-recurrent portions.
-  blockInput = blockInputWeight * input + repmat(blockInputBias, 1, batchSize);
-  inputGate = inputGateWeight * input + repmat(inputGateBias, 1, batchSize);
-  forgetGate = forgetGateWeight * input + repmat(forgetGateBias, 1, batchSize);
-  outputGate = outputGateWeight * input + repmat(outputGateBias, 1, batchSize);
+  blockInput = blockInputWeight * input + repmat(blockInputBias, 1,
+      activeBatchSize);
+  inputGate = inputGateWeight * input + repmat(inputGateBias, 1,
+      activeBatchSize);
+  forgetGate = forgetGateWeight * input + repmat(forgetGateBias, 1,
+      activeBatchSize);
+  outputGate = outputGateWeight * input + repmat(outputGateBias, 1,
+      activeBatchSize);
 
   // Now add in recurrent portions, if needed.
   if (this->HasPreviousStep())
   {
     blockInput += recurrentBlockInputWeight * prevRecurrent;
     inputGate += recurrentInputGateWeight * prevRecurrent +
-        repmat(peepholeInputGateWeight, 1, batchSize) % prevCell;
+        repmat(peepholeInputGateWeight, 1, activeBatchSize) % prevCell;
     forgetGate += recurrentForgetGateWeight * prevRecurrent +
-        repmat(peepholeForgetGateWeight, 1, batchSize) % prevCell;
+        repmat(peepholeForgetGateWeight, 1, activeBatchSize) % prevCell;
   }
 
   // Apply nonlinearities.  (TODO: fast sigmoid?)
   blockInput = tanh(blockInput);
-  inputGate = 1.0 / (1.0 + exp(-inputGate));
-  forgetGate = 1.0 / (1.0 + exp(-forgetGate));
+  inputGate = 1 / (1 + exp(-inputGate));
+  forgetGate = 1 / (1 + exp(-forgetGate));
 
   // Compute the cell state.
   if (this->HasPreviousStep())
@@ -172,17 +172,18 @@ void LSTMType<MatType>::Forward(const MatType& input, MatType& output)
   if (this->HasPreviousStep())
   {
     outputGate += recurrentOutputGateWeight * prevRecurrent +
-        repmat(peepholeOutputGateWeight, 1, batchSize) % thisCell;
+        repmat(peepholeOutputGateWeight, 1, activeBatchSize) % thisCell;
   }
   else
   {
     // If we don't have a previous step, we still have to consider the peephole
     // connection.
-    outputGate += repmat(peepholeOutputGateWeight, 1, batchSize) % thisCell;
+    outputGate += repmat(peepholeOutputGateWeight, 1, activeBatchSize) %
+        thisCell;
   }
 
   // Apply nonlinearity for output gate.
-  outputGate = 1.0 / (1.0 + exp(-outputGate));
+  outputGate = 1 / (1 + exp(-outputGate));
 
   // Finally, we can compute the output itself.
   output = tanh(thisCell) % outputGate;
@@ -193,7 +194,7 @@ void LSTMType<MatType>::Forward(const MatType& input, MatType& output)
 }
 
 template<typename MatType>
-void LSTMType<MatType>::Backward(
+void LSTM<MatType>::Backward(
     const MatType& /* input */,
     const MatType& output,
     const MatType& gy,
@@ -219,12 +220,7 @@ void LSTMType<MatType>::Backward(
   // dz_t = dc_t % i_t       % (1 - z_t .^ 2)
   //
   // dx_t = W_z^T dz_t + W_i^T di_t + W_f^T df_t + W_o^T do_t
-  //
-  // Before we start, set all the internal aliases, which will contain this time
-  // step's values as computed in Forward().
-  const size_t batchSize = output.n_cols;
-  SetInternalAliases(batchSize);
-  SetBackwardWorkspace(batchSize);
+  const size_t activeBatchSize = output.n_cols;
 
   // First attempt...
   if (this->AtFinalStep())
@@ -239,35 +235,31 @@ void LSTMType<MatType>::Backward(
                   recurrentOutputGateWeight.t() * nextDeltaOutputGate;
   }
 
-  deltaOutputGate = deltaY % tanh(thisCell) % (outputGate % (1.0 - outputGate));
+  deltaOutputGate = deltaY % tanh(thisCell) % (outputGate % (1 - outputGate));
 
   // Only first two terms if at final step
   if (this->AtFinalStep())
   {
-    deltaCell = deltaY % outputGate % (1.0 - square(tanh(thisCell))) +
-        repmat(peepholeOutputGateWeight, 1, batchSize) % deltaOutputGate;
+    deltaCell = deltaY % outputGate % (1 - square(tanh(thisCell))) +
+        repmat(peepholeOutputGateWeight, 1, activeBatchSize) % deltaOutputGate;
   }
   else
   {
-    // To update the cell state, we actually need to use the forget gate values
-    // from the next time step.
-    MatType nextForgetGate;
-    MakeAlias(nextForgetGate, this->RecurrentState(this->CurrentStep() + 1),
-        outSize, batchSize, 4 * outSize * batchSize);
-
-    deltaCell = deltaY % outputGate % (1.0 - square(tanh(thisCell))) +
-        repmat(peepholeOutputGateWeight, 1, batchSize) % deltaOutputGate +
-        repmat(peepholeInputGateWeight, 1, batchSize) % nextDeltaInputGate +
-        repmat(peepholeForgetGateWeight, 1, batchSize) % nextDeltaForgetGate +
+    deltaCell = deltaY % outputGate % (1 - square(tanh(thisCell))) +
+        repmat(peepholeOutputGateWeight, 1, activeBatchSize) % deltaOutputGate +
+        repmat(peepholeInputGateWeight, 1, activeBatchSize) %
+            nextDeltaInputGate +
+        repmat(peepholeForgetGateWeight, 1, activeBatchSize) %
+            nextDeltaForgetGate +
         nextDeltaCell % nextForgetGate;
   }
 
   if (this->HasPreviousStep())
-    deltaForgetGate = deltaCell % prevCell % (forgetGate % (1.0 - forgetGate));
+    deltaForgetGate = deltaCell % prevCell % (forgetGate % (1 - forgetGate));
   else
     deltaForgetGate.zeros();
-  deltaInputGate = deltaCell % blockInput % (inputGate % (1.0 - inputGate));
-  deltaBlockInput = deltaCell % inputGate % (1.0 - square(blockInput));
+  deltaInputGate = deltaCell % blockInput % (inputGate % (1 - inputGate));
+  deltaBlockInput = deltaCell % inputGate % (1 - square(blockInput));
 
   // Finally, compute deltaX (which is what we wanted all along).
   g = blockInputWeight.t() * deltaBlockInput +
@@ -280,15 +272,11 @@ void LSTMType<MatType>::Backward(
 }
 
 template<typename MatType>
-void LSTMType<MatType>::Gradient(
+void LSTM<MatType>::Gradient(
     const MatType& input,
     const MatType& /* error */,
     MatType& gradient)
 {
-  // This implementation depends on Gradient() being called just after
-  // Backward(), which is something we can safely assume.  So, the workspace
-  // aliases are already set by SetBackwardWorkspace().
-  //
   // In this implementation we won't use aliases; we'll just address the correct
   // part of the gradient directly.
 
@@ -390,7 +378,7 @@ void LSTMType<MatType>::Gradient(
 }
 
 template<typename MatType>
-size_t LSTMType<MatType>::WeightSize() const
+size_t LSTM<MatType>::WeightSize() const
 {
   return 4 * inSize * outSize /* input weight connections */ +
       4 * outSize /* input bias */ +
@@ -399,7 +387,7 @@ size_t LSTMType<MatType>::WeightSize() const
 }
 
 template<typename MatType>
-size_t LSTMType<MatType>::RecurrentSize() const
+size_t LSTM<MatType>::RecurrentSize() const
 {
   // We have to account for the cell, recurrent connection, and the four
   // internal matrices: block input, input gate, forget gate, and output gate.
@@ -410,97 +398,113 @@ size_t LSTMType<MatType>::RecurrentSize() const
 }
 
 template<typename MatType>
-void LSTMType<MatType>::SetInternalAliases(const size_t batchSize)
+void LSTM<MatType>::OnStepChanged(const size_t step,
+                                  const size_t batchSize,
+                                  const size_t activeBatchSize,
+                                  const bool backwards)
 {
   // Make all of the aliases for internal state point to the correct place.
-  MatType& state = this->RecurrentState(this->CurrentStep());
+  MatType& state = this->RecurrentState(step);
 
   // First make aliases for the recurrent connections.
-  MakeAlias(thisRecurrent, state, outSize, batchSize);
-  MakeAlias(thisCell, state, outSize, batchSize, outSize * batchSize);
+  MakeAlias(thisRecurrent, state, outSize, activeBatchSize);
+  MakeAlias(thisCell, state, outSize, activeBatchSize, outSize * batchSize);
 
   // Now make aliases for the internal state members that we use as scratch
   // space for computation.
-  MakeAlias(blockInput, state, outSize, batchSize, 2 * outSize * batchSize);
-  MakeAlias(inputGate, state, outSize, batchSize, 3 * outSize * batchSize);
-  MakeAlias(forgetGate, state, outSize, batchSize, 4 * outSize * batchSize);
-  MakeAlias(outputGate, state, outSize, batchSize, 5 * outSize * batchSize);
+  MakeAlias(blockInput, state, outSize, activeBatchSize, 2 * outSize *
+      batchSize);
+  MakeAlias(inputGate, state, outSize, activeBatchSize, 3 * outSize *
+      batchSize);
+  MakeAlias(forgetGate, state, outSize, activeBatchSize, 4 * outSize *
+      batchSize);
+  MakeAlias(outputGate, state, outSize, activeBatchSize, 5 * outSize *
+      batchSize);
 
   // Make aliases for the previous time step, too, if we can.
   if (this->HasPreviousStep())
   {
     MatType& prevState = this->RecurrentState(this->PreviousStep());
 
-    MakeAlias(prevRecurrent, prevState, outSize, batchSize);
-    MakeAlias(prevCell, prevState, outSize, batchSize, outSize * batchSize);
+    MakeAlias(prevRecurrent, prevState, outSize, activeBatchSize);
+    MakeAlias(prevCell, prevState, outSize, activeBatchSize, outSize *
+        batchSize);
   }
-}
-
-template<typename MatType>
-void LSTMType<MatType>::SetBackwardWorkspace(const size_t batchSize)
-{
-  // We need to hold enough space for two time steps.
-  workspace.set_size(12 * outSize, batchSize);
 
-  if (this->CurrentStep() % 2 == 0)
-  {
-    MakeAlias(deltaY, workspace, outSize, batchSize);
-    MakeAlias(deltaBlockInput, workspace, outSize, batchSize,
-        outSize * batchSize);
-    MakeAlias(deltaInputGate, workspace, outSize, batchSize,
-        2 * outSize * batchSize);
-    MakeAlias(deltaForgetGate, workspace, outSize, batchSize,
-        3 * outSize * batchSize);
-    MakeAlias(deltaOutputGate, workspace, outSize, batchSize,
-        4 * outSize * batchSize);
-    MakeAlias(deltaCell, workspace, outSize, batchSize,
-        5 * outSize * batchSize);
-
-    MakeAlias(nextDeltaY, workspace, outSize, batchSize,
-        6 * outSize * batchSize);
-    MakeAlias(nextDeltaBlockInput, workspace, outSize, batchSize,
-        7 * outSize * batchSize);
-    MakeAlias(nextDeltaInputGate, workspace, outSize, batchSize,
-        8 * outSize * batchSize);
-    MakeAlias(nextDeltaForgetGate, workspace, outSize, batchSize,
-        9 * outSize * batchSize);
-    MakeAlias(nextDeltaOutputGate, workspace, outSize, batchSize,
-        10 * outSize * batchSize);
-    MakeAlias(nextDeltaCell, workspace, outSize, batchSize,
-        11 * outSize * batchSize);
-  }
-  else
+  // Also set the workspaces for the backwards pass, if requested.
+  if (backwards)
   {
-    MakeAlias(nextDeltaY, workspace, outSize, batchSize);
-    MakeAlias(nextDeltaBlockInput, workspace, outSize, batchSize,
-        outSize * batchSize);
-    MakeAlias(nextDeltaInputGate, workspace, outSize, batchSize,
-        2 * outSize * batchSize);
-    MakeAlias(nextDeltaForgetGate, workspace, outSize, batchSize,
-        3 * outSize * batchSize);
-    MakeAlias(nextDeltaOutputGate, workspace, outSize, batchSize,
-        4 * outSize * batchSize);
-    MakeAlias(nextDeltaCell, workspace, outSize, batchSize,
-        5 * outSize * batchSize);
-
-    MakeAlias(deltaY, workspace, outSize, batchSize,
-        6 * outSize * batchSize);
-    MakeAlias(deltaBlockInput, workspace, outSize, batchSize,
-        7 * outSize * batchSize);
-    MakeAlias(deltaInputGate, workspace, outSize, batchSize,
-        8 * outSize * batchSize);
-    MakeAlias(deltaForgetGate, workspace, outSize, batchSize,
-        9 * outSize * batchSize);
-    MakeAlias(deltaOutputGate, workspace, outSize, batchSize,
-        10 * outSize * batchSize);
-    MakeAlias(deltaCell, workspace, outSize, batchSize,
-        11 * outSize * batchSize);
+    // We need to hold enough space for two time steps.
+    workspace.set_size(12 * outSize, batchSize);
+
+    if (step % 2 == 0)
+    {
+      MakeAlias(deltaY, workspace, outSize, activeBatchSize);
+      MakeAlias(deltaBlockInput, workspace, outSize, activeBatchSize,
+          outSize * batchSize);
+      MakeAlias(deltaInputGate, workspace, outSize, activeBatchSize,
+          2 * outSize * batchSize);
+      MakeAlias(deltaForgetGate, workspace, outSize, activeBatchSize,
+          3 * outSize * batchSize);
+      MakeAlias(deltaOutputGate, workspace, outSize, activeBatchSize,
+          4 * outSize * batchSize);
+      MakeAlias(deltaCell, workspace, outSize, activeBatchSize,
+          5 * outSize * batchSize);
+
+      MakeAlias(nextDeltaY, workspace, outSize, activeBatchSize,
+          6 * outSize * batchSize);
+      MakeAlias(nextDeltaBlockInput, workspace, outSize, activeBatchSize,
+          7 * outSize * batchSize);
+      MakeAlias(nextDeltaInputGate, workspace, outSize, activeBatchSize,
+          8 * outSize * batchSize);
+      MakeAlias(nextDeltaForgetGate, workspace, outSize, activeBatchSize,
+          9 * outSize * batchSize);
+      MakeAlias(nextDeltaOutputGate, workspace, outSize, activeBatchSize,
+          10 * outSize * batchSize);
+      MakeAlias(nextDeltaCell, workspace, outSize, activeBatchSize,
+          11 * outSize * batchSize);
+    }
+    else
+    {
+      MakeAlias(nextDeltaY, workspace, outSize, activeBatchSize);
+      MakeAlias(nextDeltaBlockInput, workspace, outSize, activeBatchSize,
+          outSize * batchSize);
+      MakeAlias(nextDeltaInputGate, workspace, outSize, activeBatchSize,
+          2 * outSize * batchSize);
+      MakeAlias(nextDeltaForgetGate, workspace, outSize, activeBatchSize,
+          3 * outSize * batchSize);
+      MakeAlias(nextDeltaOutputGate, workspace, outSize, activeBatchSize,
+          4 * outSize * batchSize);
+      MakeAlias(nextDeltaCell, workspace, outSize, activeBatchSize,
+          5 * outSize * batchSize);
+
+      MakeAlias(deltaY, workspace, outSize, activeBatchSize,
+          6 * outSize * batchSize);
+      MakeAlias(deltaBlockInput, workspace, outSize, activeBatchSize,
+          7 * outSize * batchSize);
+      MakeAlias(deltaInputGate, workspace, outSize, activeBatchSize,
+          8 * outSize * batchSize);
+      MakeAlias(deltaForgetGate, workspace, outSize, activeBatchSize,
+          9 * outSize * batchSize);
+      MakeAlias(deltaOutputGate, workspace, outSize, activeBatchSize,
+          10 * outSize * batchSize);
+      MakeAlias(deltaCell, workspace, outSize, activeBatchSize,
+          11 * outSize * batchSize);
+    }
+
+    if (!this->AtFinalStep())
+    {
+      // To update the cell state, we actually need to use the forget gate
+      // values from the next time step.
+      MakeAlias(nextForgetGate, this->RecurrentState(this->CurrentStep() + 1),
+          outSize, activeBatchSize, 4 * outSize * batchSize);
+    }
   }
 }
 
 template<typename MatType>
 template<typename Archive>
-void LSTMType<MatType>::serialize(Archive& ar, const uint32_t /* version */)
+void LSTM<MatType>::serialize(Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<RecurrentLayer<MatType>>(this));
 

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

@@ -56,12 +56,15 @@ class MaxPoolingRule
  *    computation.
  */
 template<typename MatType = arma::mat>
-class MaxPoolingType : public Layer<MatType>
+class MaxPooling : public Layer<MatType>
 {
  public:
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
-  //! Create the MaxPooling object.
-  MaxPoolingType();
+
+  // Create the MaxPooling object.
+  MaxPooling();
 
   /**
    * Create the MaxPooling object using the specified number of units.
@@ -73,26 +76,26 @@ class MaxPoolingType : public Layer<MatType>
    * @param floor If true, then a pooling operation that would oly part of the
    *              input will be skipped.
    */
-  MaxPoolingType(const size_t kernelWidth,
+  MaxPooling(const size_t kernelWidth,
                  const size_t kernelHeight,
                  const size_t strideWidth = 1,
                  const size_t strideHeight = 1,
                  const bool floor = true);
 
   // Virtual destructor.
-  virtual ~MaxPoolingType() { }
+  virtual ~MaxPooling() { }
 
-  //! Copy the given MaxPoolingType.
-  MaxPoolingType(const MaxPoolingType& other);
-  //! Take ownership of the given MaxPoolingType.
-  MaxPoolingType(MaxPoolingType&& other);
-  //! Copy the given MaxPoolingType.
-  MaxPoolingType& operator=(const MaxPoolingType& other);
-  //! Take ownership of the given MaxPoolingType.
-  MaxPoolingType& operator=(MaxPoolingType&& other);
+  //! Copy the given MaxPooling.
+  MaxPooling(const MaxPooling& other);
+  //! Take ownership of the given MaxPooling.
+  MaxPooling(MaxPooling&& other);
+  //! Copy the given MaxPooling.
+  MaxPooling& operator=(const MaxPooling& other);
+  //! Take ownership of the given MaxPooling.
+  MaxPooling& operator=(MaxPooling&& other);
 
-  //! Clone the MaxPoolingType object. This handles polymorphism correctly.
-  MaxPoolingType* Clone() const { return new MaxPoolingType(*this); }
+  //! Clone the MaxPooling object. This handles polymorphism correctly.
+  MaxPooling* Clone() const { return new MaxPooling(*this); }
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -306,10 +309,7 @@ class MaxPoolingType : public Layer<MatType>
 
   //! Locally-stored pooling indices.
   arma::Cube<size_t> poolingIndices;
-}; // class MaxPoolingType
-
-// Standard MaxPooling layer.
-using MaxPooling = MaxPoolingType<arma::mat>;
+}; // class MaxPooling
 
 } // namespace mlpack
 

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

@@ -19,14 +19,14 @@
 namespace mlpack {
 
 template<typename MatType>
-MaxPoolingType<MatType>::MaxPoolingType() :
+MaxPooling<MatType>::MaxPooling() :
     Layer<MatType>()
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-MaxPoolingType<MatType>::MaxPoolingType(
+MaxPooling<MatType>::MaxPooling(
     const size_t kernelWidth,
     const size_t kernelHeight,
     const size_t strideWidth,
@@ -44,8 +44,8 @@ MaxPoolingType<MatType>::MaxPoolingType(
 }
 
 template<typename MatType>
-MaxPoolingType<MatType>::MaxPoolingType(
-    const MaxPoolingType& other) :
+MaxPooling<MatType>::MaxPooling(
+    const MaxPooling& other) :
     Layer<MatType>(other),
     kernelWidth(other.kernelWidth),
     kernelHeight(other.kernelHeight),
@@ -59,8 +59,8 @@ MaxPoolingType<MatType>::MaxPoolingType(
 }
 
 template<typename MatType>
-MaxPoolingType<MatType>::MaxPoolingType(
-    MaxPoolingType&& other) :
+MaxPooling<MatType>::MaxPooling(
+    MaxPooling&& other) :
     Layer<MatType>(std::move(other)),
     kernelWidth(std::move(other.kernelWidth)),
     kernelHeight(std::move(other.kernelHeight)),
@@ -74,8 +74,8 @@ MaxPoolingType<MatType>::MaxPoolingType(
 }
 
 template<typename MatType>
-MaxPoolingType<MatType>&
-MaxPoolingType<MatType>::operator=(const MaxPoolingType& other)
+MaxPooling<MatType>&
+MaxPooling<MatType>::operator=(const MaxPooling& other)
 {
   if (&other != this)
   {
@@ -93,8 +93,8 @@ MaxPoolingType<MatType>::operator=(const MaxPoolingType& other)
 }
 
 template<typename MatType>
-MaxPoolingType<MatType>&
-MaxPoolingType<MatType>::operator=(MaxPoolingType&& other)
+MaxPooling<MatType>&
+MaxPooling<MatType>::operator=(MaxPooling&& other)
 {
   if (&other != this)
   {
@@ -112,7 +112,7 @@ MaxPoolingType<MatType>::operator=(MaxPoolingType&& other)
 }
 
 template<typename MatType>
-void MaxPoolingType<MatType>::Forward(const MatType& input, MatType& output)
+void MaxPooling<MatType>::Forward(const MatType& input, MatType& output)
 {
   using CubeType = typename GetCubeType<MatType>::type;
   CubeType inputTemp;
@@ -139,7 +139,7 @@ void MaxPoolingType<MatType>::Forward(const MatType& input, MatType& output)
 }
 
 template<typename MatType>
-void MaxPoolingType<MatType>::Backward(
+void MaxPooling<MatType>::Backward(
     const MatType& input,
     const MatType& /* output */,
     const MatType& gy,
@@ -167,7 +167,7 @@ void MaxPoolingType<MatType>::Backward(
 }
 
 template<typename MatType>
-void MaxPoolingType<MatType>::ComputeOutputDimensions()
+void MaxPooling<MatType>::ComputeOutputDimensions()
 {
   this->outputDimensions = this->inputDimensions;
 
@@ -197,7 +197,7 @@ void MaxPoolingType<MatType>::ComputeOutputDimensions()
 
 template<typename MatType>
 template<typename Archive>
-void MaxPoolingType<MatType>::serialize(
+void MaxPooling<MatType>::serialize(
     Archive& ar,
     const uint32_t /* version */)
 

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

@@ -26,12 +26,15 @@ namespace mlpack {
  *         computation.
  */
 template <typename MatType = arma::mat>
-class MeanPoolingType : public Layer<MatType>
+class MeanPooling : public Layer<MatType>
 {
  public:
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
-  //! Create the MeanPoolingType object.
-  MeanPoolingType();
+
+  // Create the MeanPooling object.
+  MeanPooling();
 
   /**
    * Create the MeanPooling object using the specified number of units.
@@ -43,26 +46,26 @@ class MeanPoolingType : public Layer<MatType>
    * @param floor If true, then a pooling operation that would oly part of the
    *              input will be skipped.
    */
-  MeanPoolingType(const size_t kernelWidth,
-                  const size_t kernelHeight,
-                  const size_t strideWidth = 1,
-                  const size_t strideHeight = 1,
-                  const bool floor = true);
+  MeanPooling(const size_t kernelWidth,
+              const size_t kernelHeight,
+              const size_t strideWidth = 1,
+              const size_t strideHeight = 1,
+              const bool floor = true);
 
   // Virtual destructor.
-  virtual ~MeanPoolingType() { }
+  virtual ~MeanPooling() { }
 
-  //! Copy the given MeanPoolingType.
-  MeanPoolingType(const MeanPoolingType& other);
-  //! Take ownership of the given MeanPoolingType.
-  MeanPoolingType(MeanPoolingType&& other);
-  //! Copy the given MeanPoolingType.
-  MeanPoolingType& operator=(const MeanPoolingType& other);
-  //! Take ownership of the given MeanPoolingType.
-  MeanPoolingType& operator=(MeanPoolingType&& other);
+  //! Copy the given MeanPooling.
+  MeanPooling(const MeanPooling& other);
+  //! Take ownership of the given MeanPooling.
+  MeanPooling(MeanPooling&& other);
+  //! Copy the given MeanPooling.
+  MeanPooling& operator=(const MeanPooling& other);
+  //! Take ownership of the given MeanPooling.
+  MeanPooling& operator=(MeanPooling&& other);
 
-  //! Clone the MeanPoolingType object. This handles polymorphism correctly.
-  MeanPoolingType* Clone() const { return new MeanPoolingType(*this); }
+  //! Clone the MeanPooling object. This handles polymorphism correctly.
+  MeanPooling* Clone() const { return new MeanPooling(*this); }
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -149,7 +152,7 @@ class MeanPoolingType : public Layer<MatType>
    */
   typename MatType::elem_type Pooling(const MatType& input)
   {
-    return arma::mean(vectorise(input));
+    return mean(vectorise(input));
   }
 
   //! Locally-stored width of the pooling window.
@@ -169,10 +172,7 @@ class MeanPoolingType : public Layer<MatType>
 
   //! Locally-stored number channels.
   size_t channels;
-}; // class MeanPoolingType
-
-// Standard MeanPooling layer.
-using MeanPooling = MeanPoolingType<arma::mat>;
+}; // class MeanPooling
 
 } // namespace mlpack