base_layer.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_ANN_LAYER_BASE_LAYER_HPP
#define MLPACK_METHODS_ANN_LAYER_BASE_LAYER_HPP

#include <mlpack/prereqs.hpp>
#include <mlpack/methods/ann/activation_functions/logistic_function.hpp>
#include <mlpack/methods/ann/activation_functions/identity_function.hpp>
#include <mlpack/methods/ann/activation_functions/rectifier_function.hpp>
#include <mlpack/methods/ann/activation_functions/tanh_function.hpp>
#include <mlpack/methods/ann/activation_functions/softplus_function.hpp>
#include <mlpack/methods/ann/activation_functions/hard_sigmoid_function.hpp>
#include <mlpack/methods/ann/activation_functions/swish_function.hpp>
#include <mlpack/methods/ann/activation_functions/mish_function.hpp>
#include <mlpack/methods/ann/activation_functions/lisht_function.hpp>
#include <mlpack/methods/ann/activation_functions/gelu_function.hpp>
#include <mlpack/methods/ann/activation_functions/elliot_function.hpp>
#include <mlpack/methods/ann/activation_functions/elish_function.hpp>
#include <mlpack/methods/ann/activation_functions/gaussian_function.hpp>
#include <mlpack/methods/ann/activation_functions/hard_swish_function.hpp>
#include <mlpack/methods/ann/activation_functions/tanh_exponential_function.hpp>
#include <mlpack/methods/ann/activation_functions/silu_function.hpp>
#include "layer.hpp"

namespace mlpack {
namespace ann  {

template <
    class ActivationFunction = LogisticFunction,
    typename MatType = arma::mat
>
class BaseLayer : public Layer<MatType>
{
 public:
  BaseLayer() : Layer<MatType>()
  {
    // Nothing to do here.
  }

  // Virtual destructor.
  virtual ~BaseLayer() { }

  // No copy constructor or operators needed here, since the class has no
  // members.

  BaseLayer* Clone() const { return new BaseLayer(*this); }

  void Forward(const MatType& input, MatType& output)
  {
    ActivationFunction::Fn(input, output);
  }

  void Backward(const MatType& input, const MatType& gy, MatType& g)
  {
    MatType derivative;
    ActivationFunction::Deriv(input, derivative);
    g = gy % derivative;
  }

  template<typename Archive>
  void serialize(Archive& ar, const uint32_t /* version */)
  {
    ar(cereal::base_class<Layer<MatType>>(this));
    // Nothing to serialize.
  }
}; // class BaseLayer

// Convenience typedefs.

typedef BaseLayer<LogisticFunction, arma::mat> Sigmoid;

template<typename MatType = arma::mat>
using SigmoidType = BaseLayer<LogisticFunction, MatType>;

typedef BaseLayer<RectifierFunction, arma::mat> ReLU;

template<typename MatType = arma::mat>
using ReLUType = BaseLayer<RectifierFunction, MatType>;

typedef BaseLayer<TanhFunction, arma::mat> TanH;

template<typename MatType = arma::mat>
using TanHType = BaseLayer<TanhFunction, MatType>;

typedef BaseLayer<SoftplusFunction, arma::mat> SoftPlus;

template<typename MatType = arma::mat>
using SoftPlusType = BaseLayer<SoftplusFunction, MatType>;

typedef BaseLayer<HardSigmoidFunction, arma::mat> HardSigmoid;

template<typename MatType = arma::mat>
using HardSigmoidType = BaseLayer<HardSigmoidFunction, MatType>;

typedef BaseLayer<SwishFunction, arma::mat> Swish;

template<typename MatType = arma::mat>
using SwishType = BaseLayer<SwishFunction, MatType>;

typedef BaseLayer<MishFunction, arma::mat> Mish;

template<typename MatType = arma::mat>
using MishType = BaseLayer<MishFunction, MatType>;

typedef BaseLayer<LiSHTFunction, arma::mat> LiSHT;

template<typename MatType = arma::mat>
using LiSHTType = BaseLayer<LiSHTFunction, MatType>;

typedef BaseLayer<GELUFunction, arma::mat> GELU;

template<typename MatType = arma::mat>
using GELUType = BaseLayer<GELUFunction, MatType>;

typedef BaseLayer<ElliotFunction, arma::mat> Elliot;

template<typename MatType = arma::mat>
using ElliotType = BaseLayer<ElliotFunction, MatType>;

typedef BaseLayer<ElishFunction, arma::mat> Elish;

template<typename MatType = arma::mat>
using ElishType = BaseLayer<ElishFunction, MatType>;

typedef BaseLayer<GaussianFunction, arma::mat> Gaussian;

template<typename MatType = arma::mat>
using GaussianType = BaseLayer<GaussianFunction, MatType>;

typedef BaseLayer<HardSwishFunction, arma::mat> HardSwish;

template <typename MatType = arma::mat>
using HardSwishType = BaseLayer<HardSwishFunction, MatType>;

typedef BaseLayer<TanhExpFunction, arma::mat> TanhExp;

template<typename MatType = arma::mat>
using TanhExpType = BaseLayer<TanhExpFunction, MatType>;

typedef BaseLayer<SILUFunction, arma::mat> SILU;

template<typename MatType = arma::mat>
using SILUType = BaseLayer<SILUFunction, MatType>;

} // namespace ann
} // namespace mlpack

#endif