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

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

@@ -0,0 +1,195 @@
+/**
+ * @file methods/ann/layer/gru.hpp
+ * @author Sumedh Ghaisas
+ * @author Zachary Ng
+ *
+ * Definition of the GRU layer.
+ *
+ * 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_GRU_HPP
+#define MLPACK_METHODS_ANN_LAYER_GRU_HPP
+
+#include <mlpack/prereqs.hpp>
+
+namespace mlpack {
+
+/**
+ * An implementation of a gru network layer using the following algorithm.
+ *
+ * r_t = sigmoid(W_r x_t + U_r y_{t - 1})
+ * z_t = sigmoid(W_z x_t + U_z y_{t - 1})
+ * h_t =    tanh(W_h x_t + r_t % (U_h y_{t - 1}))
+ * y_t =        (1 - z_t) % y_{t - 1} + z_t % h_t
+ *
+ * For more information, read the following paper:
+ *
+ * @code
+ * @inproceedings{chung2015gated,
+ *    title     = {Gated Feedback Recurrent Neural Networks},
+ *    author    = {Chung, Junyoung and G{\"u}l{\c{c}}ehre, Caglar and Cho,
+ *                Kyunghyun and Bengio, Yoshua},
+ *    booktitle = {ICML},
+ *    pages     = {2067--2075},
+ *    year      = {2015},
+ *    url       = {https://arxiv.org/abs/1502.02367}
+ * }
+ * @endcode
+ *
+ * This cell can be used in RNNs.
+ *
+ * @tparam MatType Type of the input data (arma::colvec, arma::mat,
+ *         arma::sp_mat or arma::cube).
+ */
+template <typename MatType = arma::mat>
+class GRU : public RecurrentLayer<MatType>
+{
+ public:
+  // Create the GRU object.
+  GRU();
+
+  /**
+   * Create the GRU layer object using the specified parameters.
+   *
+   * @param outSize The number of output units.
+   */
+  GRU(const size_t outSize);
+
+  // Clone the GRU object. This handles polymorphism correctly.
+  GRU* Clone() const { return new GRU(*this); }
+
+  // Copy the given GRU object.
+  GRU(const GRU& other);
+  // Take ownership of the given GRU object's data.
+  GRU(GRU&& other);
+  // Copy the given GRU object.
+  GRU& operator=(const GRU& other);
+  // Take ownership of the given GRU object's data.
+  GRU& operator=(GRU&& other);
+
+  virtual ~GRU() { }
+
+  /**
+   * Reset the layer parameter. The method is called to
+   * assign the allocated memory to the internal learnable parameters.
+   */
+  void SetWeights(const MatType& weightsIn);
+
+  /**
+   * Ordinary feed forward pass of a neural network, evaluating the function
+   * f(x) by propagating the activity forward through f.
+   *
+   * @param input Input data used for evaluating the specified function.
+   * @param output Resulting output activation.
+   */
+  void Forward(const MatType& input, MatType& output);
+
+  /**
+   * Ordinary feed backward pass of a neural network, calculating the function
+   * f(x) by propagating x backwards trough f. Using the results from the feed
+   * forward pass.
+   *
+   * @param input The input data (x) given to the forward pass.
+   * @param output The propagated data (f(x)) resulting from Forward()
+   * @param gy Propagated error from next layer.
+   * @param g Matrix to store propagated error in for previous layer.
+   */
+  void Backward(const MatType& /* input */,
+                const MatType& output,
+                const MatType& gy,
+                MatType& g);
+
+  /*
+   * Calculate the gradient using the output delta and the input activation.
+   *
+   * @param input Original input data provided to Forward().
+   * @param error Error as computed by `Backward()`.
+   * @param gradient Matrix to store the gradients in.
+   */
+  void Gradient(const MatType& input,
+                const MatType& /* error */,
+                MatType& gradient);
+
+  // Get the parameters.
+  MatType const& Parameters() const { return weights; }
+  // Modify the parameters.
+  MatType& Parameters() { return weights; }
+
+  // Get the total number of trainable parameters.
+  size_t WeightSize() const;
+
+  // Get the total number of recurrent state parameters.
+  size_t RecurrentSize() const;
+
+  // Given a properly set InputDimensions(), compute the output dimensions.
+  void ComputeOutputDimensions()
+  {
+    inSize = this->inputDimensions[0];
+    for (size_t i = 1; i < this->inputDimensions.size(); ++i)
+      inSize *= this->inputDimensions[i];
+    this->outputDimensions = std::vector<size_t>(this->inputDimensions.size(),
+        1);
+
+    // The GRU layer flattens its input.
+    this->outputDimensions[0] = outSize;
+  }
+
+  // Update the internal aliases of the layer when the step changes.
+  void OnStepChanged(const size_t step,
+                     const size_t batchSize,
+                     const size_t activeBatchSize,
+                     const bool backwards);
+
+  /**
+   * Serialize the layer
+   */
+  template<typename Archive>
+  void serialize(Archive& ar, const uint32_t /* version */);
+
+ private:
+  // Locally-stored number of input units.
+  size_t inSize;
+
+  // Locally-stored number of output units.
+  size_t outSize;
+
+  // Locally-stored weight object.
+  MatType weights;
+
+  // Weight aliases for input connections.
+  MatType resetGateWeight;
+  MatType updateGateWeight;
+  MatType hiddenGateWeight;
+
+  // Weight aliases for recurrent connections.
+  MatType recurrentResetGateWeight;
+  MatType recurrentUpdateGateWeight;
+  MatType recurrentHiddenGateWeight;
+
+  // Recurrent state aliases.
+  MatType resetGate;
+  MatType updateGate;
+  MatType hiddenGate;
+  MatType currentOutput;
+  MatType prevOutput;
+
+  // Backwards workspace
+  MatType workspace;
+  MatType deltaReset;
+  MatType deltaUpdate;
+  MatType deltaHidden;
+  // These correspond to, e.g., dy_{t + 1}.
+  MatType nextDeltaReset;
+  MatType nextDeltaUpdate;
+  MatType nextDeltaHidden;
+}; // class GRU
+
+} // namespace mlpack
+
+// Include implementation.
+#include "gru_impl.hpp"
+
+#endif

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

