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

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

@@ -38,11 +38,14 @@ template<
     typename MatType = arma::mat,
     typename RegularizerType = NoRegularizer
 >
-class LinearType : public Layer<MatType>
+class Linear : public Layer<MatType>
 {
  public:
-  //! Create the Linear object.
-  LinearType();
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
+  // Create the Linear object.
+  Linear();
 
   /**
    * Create the Linear layer object with the specified number of output
@@ -52,25 +55,25 @@ class LinearType : public Layer<MatType>
    * @param regularizer The regularizer to use, optional (default: no
    *     regularizer).
    */
-  LinearType(const size_t outSize,
-             RegularizerType regularizer = RegularizerType());
+  Linear(const size_t outSize,
+         RegularizerType regularizer = RegularizerType());
 
-  virtual ~LinearType() { }
+  virtual ~Linear() { }
 
-  //! Clone the LinearType object. This handles polymorphism correctly.
-  LinearType* Clone() const { return new LinearType(*this); }
+  //! Clone the Linear object. This handles polymorphism correctly.
+  Linear* Clone() const { return new Linear(*this); }
 
   //! Copy the other Linear layer (but not weights).
-  LinearType(const LinearType& layer);
+  Linear(const Linear& layer);
 
   //! Take ownership of the members of the other Linear layer (but not weights).
-  LinearType(LinearType&& layer);
+  Linear(Linear&& layer);
 
   //! Copy the other Linear layer (but not weights).
-  LinearType& operator=(const LinearType& layer);
+  Linear& operator=(const Linear& layer);
 
   //! Take ownership of the members of the other Linear layer (but not weights).
-  LinearType& operator=(LinearType&& layer);
+  Linear& operator=(Linear&& layer);
 
   /**
    * Reset the layer parameter (weights and bias). The method is called to
@@ -162,12 +165,7 @@ class LinearType : public Layer<MatType>
 
   //! Locally-stored regularizer object.
   RegularizerType regularizer;
-}; // class LinearType
-
-// Convenience typedefs.
-
-// Standard Linear layer using no regularization.
-using Linear = LinearType<arma::mat, NoRegularizer>;
+}; // class Linear
 
 } // namespace mlpack
 

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

@@ -34,12 +34,15 @@ template<
     typename MatType = arma::mat,
     typename RegularizerType = NoRegularizer
 >
-class Linear3DType : public Layer<MatType>
+class Linear3D : public Layer<MatType>
 {
  public:
+  // Convenience typedefs.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
-  //! Create the Linear3D object.
-  Linear3DType();
+
+  // Create the Linear3D object.
+  Linear3D();
 
   /**
    * Create the Linear3D layer object using the specified number of output
@@ -48,23 +51,23 @@ class Linear3DType : public Layer<MatType>
    * @param outSize The number of output units.
    * @param regularizer The regularizer to use, optional.
    */
-  Linear3DType(const size_t outSize,
+  Linear3D(const size_t outSize,
                RegularizerType regularizer = RegularizerType());
 
-  //! Clone the Linear3DType object. This handles polymorphism correctly.
-  Linear3DType* Clone() const { return new Linear3DType(*this); }
+  //! Clone the Linear3D object. This handles polymorphism correctly.
+  Linear3D* Clone() const { return new Linear3D(*this); }
 
   // Virtual destructor.
-  virtual ~Linear3DType() { }
+  virtual ~Linear3D() { }
 
-  //! Copy the given Linear3DType (but not weights).
-  Linear3DType(const Linear3DType& other);
-  //! Take ownership of the given Linear3DType (but not weights).
-  Linear3DType(Linear3DType&& other);
-  //! Copy the given Linear3DType (but not weights).
-  Linear3DType& operator=(const Linear3DType& other);
-  //! Take ownership of the given Linear3DType (but not weights).
-  Linear3DType& operator=(Linear3DType&& other);
+  //! Copy the given Linear3D (but not weights).
+  Linear3D(const Linear3D& other);
+  //! Take ownership of the given Linear3D (but not weights).
+  Linear3D(Linear3D&& other);
+  //! Copy the given Linear3D (but not weights).
+  Linear3D& operator=(const Linear3D& other);
+  //! Take ownership of the given Linear3D (but not weights).
+  Linear3D& operator=(Linear3D&& other);
 
   /*
    * Reset the layer parameter.
@@ -150,9 +153,6 @@ class Linear3DType : public Layer<MatType>
   RegularizerType regularizer;
 }; // class Linear
 
-// Standard Linear3D layer.
-using Linear3D = Linear3DType<arma::mat, NoRegularizer>;
-
 } // namespace mlpack
 
 // Include implementation.

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

@@ -18,7 +18,7 @@
 namespace mlpack {
 
 template<typename MatType, typename RegularizerType>
-Linear3DType<MatType, RegularizerType>::Linear3DType() :
+Linear3D<MatType, RegularizerType>::Linear3D() :
     Layer<MatType>(),
     outSize(0)
 {
@@ -26,7 +26,7 @@ Linear3DType<MatType, RegularizerType>::Linear3DType() :
 }
 
 template<typename MatType, typename RegularizerType>
-Linear3DType<MatType, RegularizerType>::Linear3DType(
+Linear3D<MatType, RegularizerType>::Linear3D(
     const size_t outSize,
     RegularizerType regularizer) :
     Layer<MatType>(),
@@ -35,8 +35,8 @@ Linear3DType<MatType, RegularizerType>::Linear3DType(
 { }
 
 template<typename MatType, typename RegularizerType>
-Linear3DType<MatType, RegularizerType>::Linear3DType(
-    const Linear3DType& other) :
+Linear3D<MatType, RegularizerType>::Linear3D(
+    const Linear3D& other) :
     Layer<MatType>(other),
     outSize(other.outSize),
     regularizer(other.regularizer)
@@ -45,8 +45,8 @@ Linear3DType<MatType, RegularizerType>::Linear3DType(
 }
 
 template<typename MatType, typename RegularizerType>
-Linear3DType<MatType, RegularizerType>::Linear3DType(
-    Linear3DType&& other) :
+Linear3D<MatType, RegularizerType>::Linear3D(
+    Linear3D&& other) :
     Layer<MatType>(std::move(other)),
     outSize(std::move(other.outSize)),
     regularizer(std::move(other.regularizer))
@@ -55,9 +55,9 @@ Linear3DType<MatType, RegularizerType>::Linear3DType(
 }
 
 template<typename MatType, typename RegularizerType>
-Linear3DType<MatType, RegularizerType>&
-Linear3DType<MatType, RegularizerType>::operator=(
-    const Linear3DType& other)
+Linear3D<MatType, RegularizerType>&
+Linear3D<MatType, RegularizerType>::operator=(
+    const Linear3D& other)
 {
   if (&other != this)
   {
@@ -70,9 +70,9 @@ Linear3DType<MatType, RegularizerType>::operator=(
 }
 
 template<typename MatType, typename RegularizerType>
-Linear3DType<MatType, RegularizerType>&
-Linear3DType<MatType, RegularizerType>::operator=(
-    Linear3DType&& other)
+Linear3D<MatType, RegularizerType>&
+Linear3D<MatType, RegularizerType>::operator=(
+    Linear3D&& other)
 {
   if (&other != this)
   {
@@ -85,7 +85,7 @@ Linear3DType<MatType, RegularizerType>::operator=(
 }
 
 template<typename MatType, typename RegularizerType>
-void Linear3DType<MatType, RegularizerType>::SetWeights(
+void Linear3D<MatType, RegularizerType>::SetWeights(
     const MatType& weightsIn)
 {
   MakeAlias(weights, weightsIn, outSize * this->inputDimensions[0] + outSize,
@@ -95,7 +95,7 @@ void Linear3DType<MatType, RegularizerType>::SetWeights(
 }
 
 template<typename MatType, typename RegularizerType>
-void Linear3DType<MatType, RegularizerType>::Forward(
+void Linear3D<MatType, RegularizerType>::Forward(
     const MatType& input, MatType& output)
 {
   const size_t nPoints = input.n_rows / this->inputDimensions[0];
@@ -116,7 +116,7 @@ void Linear3DType<MatType, RegularizerType>::Forward(
 }
 
 template<typename MatType, typename RegularizerType>
-void Linear3DType<MatType, RegularizerType>::Backward(
+void Linear3D<MatType, RegularizerType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -144,7 +144,7 @@ void Linear3DType<MatType, RegularizerType>::Backward(
 }
 
 template<typename MatType, typename RegularizerType>
-void Linear3DType<MatType, RegularizerType>::Gradient(
+void Linear3D<MatType, RegularizerType>::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
@@ -178,7 +178,7 @@ void Linear3DType<MatType, RegularizerType>::Gradient(
 }
 
 template<typename MatType, typename RegularizerType>
-void Linear3DType<
+void Linear3D<
     MatType, RegularizerType
 >::ComputeOutputDimensions()
 {
@@ -191,7 +191,7 @@ void Linear3DType<
 
 template<typename MatType, typename RegularizerType>
 template<typename Archive>
-void Linear3DType<MatType, RegularizerType>::serialize(
+void Linear3D<MatType, RegularizerType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));

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

@@ -19,7 +19,7 @@
 namespace mlpack {
 
 template<typename MatType, typename RegularizerType>
-LinearType<MatType, RegularizerType>::LinearType() :
+Linear<MatType, RegularizerType>::Linear() :
     Layer<MatType>(),
     inSize(0),
     outSize(0)
@@ -28,7 +28,7 @@ LinearType<MatType, RegularizerType>::LinearType() :
 }
 
 template<typename MatType, typename RegularizerType>
-LinearType<MatType, RegularizerType>::LinearType(
+Linear<MatType, RegularizerType>::Linear(
     const size_t outSize,
     RegularizerType regularizer) :
     Layer<MatType>(),
@@ -41,7 +41,7 @@ LinearType<MatType, RegularizerType>::LinearType(
 
 // Copy constructor.
 template<typename MatType, typename RegularizerType>
-LinearType<MatType, RegularizerType>::LinearType(const LinearType& layer) :
+Linear<MatType, RegularizerType>::Linear(const Linear& layer) :
     Layer<MatType>(layer),
     inSize(layer.inSize),
     outSize(layer.outSize),
@@ -52,7 +52,7 @@ LinearType<MatType, RegularizerType>::LinearType(const LinearType& layer) :
 
 // Move constructor.
 template<typename MatType, typename RegularizerType>
-LinearType<MatType, RegularizerType>::LinearType(LinearType&& layer) :
+Linear<MatType, RegularizerType>::Linear(Linear&& layer) :
     Layer<MatType>(std::move(layer)),
     inSize(std::move(layer.inSize)),
     outSize(std::move(layer.outSize)),
@@ -64,8 +64,8 @@ LinearType<MatType, RegularizerType>::LinearType(LinearType&& layer) :
 }
 
 template<typename MatType, typename RegularizerType>
-LinearType<MatType, RegularizerType>&
-LinearType<MatType, RegularizerType>::operator=(const LinearType& layer)
+Linear<MatType, RegularizerType>&
+Linear<MatType, RegularizerType>::operator=(const Linear& layer)
 {
   if (&layer != this)
   {
@@ -79,9 +79,9 @@ LinearType<MatType, RegularizerType>::operator=(const LinearType& layer)
 }
 
 template<typename MatType, typename RegularizerType>
-LinearType<MatType, RegularizerType>&
-LinearType<MatType, RegularizerType>::operator=(
-    LinearType&& layer)
+Linear<MatType, RegularizerType>&
+Linear<MatType, RegularizerType>::operator=(
+    Linear&& layer)
 {
   if (&layer != this)
   {
@@ -99,7 +99,7 @@ LinearType<MatType, RegularizerType>::operator=(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearType<MatType, RegularizerType>::SetWeights(const MatType& weightsIn)
+void Linear<MatType, RegularizerType>::SetWeights(const MatType& weightsIn)
 {
   MakeAlias(weights, weightsIn, outSize * inSize + outSize, 1);
   MakeAlias(weight, weightsIn, outSize, inSize);
@@ -107,7 +107,7 @@ void LinearType<MatType, RegularizerType>::SetWeights(const MatType& weightsIn)
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearType<MatType, RegularizerType>::Forward(
+void Linear<MatType, RegularizerType>::Forward(
     const MatType& input, MatType& output)
 {
   output = weight * input;
@@ -118,7 +118,7 @@ void LinearType<MatType, RegularizerType>::Forward(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearType<MatType, RegularizerType>::Backward(
+void Linear<MatType, RegularizerType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -128,7 +128,7 @@ void LinearType<MatType, RegularizerType>::Backward(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearType<MatType, RegularizerType>::Gradient(
+void Linear<MatType, RegularizerType>::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
@@ -139,7 +139,7 @@ void LinearType<MatType, RegularizerType>::Gradient(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearType<MatType, RegularizerType>::ComputeOutputDimensions()
+void Linear<MatType, RegularizerType>::ComputeOutputDimensions()
 {
   inSize = this->inputDimensions[0];
   for (size_t i = 1; i < this->inputDimensions.size(); ++i)
@@ -153,7 +153,7 @@ void LinearType<MatType, RegularizerType>::ComputeOutputDimensions()
 
 template<typename MatType, typename RegularizerType>
 template<typename Archive>
-void LinearType<MatType, RegularizerType>::serialize(
+void Linear<MatType, RegularizerType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));

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

@@ -33,11 +33,14 @@ template<
     typename MatType = arma::mat,
     typename RegularizerType = NoRegularizer
 >
-class LinearNoBiasType : public Layer<MatType>
+class LinearNoBias : public Layer<MatType>
 {
  public:
-  //! Create the LinearNoBias object.
-  LinearNoBiasType();
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
+  // Create the LinearNoBias object.
+  LinearNoBias();
 
   /**
    * Create the LinearNoBias object using the specified number of units.
@@ -45,29 +48,29 @@ class LinearNoBiasType : public Layer<MatType>
    * @param outSize The number of output units.
    * @param regularizer The regularizer to use, optional.
    */
-  LinearNoBiasType(const size_t outSize,
+  LinearNoBias(const size_t outSize,
                    RegularizerType regularizer = RegularizerType());
 
-  //! Clone the LinearNoBiasType object. This handles polymorphism correctly.
-  LinearNoBiasType* Clone() const { return new LinearNoBiasType(*this); }
+  //! Clone the LinearNoBias object. This handles polymorphism correctly.
+  LinearNoBias* Clone() const { return new LinearNoBias(*this); }
 
   //! Reset the layer parameter.
   void SetWeights(const MatType& weightsIn);
 
   //! Copy constructor.
-  LinearNoBiasType(const LinearNoBiasType& layer);
+  LinearNoBias(const LinearNoBias& layer);
 
   //! Move constructor.
-  LinearNoBiasType(LinearNoBiasType&&);
+  LinearNoBias(LinearNoBias&&);
 
   //! Copy assignment operator.
-  LinearNoBiasType& operator=(const LinearNoBiasType& layer);
+  LinearNoBias& operator=(const LinearNoBias& layer);
 
   //! Move assignment operator.
-  LinearNoBiasType& operator=(LinearNoBiasType&& layer);
+  LinearNoBias& operator=(LinearNoBias&& layer);
 
   //! Virtual destructor.
-  virtual ~LinearNoBiasType() { }
+  virtual ~LinearNoBias() { }
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -131,12 +134,7 @@ class LinearNoBiasType : public Layer<MatType>
 
   //! Locally-stored regularizer object.
   RegularizerType regularizer;
-}; // class LinearNoBiasType
-
-// Convenience typedefs.
-
-// Standard Linear without bias layer using no regularization.
-using LinearNoBias = LinearNoBiasType<arma::mat, NoRegularizer>;
+}; // class LinearNoBias
 
 } // namespace mlpack
 

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

