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

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

@@ -32,11 +32,14 @@ namespace mlpack {
  *         computation.
  */
 template <typename MatType = arma::mat>
-class AdaptiveMeanPoolingType : public Layer<MatType>
+class AdaptiveMeanPooling : public Layer<MatType>
 {
  public:
-  //! Create the AdaptiveMeanPooling object.
-  AdaptiveMeanPoolingType();
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
+  // Create the AdaptiveMeanPooling object.
+  AdaptiveMeanPooling();
 
   /**
    * Create the AdaptiveMeanPooling object.
@@ -44,29 +47,29 @@ class AdaptiveMeanPoolingType : public Layer<MatType>
    * @param outputWidth Width of the output.
    * @param outputHeight Height of the output.
    */
-  AdaptiveMeanPoolingType(const size_t outputWidth,
+  AdaptiveMeanPooling(const size_t outputWidth,
                           const size_t outputHeight);
 
   // Virtual destructor.
-  virtual ~AdaptiveMeanPoolingType()
+  virtual ~AdaptiveMeanPooling()
   {
     // Nothing to do here.
   }
 
-  //! Copy the given AdaptiveMeanPoolingType.
-  AdaptiveMeanPoolingType(const AdaptiveMeanPoolingType& other);
-  //! Take ownership of the given AdaptiveMeanPoolingType.
-  AdaptiveMeanPoolingType(AdaptiveMeanPoolingType&& other);
-  //! Copy the given AdaptiveMeanPoolingType.
-  AdaptiveMeanPoolingType& operator=(const AdaptiveMeanPoolingType& other);
-  //! Take ownership of the given AdaptiveMeanPoolingType.
-  AdaptiveMeanPoolingType& operator=(AdaptiveMeanPoolingType&& other);
+  //! Copy the given AdaptiveMeanPooling.
+  AdaptiveMeanPooling(const AdaptiveMeanPooling& other);
+  //! Take ownership of the given AdaptiveMeanPooling.
+  AdaptiveMeanPooling(AdaptiveMeanPooling&& other);
+  //! Copy the given AdaptiveMeanPooling.
+  AdaptiveMeanPooling& operator=(const AdaptiveMeanPooling& other);
+  //! Take ownership of the given AdaptiveMeanPooling.
+  AdaptiveMeanPooling& operator=(AdaptiveMeanPooling&& other);
 
-  //! Clone the AdaptiveMeanPoolingType object.
+  //! Clone the AdaptiveMeanPooling object.
   //! This handles polymorphism correctly.
-  AdaptiveMeanPoolingType* Clone() const
+  AdaptiveMeanPooling* Clone() const
   {
-    return new AdaptiveMeanPoolingType(*this);
+    return new AdaptiveMeanPooling(*this);
   }
 
   /**
@@ -114,7 +117,7 @@ class AdaptiveMeanPoolingType : public Layer<MatType>
 
  private:
   //! Locally stored MeanPooling Object.
-  MeanPoolingType<MatType> poolingLayer;
+  MeanPooling<MatType> poolingLayer;
 
   //! Locally-stored output width. These are user specified outputWidth.
   //! Actual outputWidth will be equal to this but only after
@@ -125,12 +128,7 @@ class AdaptiveMeanPoolingType : public Layer<MatType>
   //! Actual outputWidth will be equal to this but only after
   //! `ComputeOutputDimensions()` is called.
   size_t outputHeight;
-}; // class AdaptiveMeanPoolingType
-
-// Convenience typedefs.
-
-// Standard Adaptive mean pooling layer.
-using AdaptiveMeanPooling = AdaptiveMeanPoolingType<arma::mat>;
+}; // class AdaptiveMeanPooling
 
 } // namespace mlpack
 

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

@@ -18,18 +18,18 @@
 namespace mlpack {
 
 template<typename MatType>
-AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType() :
+AdaptiveMeanPooling<MatType>::AdaptiveMeanPooling() :
     Layer<MatType>()
 {
   // Nothing to do here.
 }
 
 template <typename MatType>
-AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType(
+AdaptiveMeanPooling<MatType>::AdaptiveMeanPooling(
     const size_t outputWidth,
     const size_t outputHeight) :
     Layer<MatType>(),
-    poolingLayer(MeanPoolingType<MatType>(1, 1)),
+    poolingLayer(MeanPooling<MatType>(1, 1)),
     outputWidth(outputWidth),
     outputHeight(outputHeight)
 {
@@ -37,8 +37,8 @@ AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType(
 }
 
 template<typename MatType>
-AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType(
-    const AdaptiveMeanPoolingType& other) :
+AdaptiveMeanPooling<MatType>::AdaptiveMeanPooling(
+    const AdaptiveMeanPooling& other) :
     Layer<MatType>(other),
     poolingLayer(other.poolingLayer),
     outputWidth(other.outputWidth),
@@ -48,8 +48,8 @@ AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType(
 }
 
 template<typename MatType>
-AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType(
-    AdaptiveMeanPoolingType&& other) :
+AdaptiveMeanPooling<MatType>::AdaptiveMeanPooling(
+    AdaptiveMeanPooling&& other) :
     Layer<MatType>(std::move(other)),
     poolingLayer(std::move(other.poolingLayer)),
     outputWidth(std::move(other.outputWidth)),
@@ -59,9 +59,9 @@ AdaptiveMeanPoolingType<MatType>::AdaptiveMeanPoolingType(
 }
 
 template<typename MatType>
-AdaptiveMeanPoolingType<MatType>&
-AdaptiveMeanPoolingType<MatType>::operator=(
-    const AdaptiveMeanPoolingType& other)
+AdaptiveMeanPooling<MatType>&
+AdaptiveMeanPooling<MatType>::operator=(
+    const AdaptiveMeanPooling& other)
 {
   if (&other != this)
   {
@@ -75,8 +75,8 @@ AdaptiveMeanPoolingType<MatType>::operator=(
 }
 
 template<typename MatType>
-AdaptiveMeanPoolingType<MatType>&
-AdaptiveMeanPoolingType<MatType>::operator=(AdaptiveMeanPoolingType&& other)
+AdaptiveMeanPooling<MatType>&
+AdaptiveMeanPooling<MatType>::operator=(AdaptiveMeanPooling&& other)
 {
   if (&other != this)
   {
@@ -90,7 +90,7 @@ AdaptiveMeanPoolingType<MatType>::operator=(AdaptiveMeanPoolingType&& other)
 }
 
 template<typename MatType>
-void AdaptiveMeanPoolingType<MatType>::Forward(
+void AdaptiveMeanPooling<MatType>::Forward(
     const MatType& input, MatType& output)
 {
   poolingLayer.Training() = this->training;
@@ -98,7 +98,7 @@ void AdaptiveMeanPoolingType<MatType>::Forward(
 }
 
 template<typename MatType>
-void AdaptiveMeanPoolingType<MatType>::Backward(
+void AdaptiveMeanPooling<MatType>::Backward(
   const MatType& input,
   const MatType& output,
   const MatType& gy,
@@ -108,7 +108,7 @@ void AdaptiveMeanPoolingType<MatType>::Backward(
 }
 
 template<typename MatType>
-void AdaptiveMeanPoolingType<MatType>::ComputeOutputDimensions()
+void AdaptiveMeanPooling<MatType>::ComputeOutputDimensions()
 {
   // The AdaptiveMaxPooling layer only affects the first two dimensions.
   this->outputDimensions = this->inputDimensions;
@@ -140,7 +140,7 @@ void AdaptiveMeanPoolingType<MatType>::ComputeOutputDimensions()
 
 template<typename MatType>
 template<typename Archive>
-void AdaptiveMeanPoolingType<MatType>::serialize(
+void AdaptiveMeanPooling<MatType>::serialize(
     Archive& ar,
     const uint32_t /* version */)
 {

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

@@ -24,30 +24,33 @@ namespace mlpack {
  * @tparam MatType Matrix representation to accept as input and use for
  *    computation.
  */
-template<typename MatType>
-class AddType : public Layer<MatType>
+template<typename MatType = arma::mat>
+class Add : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
-   * Create the AddType object.  The output size of the layer will be the same
+   * Create the Add object.  The output size of the layer will be the same
    * as the input size.
    */
-  AddType();
+  Add();
 
-  //! Clone the AddType object. This handles polymorphism correctly.
-  AddType* Clone() const { return new AddType(*this); }
+  //! Clone the Add object. This handles polymorphism correctly.
+  Add* Clone() const { return new Add(*this); }
 
   // Virtual destructor.
-  virtual ~AddType() { }
+  virtual ~Add() { }
 
-  //! Copy the given AddType layer.
-  AddType(const AddType& other);
-  //! Take ownership of the given AddType layer.
-  AddType(AddType&& other);
-  //! Copy the given AddType layer.
-  AddType& operator=(const AddType& other);
-  //! Take ownership of the given AddType layer.
-  AddType& operator=(AddType&& other);
+  //! Copy the given Add layer.
+  Add(const Add& other);
+  //! Take ownership of the given Add layer.
+  Add(Add&& other);
+  //! Copy the given Add layer.
+  Add& operator=(const Add& other);
+  //! Take ownership of the given Add layer.
+  Add& operator=(Add&& other);
 
   /**
    * Forward pass: add the bias to the input.
@@ -110,9 +113,6 @@ class AddType : public Layer<MatType>
   MatType weights;
 }; // class Add
 
-// Standard Add layer.
-using Add = AddType<arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.

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

@@ -19,7 +19,7 @@
 namespace mlpack {
 
 template<typename MatType>
-AddType<MatType>::AddType() :
+Add<MatType>::Add() :
     Layer<MatType>(),
     outSize(0)
 {
@@ -27,7 +27,7 @@ AddType<MatType>::AddType() :
 }
 
 template<typename MatType>
-AddType<MatType>::AddType(const AddType& other) :
+Add<MatType>::Add(const Add& other) :
     Layer<MatType>(other),
     outSize(other.outSize)
 {
@@ -35,7 +35,7 @@ AddType<MatType>::AddType(const AddType& other) :
 }
 
 template<typename MatType>
-AddType<MatType>::AddType(AddType&& other) :
+Add<MatType>::Add(Add&& other) :
     Layer<MatType>(std::move(other)),
     outSize(std::move(other.outSize))
 {
@@ -43,8 +43,8 @@ AddType<MatType>::AddType(AddType&& other) :
 }
 
 template<typename MatType>
-AddType<MatType>&
-AddType<MatType>::operator=(const AddType& other)
+Add<MatType>&
+Add<MatType>::operator=(const Add& other)
 {
   if (&other != this)
   {
@@ -56,8 +56,8 @@ AddType<MatType>::operator=(const AddType& other)
 }
 
 template<typename MatType>
-AddType<MatType>&
-AddType<MatType>::operator=(AddType&& other)
+Add<MatType>&
+Add<MatType>::operator=(Add&& other)
 {
   if (&other != this)
   {
@@ -69,13 +69,13 @@ AddType<MatType>::operator=(AddType&& other)
 }
 
 template<typename MatType>
-void AddType<MatType>::Forward(const MatType& input, MatType& output)
+void Add<MatType>::Forward(const MatType& input, MatType& output)
 {
   output = input + repmat(vectorise(weights), 1, input.n_cols);
 }
 
 template<typename MatType>
-void AddType<MatType>::Backward(
+void Add<MatType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -85,7 +85,7 @@ void AddType<MatType>::Backward(
 }
 
 template<typename MatType>
-void AddType<MatType>::Gradient(
+void Add<MatType>::Gradient(
     const MatType& /* input */,
     const MatType& error,
     MatType& gradient)
@@ -95,14 +95,14 @@ void AddType<MatType>::Gradient(
 }
 
 template<typename MatType>
-void AddType<MatType>::SetWeights(const MatType& weightsIn)
+void Add<MatType>::SetWeights(const MatType& weightsIn)
 {
   // Set the weights to wrap the given memory.
   MakeAlias(weights, weightsIn, 1, outSize);
 }
 
 template<typename MatType>
-void AddType<MatType>::ComputeOutputDimensions()
+void Add<MatType>::ComputeOutputDimensions()
 {
   this->outputDimensions = this->inputDimensions;
 
@@ -113,7 +113,7 @@ void AddType<MatType>::ComputeOutputDimensions()
 
 template<typename MatType>
 template<typename Archive>
-void AddType<MatType>::serialize(Archive& ar, const uint32_t /* version */)
+void Add<MatType>::serialize(Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));
 

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

@@ -24,33 +24,36 @@ namespace mlpack {
  * @tparam MatType Matrix representation to accept as input and use for
  *    computation.
  */
-template<typename MatType>
-class AddMergeType : public MultiLayer<MatType>
+template<typename MatType = arma::mat>
+class AddMerge : public MultiLayer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
-   * Create an empty AddMergeType that holds no layers of its own.  Be sure to add
+   * Create an empty AddMerge that holds no layers of its own.  Be sure to add
    * layers with Add() before using!
    */
-  AddMergeType();
+  AddMerge();
 
-  //! Copy the given AddMergeType.
-  AddMergeType(const AddMergeType& other);
-  //! Take ownership of the layers of the given AddMergeType.
-  AddMergeType(AddMergeType&& other);
-  //! Copy the given AddMergeType.
-  AddMergeType& operator=(const AddMergeType& other);
-  //! Take ownership of the given AddMergeType.
-  AddMergeType& operator=(AddMergeType&& other);
+  //! Copy the given AddMerge.
+  AddMerge(const AddMerge& other);
+  //! Take ownership of the layers of the given AddMerge.
+  AddMerge(AddMerge&& other);
+  //! Copy the given AddMerge.
+  AddMerge& operator=(const AddMerge& other);
+  //! Take ownership of the given AddMerge.
+  AddMerge& operator=(AddMerge&& other);
 
   //! Virtual destructor: delete all held layers.
-  virtual ~AddMergeType()
+  virtual ~AddMerge()
   {
     // Nothing to do here.
   }
 
-  //! Create a copy of the AddMergeType (this is safe for polymorphic use).
-  AddMergeType* Clone() const { return new AddMergeType(*this); }
+  //! Create a copy of the AddMerge (this is safe for polymorphic use).
+  AddMerge* Clone() const { return new AddMerge(*this); }
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -90,13 +93,11 @@ class AddMergeType : public MultiLayer<MatType>
   //! Compute the size of the output given `InputDimensions()`.
   void ComputeOutputDimensions();
 
-  //! Serialize the AddMergeType.
+  //! Serialize the AddMerge.
   template<typename Archive>
   void serialize(Archive& ar, const uint32_t /* version */);
 };
 
-using AddMerge = AddMergeType<arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.

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

@@ -17,29 +17,29 @@
 namespace mlpack {
 
 template<typename MatType>
-AddMergeType<MatType>::AddMergeType() :
+AddMerge<MatType>::AddMerge() :
     MultiLayer<MatType>()
 {
   // Nothing to do.
 }
 
 template<typename MatType>
-AddMergeType<MatType>::AddMergeType(const AddMergeType& other) :
+AddMerge<MatType>::AddMerge(const AddMerge& other) :
     MultiLayer<MatType>(other)
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-AddMergeType<MatType>::AddMergeType(AddMergeType&& other) :
+AddMerge<MatType>::AddMerge(AddMerge&& other) :
     MultiLayer<MatType>(std::move(other))
 {
   // Nothing to do here.
 }
 
 template<typename MatType>
-AddMergeType<MatType>& AddMergeType<MatType>::operator=(
-    const AddMergeType& other)
+AddMerge<MatType>& AddMerge<MatType>::operator=(
+    const AddMerge& other)
 {
   if (this != &other)
   {
@@ -50,7 +50,7 @@ AddMergeType<MatType>& AddMergeType<MatType>::operator=(
 }
 
 template<typename MatType>
-AddMergeType<MatType>& AddMergeType<MatType>::operator=(AddMergeType&& other)
+AddMerge<MatType>& AddMerge<MatType>::operator=(AddMerge&& other)
 {
   if (this != &other)
   {
@@ -61,7 +61,7 @@ AddMergeType<MatType>& AddMergeType<MatType>::operator=(AddMergeType&& other)
 }
 
 template<typename MatType>
-void AddMergeType<MatType>::Forward(
+void AddMerge<MatType>::Forward(
     const MatType& input, MatType& output)
 {
   // Make sure training/testing mode is set right in each layer.
@@ -74,7 +74,7 @@ void AddMergeType<MatType>::Forward(
   {
     // Initialize temporary memory for the forward pass.
     MatType tempOutput;
-    tempOutput.set_size(arma::size(output));
+    tempOutput.set_size(size(output));
 
     // Forward pass every layer in network with same input.
     // Reduce the outputs to single output by adding element-wise.
@@ -98,7 +98,7 @@ void AddMergeType<MatType>::Forward(
 }
 
 template<typename MatType>
-void AddMergeType<MatType>::Backward(
+void AddMerge<MatType>::Backward(
     const MatType& input,
     const MatType& output,
     const MatType& gy,
@@ -108,7 +108,7 @@ void AddMergeType<MatType>::Backward(
   {
     // Initialize temporary memory for the backward pass.
     MatType tempDelta;
-    tempDelta.set_size(arma::size(g));
+    tempDelta.set_size(size(g));
 
     g.zeros();
     for (size_t i = 0; i < this->network.size(); i++)
@@ -129,7 +129,7 @@ void AddMergeType<MatType>::Backward(
 }
 
 template<typename MatType>
-void AddMergeType<MatType>::Gradient(
+void AddMerge<MatType>::Gradient(
     const MatType& input, const MatType& error, MatType& gradient)
 {
   // We assume gradient has the right size already.
@@ -156,7 +156,7 @@ void AddMergeType<MatType>::Gradient(
 }
 
 template<typename MatType>
-void AddMergeType<MatType>::ComputeOutputDimensions()
+void AddMerge<MatType>::ComputeOutputDimensions()
 {
   this->inSize = 0;
   this->totalInputSize = 0;
@@ -197,7 +197,7 @@ void AddMergeType<MatType>::ComputeOutputDimensions()
 
 template<typename MatType>
 template<typename Archive>
-void AddMergeType<MatType>::serialize(
+void AddMerge<MatType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<MultiLayer<MatType>>(this));

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

@@ -44,34 +44,37 @@ namespace mlpack {
  *    computation.
  */
 template<typename MatType = arma::mat>
-class AlphaDropoutType : public Layer<MatType>
+class AlphaDropout : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the Alpha_Dropout object using the specified ratio.
    *
    * @param ratio The probability of setting a value to alphaDash.
    * @param alphaDash The dropout scaling parameter.
    */
-  AlphaDropoutType(const double ratio = 0.5,
+  AlphaDropout(const double ratio = 0.5,
                    const double alphaDash = -alpha * lambda);
 
   /**
-   * Clone the AlphaDropoutType object. This handles polymorphism correctly.
+   * Clone the AlphaDropout object. This handles polymorphism correctly.
    */
-  AlphaDropoutType* Clone() const { return new AlphaDropoutType(*this); }
+  AlphaDropout* Clone() const { return new AlphaDropout(*this); }
 
   // Virtual destructor.
-  virtual ~AlphaDropoutType() { }
+  virtual ~AlphaDropout() { }
 
-  //! Copy the given AlphaDropoutType layer.
-  AlphaDropoutType(const AlphaDropoutType& other);
-  //! Take ownership of the given AlphaDropoutType layer.
-  AlphaDropoutType(AlphaDropoutType&& other);
-  //! Copy the given AlphaDropoutType layer.
-  AlphaDropoutType& operator=(const AlphaDropoutType& other);
-  //! Take ownership of the given AlphaDropoutType layer.
-  AlphaDropoutType& operator=(AlphaDropoutType&& other);
+  //! Copy the given AlphaDropout layer.
+  AlphaDropout(const AlphaDropout& other);
+  //! Take ownership of the given AlphaDropout layer.
+  AlphaDropout(AlphaDropout&& other);
+  //! Copy the given AlphaDropout layer.
+  AlphaDropout& operator=(const AlphaDropout& other);
+  //! Take ownership of the given AlphaDropout layer.
+  AlphaDropout& operator=(AlphaDropout&& other);
 
   /**
    * Ordinary feed forward pass of the AlphaDropout layer.
@@ -145,9 +148,7 @@ class AlphaDropoutType : public Layer<MatType>
 
   //! Value to be added to a*x for affine transformation.
   double b;
-}; // class AlphaDropoutType
-
-using AlphaDropout = AlphaDropoutType<arma::mat>;
+}; // class AlphaDropout
 
 } // namespace mlpack
 

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

@@ -22,7 +22,7 @@
 namespace mlpack {
 
 template<typename MatType>
-AlphaDropoutType<MatType>::AlphaDropoutType(
+AlphaDropout<MatType>::AlphaDropout(
     const double ratio,
     const double alphaDash) :
     Layer<MatType>(),
@@ -33,7 +33,7 @@ AlphaDropoutType<MatType>::AlphaDropoutType(
 }
 
 template<typename MatType>
-AlphaDropoutType<MatType>::AlphaDropoutType(const AlphaDropoutType& other) :
+AlphaDropout<MatType>::AlphaDropout(const AlphaDropout& other) :
     Layer<MatType>(other),
     mask(other.mask),
     ratio(other.ratio),
@@ -45,7 +45,7 @@ AlphaDropoutType<MatType>::AlphaDropoutType(const AlphaDropoutType& other) :
 }
 
 template<typename MatType>
-AlphaDropoutType<MatType>::AlphaDropoutType(AlphaDropoutType&& other) :
+AlphaDropout<MatType>::AlphaDropout(AlphaDropout&& other) :
     Layer<MatType>(std::move(other)),
     mask(std::move(other.mask)),
     ratio(std::move(other.ratio)),
@@ -57,8 +57,8 @@ AlphaDropoutType<MatType>::AlphaDropoutType(AlphaDropoutType&& other) :
 }
 
 template<typename MatType>
-AlphaDropoutType<MatType>&
-AlphaDropoutType<MatType>::operator=(const AlphaDropoutType& other)
+AlphaDropout<MatType>&
+AlphaDropout<MatType>::operator=(const AlphaDropout& other)
 {
   if (&other != this)
   {
@@ -74,8 +74,8 @@ AlphaDropoutType<MatType>::operator=(const AlphaDropoutType& other)
 }
 
 template<typename MatType>
-AlphaDropoutType<MatType>&
-AlphaDropoutType<MatType>::operator=(AlphaDropoutType&& other)
+AlphaDropout<MatType>&
+AlphaDropout<MatType>::operator=(AlphaDropout&& other)
 {
   if (&other != this)
   {
@@ -91,7 +91,7 @@ AlphaDropoutType<MatType>::operator=(AlphaDropoutType&& other)
 }
 
 template<typename MatType>
-void AlphaDropoutType<MatType>::Forward(const MatType& input, MatType& output)
+void AlphaDropout<MatType>::Forward(const MatType& input, MatType& output)
 {
   // The dropout mask will not be multiplied during testing.
   if (!this->training)
@@ -104,24 +104,25 @@ void AlphaDropoutType<MatType>::Forward(const MatType& input, MatType& output)
     // transformation so as to keep mean and variance of outputs to their
     // original values.
     mask.randu(input.n_rows, input.n_cols);
-    mask.transform( [&](double val) { return (val > ratio); } );
-    output = (input % mask + alphaDash * (1 - mask)) * a + b;
+    mask.transform( [&](ElemType val) { return (val > ElemType(ratio)); } );
+    output = (input % mask + ElemType(alphaDash) * (1 - mask)) * ElemType(a) +
+        ElemType(b);
   }
 }
 
 template<typename MatType>
-void AlphaDropoutType<MatType>::Backward(
+void AlphaDropout<MatType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
     MatType& g)
 {
-  g = gy % mask * a;
+  g = gy % mask * ElemType(a);
 }
 
 template<typename MatType>
 template<typename Archive>
-void AlphaDropoutType<MatType>::serialize(
+void AlphaDropout<MatType>::serialize(
     Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));