@@ -0,0 +1,325 @@
+/**
+ * @file methods/ann/layer/gru_impl.hpp
+ * @author Sumedh Ghaisas
+ * @author Zachary Ng
+ *
+ * Implementation of the GRU class, which implements a gru network
+ * layer.
+ *
+ * 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_GRU_IMPL_HPP
+#define MLPACK_METHODS_ANN_LAYER_GRU_IMPL_HPP
+
+// In case it hasn't yet been included.
+#include "gru.hpp"
+
+namespace mlpack {
+
+template<typename MatType>
+GRU<MatType>::GRU() :
+    RecurrentLayer<MatType>()
+{
+  // Nothing to do here.
+}
+
+template<typename MatType>
+GRU<MatType>::GRU(const size_t outSize) :
+    RecurrentLayer<MatType>(),
+    inSize(0),
+    outSize(outSize)
+{
+  // Nothing to do here.
+}
+
+template<typename MatType>
+GRU<MatType>::GRU(const GRU& other) :
+    RecurrentLayer<MatType>(other),
+    inSize(other.inSize),
+    outSize(other.outSize)
+{
+  // Nothing to do here.
+}
+
+template<typename MatType>
+GRU<MatType>::GRU(GRU&& other) :
+    RecurrentLayer<MatType>(std::move(other)),
+    inSize(other.inSize),
+    outSize(other.outSize)
+{
+  // Nothing to do here.
+}
+
+template<typename MatType>
+GRU<MatType>& GRU<MatType>::operator=(const GRU& other)
+{
+  if (this != &other)
+  {
+    RecurrentLayer<MatType>::operator=(other);
+    inSize = other.inSize;
+    outSize = other.outSize;
+  }
+
+  return *this;
+}
+
+template<typename MatType>
+GRU<MatType>& GRU<MatType>::operator=(GRU&& other)
+{
+  if (this != &other)
+  {
+    RecurrentLayer<MatType>::operator=(std::move(other));
+    inSize = other.inSize;
+    outSize = other.outSize;
+  }
+
+  return *this;
+}
+
+
+template<typename MatType>
+void GRU<MatType>::SetWeights(const MatType& weightsIn)
+{
+  MakeAlias(weights, weightsIn, weightsIn.n_rows, weightsIn.n_cols);
+
+  const size_t inputWeightSize = outSize * inSize;
+  MakeAlias(resetGateWeight, weightsIn, outSize, inSize, 0);
+  MakeAlias(updateGateWeight, weightsIn, outSize, inSize, inputWeightSize);
+  MakeAlias(hiddenGateWeight, weightsIn, outSize, inSize, inputWeightSize * 2);
+
+  const size_t recurrentWeightOffset = inputWeightSize * 3;
+  const size_t recurrentWeightSize = outSize * outSize;
+  MakeAlias(recurrentResetGateWeight, weightsIn, outSize, outSize,
+      recurrentWeightOffset);
+  MakeAlias(recurrentUpdateGateWeight, weightsIn, outSize, outSize,
+      recurrentWeightOffset + recurrentWeightSize);
+  MakeAlias(recurrentHiddenGateWeight, weightsIn, outSize, outSize,
+      recurrentWeightOffset + recurrentWeightSize * 2);
+}
+
+template<typename MatType>
+void GRU<MatType>::Forward(const MatType& input, MatType& output)
+{
+  // Compute internal state using the following algorithm.
+  // r_t = sigmoid(W_r x_t + U_r y_{t - 1})
+  // z_t = sigmoid(W_z x_t + U_z y_{t - 1})
+  // h_t =    tanh(W_h x_t + r_t % (U_h y_{t - 1}))
+  // y_t =        (1 - z_t) % y_{t - 1} + z_t % h_t
+
+  // Process non recurrent input.
+  updateGate = updateGateWeight * input;
+  resetGate = resetGateWeight * input;
+
+  // Add recurrent input.
+  if (this->HasPreviousStep())
+  {
+    resetGate += recurrentResetGateWeight * prevOutput;
+    updateGate += recurrentUpdateGateWeight * prevOutput;
+  }
+
+  // Apply sigmoid activation function.
+  resetGate = 1 / (1 + exp(-resetGate));
+  updateGate = 1 / (1 + exp(-updateGate));
+
+  // Calculate candidate activation vector.
+  hiddenGate = hiddenGateWeight * input;
+
+  // Add recurrent portion to activation vector.
+  if (this->HasPreviousStep())
+  {
+    hiddenGate += resetGate % (recurrentHiddenGateWeight * prevOutput);
+  }
+
+  // Apply tanh activation function.
+  hiddenGate = tanh(hiddenGate);
+
+  // Compute output.
+  output = updateGate % hiddenGate;
+
+  // Add recurrent portion to output.
+  if (this->HasPreviousStep())
+  {
+    output += (1 - updateGate) % prevOutput;
+  }
+
+  currentOutput = output;
+}
+
+template<typename MatType>
+void GRU<MatType>::Backward(
+    const MatType& /* input */,
+    const MatType& /* output */,
+    const MatType& gy,
+    MatType& g)
+{
+  // Work backwards to get error at each gate.
+  // y_t = (1 - z_t) % y_{t - 1} + z_t % h_t
+  // dh_t = dy % z_t
+  deltaHidden = gy % updateGate;
+  // The hidden gate uses a tanh activation function.
+  // The derivative of tanh(x) is actually 1 - tanh^2(x) but
+  // tanh has already been applied to hiddenGate in Forward().
+  deltaHidden = deltaHidden % (1 - square(hiddenGate));
+
+  // y_t = (1 - z_t) % y_{t - 1} + z_t % h_t
+  // dz_t = dy % h_t - dy % y_{t - 1}
+  deltaUpdate = gy % hiddenGate;
+  if (this->HasPreviousStep())
+    deltaUpdate -= gy % prevOutput;
+  // The reset and update gate use sigmoid activation.
+  // The derivative is sigmoid(x) * (1 - sigmoid(x)).  Since sigmoid has
+  // already been applied to the gates, it's just `x * (1 - x)`
+  deltaUpdate = deltaUpdate % (updateGate % (1 - updateGate));
+
+  if (this->HasPreviousStep())
+  {
+    // h_t = tanh(W_h x_t + r_t % (U_h y_{t - 1}))
+    // dr_t = dh_t % (U_h y_{t - 1})
+    deltaReset = deltaHidden % (recurrentHiddenGateWeight * prevOutput);
+    deltaReset = deltaReset % (resetGate % (1 - resetGate));
+  }
+  else
+  {
+    deltaReset.zeros(deltaHidden.n_rows, deltaHidden.n_cols);
+  }
+
+  // Calculate the input error.
+  // r_t = sigmoid(W_r x_t + U_r y_{t - 1})
+  // z_t = sigmoid(W_z x_t + U_z y_{t - 1})
+  // h_t =    tanh(W_h x_t + r_t % (U_h y_{t - 1}))
+  // dx_t = W_r * dr_t + W_z * dz_t + W_h * dh_t
+  g = resetGateWeight.t() * deltaReset +
+      updateGateWeight.t() * deltaUpdate +
+      hiddenGateWeight.t() * deltaHidden;
+}
+
+template<typename MatType>
+void GRU<MatType>::Gradient(
+    const MatType& input,
+    const MatType& /* error */,
+    MatType& gradient)
+{
+  size_t offset = 0;
+  // Non recurrent reset gate weights.
+  gradient.submat(offset, 0, offset + resetGateWeight.n_elem - 1, 0) =
+      vectorise(deltaReset * input.t());
+  offset += resetGateWeight.n_elem;
+  // Non recurrent update gate weights.
+  gradient.submat(offset, 0, offset + updateGateWeight.n_elem - 1, 0) =
+      vectorise(deltaUpdate * input.t());
+  offset += updateGateWeight.n_elem;
+  // Non recurrent hidden gate weights.
+  gradient.submat(offset, 0, offset + hiddenGateWeight.n_elem - 1, 0) =
+      vectorise(deltaHidden * input.t());
+  offset += hiddenGateWeight.n_elem;
+
+  // nextDelta is not set until after the first step.
+  if (!this->AtFinalStep())
+  {
+    // Recurrent reset gate weights.
+    gradient.submat(offset, 0, offset + recurrentResetGateWeight.n_elem - 1,
+        0) = vectorise(nextDeltaReset * currentOutput.t());
+    offset += recurrentResetGateWeight.n_elem;
+    // Recurrent update gate weights.
+    gradient.submat(offset, 0, offset + recurrentUpdateGateWeight.n_elem - 1,
+        0) = vectorise(nextDeltaUpdate * currentOutput.t());
+    offset += recurrentUpdateGateWeight.n_elem;
+    // Recurrent hidden gate weights.
+    gradient.submat(offset, 0, offset + recurrentHiddenGateWeight.n_elem - 1,
+        0) = vectorise(nextDeltaHidden * currentOutput.t());
+    offset += recurrentHiddenGateWeight.n_elem;
+  }
+}
+
+template<typename MatType>
+size_t GRU<MatType>::WeightSize() const
+{
+  return outSize * inSize * 3 + /* Input weight connections */
+      outSize * outSize * 3; /* Recurrent weight connections */
+}
+
+template<typename MatType>
+size_t GRU<MatType>::RecurrentSize() const
+{
+  // The recurrent state has to store the output, reset gate, update gate,
+  // and hidden gate.
+  return outSize * 4;
+}
+
+template<typename MatType>
+void GRU<MatType>::OnStepChanged(const size_t step,
+                                 const size_t batchSize,
+                                 const size_t activeBatchSize,
+                                 const bool backwards)
+{
+  // Make aliases for the internal gate states from the recurrent state.
+  MatType& state = this->RecurrentState(step);
+
+  MakeAlias(currentOutput, state, outSize, activeBatchSize);
+  MakeAlias(resetGate, state, outSize, activeBatchSize, outSize * batchSize);
+  MakeAlias(updateGate, state, outSize, activeBatchSize, 2 * outSize *
+      batchSize);
+  MakeAlias(hiddenGate, state, outSize, activeBatchSize, 3 * outSize *
+      batchSize);
+
+  if (this->HasPreviousStep())
+  {
+    MatType& prevState = this->RecurrentState(this->PreviousStep());
+    MakeAlias(prevOutput, prevState, outSize, activeBatchSize);
+  }
+
+  // Also set the workspaces for the backwards pass, if requested.
+  if (backwards)
+  {
+    // We need to hold enough space for two time steps.
+    workspace.set_size(6 * outSize, batchSize);
+
+    if (step % 2 == 0)
+    {
+      MakeAlias(deltaReset, workspace, outSize, activeBatchSize);
+      MakeAlias(deltaUpdate, workspace, outSize, activeBatchSize,
+          outSize * batchSize);
+      MakeAlias(deltaHidden, workspace, outSize, activeBatchSize,
+          2 * outSize * batchSize);
+
+      MakeAlias(nextDeltaReset, workspace, outSize, activeBatchSize,
+          3 * outSize * batchSize);
+      MakeAlias(nextDeltaUpdate, workspace, outSize, activeBatchSize,
+          4 * outSize * batchSize);
+      MakeAlias(nextDeltaHidden, workspace, outSize, activeBatchSize,
+          5 * outSize * batchSize);
+    }
+    else
+    {
+      MakeAlias(nextDeltaReset, workspace, outSize, activeBatchSize);
+      MakeAlias(nextDeltaUpdate, workspace, outSize, activeBatchSize,
+          outSize * batchSize);
+      MakeAlias(nextDeltaHidden, workspace, outSize, activeBatchSize,
+          2 * outSize * batchSize);
+
+      MakeAlias(deltaReset, workspace, outSize, activeBatchSize,
+          3 * outSize * batchSize);
+      MakeAlias(deltaUpdate, workspace, outSize, activeBatchSize,
+          4 * outSize * batchSize);
+      MakeAlias(deltaHidden, workspace, outSize, activeBatchSize,
+          5 * outSize * batchSize);
+    }
+  }
+}
+
+template<typename MatType>
+template<typename Archive>
+void GRU<MatType>::serialize(Archive& ar, const uint32_t /* version */)
+{
+  ar(cereal::base_class<RecurrentLayer<MatType>>(this));
+
+  ar(CEREAL_NVP(inSize));
+  ar(CEREAL_NVP(outSize));
+}
+
+} // namespace mlpack
+
+#endif

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

