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

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

@@ -0,0 +1,189 @@
+/**
+ * @file methods/ann/layer/embedding_impl.hpp
+ * @author Marcus Edel
+ *
+ * Implementation of the Embedding layer class.
+ *
+ * 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_METHODS_ANN_LAYER_EMBEDDING_IMPL_HPP
+#define MLPACK_METHODS_ANN_LAYER_EMBEDDING_IMPL_HPP
+
+// In case it hasn't yet been included.
+#include "embedding.hpp"
+
+namespace mlpack {
+
+template<typename MatType, typename RegularizerType>
+Embedding<MatType, RegularizerType>::Embedding() :
+    Layer<MatType>(),
+    vocabSize(0),
+    embeddingSize(0)
+{
+  // Nothing to do here.
+}
+
+template<typename MatType, typename RegularizerType>
+Embedding<MatType, RegularizerType>::Embedding(
+    const size_t vocabSize,
+    const size_t embeddingSize,
+    RegularizerType regularizer) :
+    Layer<MatType>(),
+    vocabSize(vocabSize),
+    embeddingSize(embeddingSize),
+    regularizer(regularizer)
+{
+  // Nothing to do here.
+}
+
+// Copy constructor.
+template<typename MatType, typename RegularizerType>
+Embedding<MatType, RegularizerType>::Embedding(const Embedding& layer) :
+    Layer<MatType>(layer),
+    vocabSize(layer.vocabSize),
+    embeddingSize(layer.embeddingSize),
+    regularizer(layer.regularizer)
+{
+  // Nothing else to do.
+}
+
+// Move constructor.
+template<typename MatType, typename RegularizerType>
+Embedding<MatType, RegularizerType>::Embedding(Embedding&& layer) :
+    Layer<MatType>(std::move(layer)),
+    vocabSize(std::move(layer.vocabSize)),
+    embeddingSize(std::move(layer.embeddingSize)),
+    regularizer(std::move(layer.regularizer))
+{
+  // Reset parameters of other layer.
+  layer.vocabSize = 0;
+  layer.embeddingSize = 0;
+}
+
+template<typename MatType, typename RegularizerType>
+Embedding<MatType, RegularizerType>&
+Embedding<MatType, RegularizerType>::operator=(const Embedding& layer)
+{
+  if (&layer != this)
+  {
+    Layer<MatType>::operator=(layer);
+    vocabSize = layer.vocabSize;
+    embeddingSize = layer.embeddingSize;
+    regularizer = layer.regularizer;
+  }
+
+  return *this;
+}
+
+template<typename MatType, typename RegularizerType>
+Embedding<MatType, RegularizerType>&
+Embedding<MatType, RegularizerType>::operator=(
+    Embedding&& layer)
+{
+  if (&layer != this)
+  {
+    Layer<MatType>::operator=(std::move(layer));
+    vocabSize = std::move(layer.vocabSize);
+    embeddingSize = std::move(layer.embeddingSize);
+    regularizer = std::move(layer.regularizer);
+
+    // Reset parameters of other layer.
+    layer.vocabSize = 0;
+    layer.embeddingSize = 0;
+  }
+
+  return *this;
+}
+
+template<typename MatType, typename RegularizerType>
+void Embedding<MatType, RegularizerType>::SetWeights(const MatType& weightsIn)
+{
+  // The weights matrix is of size (embeddingSize, vocabSize).  Each vocabulary
+  // item's embedding is represented in a single column.
+  MakeAlias(weights, weightsIn, embeddingSize, vocabSize);
+}
+
+template<typename MatType, typename RegularizerType>
+void Embedding<MatType, RegularizerType>::Forward(
+    const MatType& input, MatType& output)
+{
+  const size_t batchSize = input.n_cols;
+  for (size_t i = 0; i < batchSize; ++i)
+  {
+    // ith column of output is a vectorized form of a matrix of shape
+    // (seqLength, embeddingSize) selected as a combination of rows from the
+    // weights. The MultiheadAttention class requires this particular ordering
+    // of matrix dimensions.
+    output.col(i) = vectorise(weights.cols(
+        arma::conv_to<arma::uvec>::from(input.col(i))));
+  }
+}
+
+template<typename MatType, typename RegularizerType>
+void Embedding<MatType, RegularizerType>::Backward(
+    const MatType& /* input */,
+    const MatType& /* output */,
+    const MatType& /* gy */,
+    MatType& g)
+{
+  // NOTE: Embedding should be the first layer of a network, and shouldn't be
+  // used as an intermediate layer!  So Backward() does nothing except set g to
+  // zeros.
+  g.zeros();
+}
+
+template<typename MatType, typename RegularizerType>
+void Embedding<MatType, RegularizerType>::Gradient(
+    const MatType& input,
+    const MatType& error,
+    MatType& gradient)
+{
+  const size_t seqLength = input.n_rows;
+  const size_t batchSize = input.n_cols;
+
+  const CubeType errorTemp;
+  MakeAlias(const_cast<CubeType&>(errorTemp), error, embeddingSize, seqLength,
+      batchSize, 0, false);
+  MatType gradTemp;
+  MakeAlias(gradTemp, gradient, embeddingSize, vocabSize);
+
+  gradient.zeros();
+  for (size_t j = 0; j < batchSize; ++j)
+  {
+    for (size_t i = 0; i < seqLength; ++i)
+    {
+      gradTemp.col((size_t) input(i, j)) += errorTemp.slice(j).col(i);
+    }
+  }
+}
+
+template<typename MatType, typename RegularizerType>
+void Embedding<MatType, RegularizerType>::ComputeOutputDimensions()
+{
+  // The Embedding layer returns a two-dimensional output and flattens its
+  // input.
+  this->outputDimensions.clear();
+  this->outputDimensions.push_back(this->embeddingSize);
+  this->outputDimensions.push_back(this->inputDimensions[0]);
+  for (size_t i = 1; i < this->inputDimensions.size(); ++i)
+    this->outputDimensions[1] *= this->inputDimensions[i];
+}
+
+template<typename MatType, typename RegularizerType>
+template<typename Archive>
+void Embedding<MatType, RegularizerType>::serialize(
+    Archive& ar, const uint32_t /* version */)
+{
+  ar(cereal::base_class<Layer<MatType>>(this));
+
+  ar(CEREAL_NVP(vocabSize));
+  ar(CEREAL_NVP(embeddingSize));
+  ar(CEREAL_NVP(regularizer));
+}
+
+} // namespace mlpack
+
+#endif

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