@@ -19,7 +19,7 @@
 namespace mlpack {
 
 template<typename MatType, typename RegularizerType>
-LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType() :
+LinearNoBias<MatType, RegularizerType>::LinearNoBias() :
     Layer<MatType>(),
     inSize(0),
     outSize(0)
@@ -28,7 +28,7 @@ LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType() :
 }
 
 template<typename MatType, typename RegularizerType>
-LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType(
+LinearNoBias<MatType, RegularizerType>::LinearNoBias(
     const size_t outSize,
     RegularizerType regularizer) :
     Layer<MatType>(),
@@ -40,8 +40,8 @@ LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType(
 }
 
 template<typename MatType, typename RegularizerType>
-LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType(
-    const LinearNoBiasType& layer) :
+LinearNoBias<MatType, RegularizerType>::LinearNoBias(
+    const LinearNoBias& layer) :
     Layer<MatType>(layer),
     inSize(layer.inSize),
     outSize(layer.outSize),
@@ -51,11 +51,11 @@ LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType(
 }
 
 template<typename MatType, typename RegularizerType>
-LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType(
-    LinearNoBiasType&& layer) :
+LinearNoBias<MatType, RegularizerType>::LinearNoBias(
+    LinearNoBias&& layer) :
     Layer<MatType>(std::move(layer)),
-    inSize(0),
-    outSize(0),
+    inSize(std::move(layer.inSize)),
+    outSize(std::move(layer.outSize)),
     regularizer(std::move(layer.regularizer))
 {
   // Reset parameters of other layer.
@@ -64,9 +64,9 @@ LinearNoBiasType<MatType, RegularizerType>::LinearNoBiasType(
 }
 
 template<typename MatType, typename RegularizerType>
-LinearNoBiasType<MatType, RegularizerType>&
-LinearNoBiasType<MatType, RegularizerType>::operator=(
-    const LinearNoBiasType& layer)
+LinearNoBias<MatType, RegularizerType>&
+LinearNoBias<MatType, RegularizerType>::operator=(
+    const LinearNoBias& layer)
 {
   if (this != &layer)
   {
@@ -80,9 +80,9 @@ LinearNoBiasType<MatType, RegularizerType>::operator=(
 }
 
 template<typename MatType, typename RegularizerType>
-LinearNoBiasType<MatType, RegularizerType>&
-LinearNoBiasType<MatType, RegularizerType>::operator=(
-    LinearNoBiasType&& layer)
+LinearNoBias<MatType, RegularizerType>&
+LinearNoBias<MatType, RegularizerType>::operator=(
+    LinearNoBias&& layer)
 {
   if (this != &layer)
   {
@@ -100,21 +100,21 @@ LinearNoBiasType<MatType, RegularizerType>::operator=(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearNoBiasType<MatType, RegularizerType>::SetWeights(
+void LinearNoBias<MatType, RegularizerType>::SetWeights(
     const MatType& weights)
 {
   MakeAlias(weight, weights, outSize, inSize);
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearNoBiasType<MatType, RegularizerType>::Forward(
+void LinearNoBias<MatType, RegularizerType>::Forward(
     const MatType& input, MatType& output)
 {
   output = weight * input;
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearNoBiasType<MatType, RegularizerType>::Backward(
+void LinearNoBias<MatType, RegularizerType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -124,7 +124,7 @@ void LinearNoBiasType<MatType, RegularizerType>::Backward(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearNoBiasType<MatType, RegularizerType>::Gradient(
+void LinearNoBias<MatType, RegularizerType>::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
@@ -134,7 +134,7 @@ void LinearNoBiasType<MatType, RegularizerType>::Gradient(
 }
 
 template<typename MatType, typename RegularizerType>
-void LinearNoBiasType<MatType, RegularizerType>::ComputeOutputDimensions()
+void LinearNoBias<MatType, RegularizerType>::ComputeOutputDimensions()
 {
   inSize = this->inputDimensions[0];
   for (size_t i = 1; i < this->inputDimensions.size(); ++i)
@@ -148,7 +148,7 @@ void LinearNoBiasType<MatType, RegularizerType>::ComputeOutputDimensions()
 
 template<typename MatType, typename RegularizerType>
 template<typename Archive>
-void LinearNoBiasType<MatType, RegularizerType>::serialize(
+void LinearNoBias<MatType, RegularizerType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));

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

@@ -41,13 +41,16 @@ template<
     typename MatType = arma::mat,
     typename RegularizerType = NoRegularizer
 >
-class LinearRecurrentType : public RecurrentLayer<MatType>
+class LinearRecurrent : public RecurrentLayer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the LinearRecurrent layer.
    */
-  LinearRecurrentType();
+  LinearRecurrent();
 
   /**
    * Create the LinearRecurrent layer object with the specified number of
@@ -57,29 +60,29 @@ class LinearRecurrentType : public RecurrentLayer<MatType>
    * @param regularizer The regularizer to use; optional (default: no
    *    regularizer)
    */
-  LinearRecurrentType(const size_t outSize,
+  LinearRecurrent(const size_t outSize,
                       RegularizerType regularizer = RegularizerType());
 
-  virtual ~LinearRecurrentType() { }
+  virtual ~LinearRecurrent() { }
 
-  // Clone the LinearRecurrentType layer.  This handles polymorphism correctly.
-  LinearRecurrentType* Clone() const { return new LinearRecurrentType(*this); }
+  // Clone the LinearRecurrent layer.  This handles polymorphism correctly.
+  LinearRecurrent* Clone() const { return new LinearRecurrent(*this); }
 
   // Copy the other linear recurrent layer, including hidden recurrent state
   // (but not weights).
-  LinearRecurrentType(const LinearRecurrentType& layer);
+  LinearRecurrent(const LinearRecurrent& layer);
 
   // Take ownership of the members of the other linear recurrent layer,
   // including hidden recurrent state (but not weights).
-  LinearRecurrentType(LinearRecurrentType&& layer);
+  LinearRecurrent(LinearRecurrent&& layer);
 
   // Copy the other linear recurrent layer, including hidden recurrent state
   // (but not weights).
-  LinearRecurrentType& operator=(const LinearRecurrentType& layer);
+  LinearRecurrent& operator=(const LinearRecurrent& layer);
 
   // Take ownership of the members of the other linear recurrent layer,
   // including hidden recurrent state (but not weights).
-  LinearRecurrentType& operator=(LinearRecurrentType&& layer);
+  LinearRecurrent& operator=(LinearRecurrent&& layer);
 
   /**
    * Set the parameters of the layer (weights, hidden state weights, and bias).
@@ -140,6 +143,12 @@ class LinearRecurrentType : public RecurrentLayer<MatType>
   // has been set.
   void ComputeOutputDimensions();
 
+  // 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.
   template<typename Archive>
   void serialize(Archive& ar, const uint32_t /* version */);
@@ -160,14 +169,16 @@ class LinearRecurrentType : public RecurrentLayer<MatType>
   // Bias vector.
   MatType bias;
 
+  // Aliases of the recurrent states.
+  MatType currentOutput;
+  MatType previousOutput;
+  MatType currentGradient;
+  MatType previousGradient;
+
   // Locally-stored regularizer object.
   RegularizerType regularizer;
 };
 
-// Convenience typedefs.
-
-using LinearRecurrent = LinearRecurrentType<arma::mat, NoRegularizer>;
-
 } // namespace mlpack
 
 #include "linear_recurrent_impl.hpp"