@@ -46,9 +46,12 @@ namespace mlpack {
  *    type to differ from the input type (Default: arma::mat).
  */
 template <typename MatType = arma::mat>
-class HardTanHType : public Layer<MatType>
+class HardTanH : public Layer<MatType>
 {
  public:
+  // Convenience typedef to access the element type of the weights and data.
+  using ElemType = typename MatType::elem_type;
+
   /**
    * Create the HardTanH object using the specified parameters. The range
    * of the linear region can be adjusted by specifying the maxValue and
@@ -57,24 +60,24 @@ class HardTanHType : public Layer<MatType>
    * @param maxValue Range of the linear region maximum value.
    * @param minValue Range of the linear region minimum value.
    */
-  HardTanHType(const double maxValue = 1, const double minValue = -1);
+  HardTanH(const double maxValue = 1, const double minValue = -1);
 
-  virtual ~HardTanHType() { }
+  virtual ~HardTanH() { }
 
   //! Copy the other HardTanH layer
-  HardTanHType(const HardTanHType& layer);
+  HardTanH(const HardTanH& layer);
 
   //! Take ownership of the members of the other HardTanH Layer
-  HardTanHType(HardTanHType&& layer);
+  HardTanH(HardTanH&& layer);
 
   //! Copy the other HardTanH layer
-  HardTanHType& operator=(const HardTanHType& layer);
+  HardTanH& operator=(const HardTanH& layer);
 
   //! Take ownership of the members of the other HardTanH Layer
-  HardTanHType& operator=(HardTanHType&& layer);
+  HardTanH& operator=(HardTanH&& layer);
 
-  //! Clone the HardTanHType object. This handles polymorphism correctly.
-  HardTanHType* Clone() const { return new HardTanHType(*this); }
+  //! Clone the HardTanH object. This handles polymorphism correctly.
+  HardTanH* Clone() const { return new HardTanH(*this); }
 
   /**
    * Ordinary feed forward pass of a neural network, evaluating the function
@@ -122,12 +125,7 @@ class HardTanHType : public Layer<MatType>
 
   //! Minimum value for the HardTanH function.
   double minValue;
-}; // class HardTanHType
-
-// Convenience typedefs.
-
-// Standard HardTanH layer.
-using HardTanH = HardTanHType<arma::mat>;
+}; // class HardTanH
 
 } // namespace mlpack
 

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

@@ -19,7 +19,7 @@
 namespace mlpack {
 
 template<typename MatType>
-HardTanHType<MatType>::HardTanHType(
+HardTanH<MatType>::HardTanH(
     const double maxValue,
     const double minValue) :
     Layer<MatType>(),
@@ -30,7 +30,7 @@ HardTanHType<MatType>::HardTanHType(
 }
 
 template<typename MatType>
-HardTanHType<MatType>::HardTanHType(const HardTanHType& layer) :
+HardTanH<MatType>::HardTanH(const HardTanH& layer) :
     Layer<MatType>(layer),
     maxValue(layer.maxValue),
     minValue(layer.minValue)
@@ -39,7 +39,7 @@ HardTanHType<MatType>::HardTanHType(const HardTanHType& layer) :
 }
 
 template<typename MatType>
-HardTanHType<MatType>::HardTanHType(HardTanHType&& layer) :
+HardTanH<MatType>::HardTanH(HardTanH&& layer) :
     Layer<MatType>(std::move(layer)),
     maxValue(std::move(layer.maxValue)),
     minValue(std::move(layer.minValue))
@@ -48,8 +48,8 @@ HardTanHType<MatType>::HardTanHType(HardTanHType&& layer) :
 }
 
 template<typename MatType>
-HardTanHType<MatType>& HardTanHType<MatType>::operator=(
-    const HardTanHType& layer)
+HardTanH<MatType>& HardTanH<MatType>::operator=(
+    const HardTanH& layer)
 {
   if (&layer != this)
   {
@@ -62,7 +62,7 @@ HardTanHType<MatType>& HardTanHType<MatType>::operator=(
 }
 
 template<typename MatType>
-HardTanHType<MatType>& HardTanHType<MatType>::operator=(HardTanHType&& layer)
+HardTanH<MatType>& HardTanH<MatType>::operator=(HardTanH&& layer)
 {
   if (&layer != this)
   {
@@ -74,19 +74,19 @@ HardTanHType<MatType>& HardTanHType<MatType>::operator=(HardTanHType&& layer)
   return *this;
 }
 template<typename MatType>
-void HardTanHType<MatType>::Forward(
+void HardTanH<MatType>::Forward(
     const MatType& input, MatType& output)
 {
   #pragma omp parallel for
   for (size_t i = 0; i < input.n_elem; ++i)
   {
-    output(i) = (input(i) > maxValue ? maxValue :
-        (input(i) < minValue ? minValue : input(i)));
+    output(i) = (input(i) > ElemType(maxValue) ? ElemType(maxValue) :
+        (input(i) < ElemType(minValue) ? ElemType(minValue) : input(i)));
   }
 }
 
 template<typename MatType>
-void HardTanHType<MatType>::Backward(
+void HardTanH<MatType>::Backward(
     const MatType& input,
     const MatType& /* output */,
     const MatType& gy,
@@ -99,7 +99,7 @@ void HardTanHType<MatType>::Backward(
   {
     // input should not have any values greater than maxValue
     // and lesser than minValue
-    if (input(i) <= minValue || input(i) >= maxValue)
+    if (input(i) <= ElemType(minValue) || input(i) >= ElemType(maxValue))
     {
       g(i) = 0;
     }
@@ -108,7 +108,7 @@ void HardTanHType<MatType>::Backward(
 
 template<typename MatType>
 template<typename Archive>
-void HardTanHType<MatType>::serialize(
+void HardTanH<MatType>::serialize(
     Archive& ar,
     const uint32_t /* version */)
 {