@@ -52,9 +52,12 @@ namespace mlpack {
  *         (Default: arma::mat).
  */
 template<typename MatType = arma::mat>
-class FlexibleReLUType : public Layer<MatType>
+class FlexibleReLU : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the FlexibleReLU object using the specified alpha parameter.
    * The trainable alpha parameter controls the range of the ReLU function.
@@ -62,22 +65,22 @@ class FlexibleReLUType : public Layer<MatType>
    *
    * @param alpha Parameter to adjust the range of the ReLU function.
    */
-  FlexibleReLUType(const double alpha = 0);
+  FlexibleReLU(const double alpha = 0);
 
-  //! Clone the FlexibleReLUType object. This handles polymorphism correctly.
-  FlexibleReLUType* Clone() const { return new FlexibleReLUType(*this); }
+  //! Clone the FlexibleReLU object. This handles polymorphism correctly.
+  FlexibleReLU* Clone() const { return new FlexibleReLU(*this); }
 
   // Virtual destructor.
-  virtual ~FlexibleReLUType() { }
+  virtual ~FlexibleReLU() { }
 
-  //! Copy the given FlexibleReLUType.
-  FlexibleReLUType(const FlexibleReLUType& other);
-  //! Take ownership of the given FlexibleReLUType.
-  FlexibleReLUType(FlexibleReLUType&& other);
-  //! Copy the given FlexibleReLUType.
-  FlexibleReLUType& operator=(const FlexibleReLUType& other);
-  //! Take ownership of the given FlexibleReLUType.
-  FlexibleReLUType& operator=(FlexibleReLUType&& other);
+  //! Copy the given FlexibleReLU.
+  FlexibleReLU(const FlexibleReLU& other);
+  //! Take ownership of the given FlexibleReLU.
+  FlexibleReLU(FlexibleReLU&& other);
+  //! Copy the given FlexibleReLU.
+  FlexibleReLU& operator=(const FlexibleReLU& other);
+  //! Take ownership of the given FlexibleReLU.
+  FlexibleReLU& operator=(FlexibleReLU&& other);
 
   /**
    * Reset the layer parameter (alpha). The method is called to
@@ -155,12 +158,7 @@ class FlexibleReLUType : public Layer<MatType>
 
   //! Parameter controlling the range of the ReLU function.
   double userAlpha;
-}; // class FlexibleReLUType
-
-// Convenience typedefs.
-
-// Standard flexible ReLU layer.
-using FlexibleReLU = FlexibleReLUType<arma::mat>;
+}; // class FlexibleReLU
 
 } // namespace mlpack
 

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

@@ -22,7 +22,7 @@
 namespace mlpack {
 
 template<typename MatType>
-FlexibleReLUType<MatType>::FlexibleReLUType(const double userAlpha) :
+FlexibleReLU<MatType>::FlexibleReLU(const double userAlpha) :
     Layer<MatType>(),
     userAlpha(userAlpha)
 {
@@ -30,8 +30,8 @@ FlexibleReLUType<MatType>::FlexibleReLUType(const double userAlpha) :
 }
 
 template<typename MatType>
-FlexibleReLUType<MatType>::FlexibleReLUType(
-    const FlexibleReLUType& other) :
+FlexibleReLU<MatType>::FlexibleReLU(
+    const FlexibleReLU& other) :
     Layer<MatType>(other),
     userAlpha(other.userAlpha)
 {
@@ -39,8 +39,8 @@ FlexibleReLUType<MatType>::FlexibleReLUType(
 }
 
 template<typename MatType>
-FlexibleReLUType<MatType>::FlexibleReLUType(
-    FlexibleReLUType&& other) :
+FlexibleReLU<MatType>::FlexibleReLU(
+    FlexibleReLU&& other) :
     Layer<MatType>(std::move(other)),
     userAlpha(std::move(other.userAlpha))
 {
@@ -48,8 +48,8 @@ FlexibleReLUType<MatType>::FlexibleReLUType(
 }
 
 template<typename MatType>
-FlexibleReLUType<MatType>&
-FlexibleReLUType<MatType>::operator=(const FlexibleReLUType& other)
+FlexibleReLU<MatType>&
+FlexibleReLU<MatType>::operator=(const FlexibleReLU& other)
 {
   if (&other != this)
   {
@@ -61,8 +61,8 @@ FlexibleReLUType<MatType>::operator=(const FlexibleReLUType& other)
 }
 
 template<typename MatType>
-FlexibleReLUType<MatType>&
-FlexibleReLUType<MatType>::operator=(FlexibleReLUType&& other)
+FlexibleReLU<MatType>&
+FlexibleReLU<MatType>::operator=(FlexibleReLU&& other)
 {
   if (&other != this)
   {
@@ -74,46 +74,46 @@ FlexibleReLUType<MatType>::operator=(FlexibleReLUType&& other)
 }
 
 template<typename MatType>
-void FlexibleReLUType<MatType>::SetWeights(const MatType& weights)
+void FlexibleReLU<MatType>::SetWeights(const MatType& weights)
 {
   MakeAlias(alpha, weights, 1, 1);
 }
 
 template<typename MatType>
-void FlexibleReLUType<MatType>::CustomInitialize(
+void FlexibleReLU<MatType>::CustomInitialize(
     MatType& W,
     const size_t elements)
 {
   if (elements != 1)
   {
-    throw std::invalid_argument("FlexibleReLUType::CustomInitialize(): wrong "
+    throw std::invalid_argument("FlexibleReLU::CustomInitialize(): wrong "
         "elements size!");
   }
 
-  W(0) = userAlpha;
+  W(0) = ElemType(userAlpha);
 }
 
 template<typename MatType>
-void FlexibleReLUType<MatType>::Forward(
+void FlexibleReLU<MatType>::Forward(
     const MatType& input, MatType& output)
 {
-  output = arma::clamp(input, 0.0,
-      std::numeric_limits<typename MatType::elem_type>::max()) + alpha(0);
+  output = arma::clamp(input, 0,
+      std::numeric_limits<ElemType>::max()) + alpha(0);
 }
 
 template<typename MatType>
-void FlexibleReLUType<MatType>::Backward(
+void FlexibleReLU<MatType>::Backward(
     const MatType& input,
     const MatType& /* output */,
     const MatType& gy,
     MatType& g)
 {
   // Compute the first derivative of FlexibleReLU function.
-  g = gy % (input > 0);
+  g = gy % conv_to<MatType>::from(input > 0);
 }
 
 template<typename MatType>
-void FlexibleReLUType<MatType>::Gradient(
+void FlexibleReLU<MatType>::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
@@ -123,7 +123,7 @@ void FlexibleReLUType<MatType>::Gradient(
 
 template<typename MatType>
 template<typename Archive>
-void FlexibleReLUType<MatType>::serialize(
+void FlexibleReLU<MatType>::serialize(
     Archive& ar,
     const uint32_t /* version*/)
 {

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

@@ -42,32 +42,34 @@ namespace mlpack {
  *    computation.
  */
 template<typename MatType = arma::mat>
-class FTSwishType : public Layer<MatType>
+class FTSwish : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the Flatten T Swish object using the specified parameters.
    * The thresholded value T can be adjusted via T paramaters.
    * When the x is < 0, T will be used instead of 0.
    * The default value of T is -0.20 as suggested in the paper.
-   * @param T 
    */
-  FTSwishType(const double T = -0.20);
+  FTSwish(const double T = -0.20);
 
-  //! Clone the FTSwishType object. This handles polymorphism correctly.
-  FTSwishType* Clone() const { return new FTSwishType(*this); }
+  //! Clone the FTSwish object. This handles polymorphism correctly.
+  FTSwish* Clone() const { return new FTSwish(*this); }
 
   // Virtual destructor.
-  virtual ~FTSwishType() { }
+  virtual ~FTSwish() { }
 
-  //! Copy the given FTSwishType.
-  FTSwishType(const FTSwishType& other);
-  //! Take ownership of the given FTSwishType.
-  FTSwishType(FTSwishType&& other);
-  //! Copy the given FTSwishType.
-  FTSwishType& operator=(const FTSwishType& other);
-  //! Take ownership of the given FTSwishType.
-  FTSwishType& operator=(FTSwishType&& other);
+  //! Copy the given FTSwish.
+  FTSwish(const FTSwish& other);
+  //! Take ownership of the given FTSwish.
+  FTSwish(FTSwish&& other);
+  //! Copy the given FTSwish.
+  FTSwish& operator=(const FTSwish& other);
+  //! Take ownership of the given FTSwish.
+  FTSwish& operator=(FTSwish&& other);
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -105,10 +107,7 @@ class FTSwishType : public Layer<MatType>
  private:
   //! Threshold value for x < 0.
   double T;
-}; // class FTSwishType
-
-// Convenience typedefs.
-using FTSwish = FTSwishType<arma::mat>;
+}; // class FTSwish
 
 } // namespace mlpack
 

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

@@ -4,7 +4,6 @@
  *
  * Definition of Flatten T Swish layer first introduced in the acoustic model,
  * Hock Hung Chieng, Noorhaniza Wahid, Pauline Ong, Sai Raj Kishore Perla,
- * 
  *
  * 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
@@ -20,7 +19,7 @@
 namespace mlpack {
 
 template<typename MatType>
-FTSwishType<MatType>::FTSwishType(const double T) :
+FTSwish<MatType>::FTSwish(const double T) :
     Layer<MatType>(),
     T(T)
 {
@@ -28,7 +27,7 @@ FTSwishType<MatType>::FTSwishType(const double T) :
 }
 
 template<typename MatType>
-FTSwishType<MatType>::FTSwishType(const FTSwishType& other) :
+FTSwish<MatType>::FTSwish(const FTSwish& other) :
     Layer<MatType>(other),
     T(other.T)
 {
@@ -36,7 +35,7 @@ FTSwishType<MatType>::FTSwishType(const FTSwishType& other) :
 }
 
 template<typename MatType>
-FTSwishType<MatType>::FTSwishType(FTSwishType&& other) :
+FTSwish<MatType>::FTSwish(FTSwish&& other) :
     Layer<MatType>(std::move(other)),
     T(std::move(other.T))
 {
@@ -44,8 +43,8 @@ FTSwishType<MatType>::FTSwishType(FTSwishType&& other) :
 }
 
 template<typename MatType>
-FTSwishType<MatType>&
-FTSwishType<MatType>::operator=(const FTSwishType& other)
+FTSwish<MatType>&
+FTSwish<MatType>::operator=(const FTSwish& other)
 {
   if (&other != this)
   {
@@ -57,8 +56,8 @@ FTSwishType<MatType>::operator=(const FTSwishType& other)
 }
 
 template<typename MatType>
-FTSwishType<MatType>&
-FTSwishType<MatType>::operator=(FTSwishType&& other)
+FTSwish<MatType>&
+FTSwish<MatType>::operator=(FTSwish&& other)
 {
   if (&other != this)
   {
@@ -70,45 +69,28 @@ FTSwishType<MatType>::operator=(FTSwishType&& other)
 }
 
 template<typename MatType>
-void FTSwishType<MatType>::Forward(const MatType& input, MatType& output)
+void FTSwish<MatType>::Forward(const MatType& input, MatType& output)
 {
-  #pragma omp for
-  for (size_t i = 0; i < (size_t) input.n_elem; ++i)
-  {
-    if (input(i) >= 0)
-      output(i) = input(i) / (1 + std::exp(-input(i))) + T;
-    else
-      output(i) = T;
-  }
+  output = ElemType(T) + clamp(input, 0,
+      std::numeric_limits<ElemType>::max()) /
+      (1 + exp(-input));
 }
 
 template<typename MatType>
-void FTSwishType<MatType>::Backward(
+void FTSwish<MatType>::Backward(
     const MatType& input,
-    const MatType& /* output */,
+    const MatType& output,
     const MatType& gy,
     MatType& g)
 {
-  #pragma omp for
-  for (size_t i = 0; i < (size_t) input.n_elem; ++i)
-  {
-    if (input(i) >= 0)
-    {
-      const double sigmoidX = 1 / (1 + std::exp(-input(i)));
-      const double fX = input(i) * sigmoidX;
-
-      g(i) = gy(i) * (sigmoidX * (1 - fX) + fX);
-    }
-    else
-    {
-      g(i) = 0;
-    }
-  }
+  const ElemType convT = ElemType(T);
+  g = gy % sign(output - convT) % (((output - convT) / input) %
+      (1 - (output - convT)) + (output - convT));
 }
 
 template<typename MatType>
 template<typename Archive>
-void FTSwishType<MatType>::serialize(
+void FTSwish<MatType>::serialize(
     Archive& ar,
     const uint32_t /* version */)
 {

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

@@ -17,8 +17,7 @@
 
 #include <mlpack/methods/ann/convolution_rules/border_modes.hpp>
 #include <mlpack/methods/ann/convolution_rules/naive_convolution.hpp>
-#include <mlpack/methods/ann/convolution_rules/fft_convolution.hpp>
-#include <mlpack/methods/ann/convolution_rules/svd_convolution.hpp>
+#include <mlpack/methods/ann/convolution_rules/im2col_convolution.hpp>
 #include <mlpack/core/util/to_lower.hpp>
 
 #include "layer.hpp"
@@ -69,21 +68,23 @@ namespace mlpack {
  *    computation.
  */
 template <
-    typename ForwardConvolutionRule = NaiveConvolution<ValidConvolution>,
-    typename BackwardConvolutionRule = NaiveConvolution<FullConvolution>,
-    typename GradientConvolutionRule = NaiveConvolution<ValidConvolution>,
-    typename MatType = arma::mat
+    typename MatType = arma::mat,
+    typename ForwardConvolutionRule = Im2ColConvolution<ValidConvolution>,
+    typename BackwardConvolutionRule = Im2ColConvolution<FullConvolution>,
+    typename GradientConvolutionRule = Im2ColConvolution<ValidConvolution>
 >
-class GroupedConvolutionType : public Layer<MatType>
+class GroupedConvolution : public Layer<MatType>
 {
  public:
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
 
-  //! Create the GroupedConvolutionType object.
-  GroupedConvolutionType();
+  // Create the GroupedConvolution object.
+  GroupedConvolution();
 
   /**
-   * Create the GroupedConvolutionType object using the specified number of
+   * Create the GroupedConvolution object using the specified number of
    * output maps, filter size, stride and padding parameter.
    *
    * @param maps The number of output maps.
@@ -99,7 +100,7 @@ class GroupedConvolutionType : public Layer<MatType>
    *    will be used.
    * @param useBias Whether or not to use a bias with the convolution.
    */
-  GroupedConvolutionType(const size_t maps,
+  GroupedConvolution(const size_t maps,
                          const size_t kernelWidth,
                          const size_t kernelHeight,
                          const size_t groups,
@@ -131,7 +132,7 @@ class GroupedConvolutionType : public Layer<MatType>
    *      will be used.
    * @param useBias Whether or not to use a bias with the convolution.
    */
-  GroupedConvolutionType(const size_t maps,
+  GroupedConvolution(const size_t maps,
                          const size_t kernelWidth,
                          const size_t kernelHeight,
                          const size_t groups,
@@ -142,27 +143,27 @@ class GroupedConvolutionType : public Layer<MatType>
                          const std::string& paddingType = "none",
                          const bool useBias = true);
 
-  //! Clone the GroupedConvolutionType object. This handles polymorphism
+  //! Clone the GroupedConvolution object. This handles polymorphism
   //! correctly.
-  GroupedConvolutionType* Clone() const
+  GroupedConvolution* Clone() const
   {
-    return new GroupedConvolutionType(*this);
+    return new GroupedConvolution(*this);
   }
 
-  //! Copy the given GroupedConvolutionType (but not weights).
-  GroupedConvolutionType(const GroupedConvolutionType& layer);
+  //! Copy the given GroupedConvolution (but not weights).
+  GroupedConvolution(const GroupedConvolution& layer);
 
-  //! Take ownership of the given GroupedConvolutionType (but not weights).
-  GroupedConvolutionType(GroupedConvolutionType&&);
+  //! Take ownership of the given GroupedConvolution (but not weights).
+  GroupedConvolution(GroupedConvolution&&);
 
-  //! Copy the given GroupedConvolutionType (but not weights).
-  GroupedConvolutionType& operator=(const GroupedConvolutionType& layer);
+  //! Copy the given GroupedConvolution (but not weights).
+  GroupedConvolution& operator=(const GroupedConvolution& layer);
 
-  //! Take ownership of the given GroupedConvolutionType (but not weights).
-  GroupedConvolutionType& operator=(GroupedConvolutionType&& layer);
+  //! Take ownership of the given GroupedConvolution (but not weights).
+  GroupedConvolution& operator=(GroupedConvolution&& layer);
 
   // Virtual destructor.
-  virtual ~GroupedConvolutionType() { }
+  virtual ~GroupedConvolution() { }
 
   /*
    * Set the weight and bias term.
@@ -396,10 +397,10 @@ class GroupedConvolutionType : public Layer<MatType>
   CubeType gradientTemp;
 
   //! Locally-stored padding layer.
-  PaddingType<MatType> padding;
+  Padding<MatType> padding;
 
   //! Locally-stored padding layer for backward pass.
-  PaddingType<MatType> paddingBackward;
+  Padding<MatType> paddingBackward;
 
   //! Type of padding.
   std::string paddingType;
@@ -416,13 +417,6 @@ class GroupedConvolutionType : public Layer<MatType>
   size_t apparentHeight;
 }; // class Convolution
 
-// Standard Convolution layer.
-using GroupedConvolution = GroupedConvolutionType<
-    NaiveConvolution<ValidConvolution>,
-    NaiveConvolution<FullConvolution>,
-    NaiveConvolution<ValidConvolution>,
-    arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.