concat.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_ANN_LAYER_CONCAT_HPP
#define MLPACK_METHODS_ANN_LAYER_CONCAT_HPP

#include <mlpack/prereqs.hpp>

#include "layer.hpp"

namespace mlpack {
namespace ann  {

template <typename MatType = arma::mat>
class ConcatType : public MultiLayer<MatType>
{
 public:
  ConcatType();

  ConcatType(const size_t axis);

  virtual ~ConcatType();

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

  ConcatType(const ConcatType& other);
  ConcatType(ConcatType&& other);
  ConcatType& operator=(const ConcatType& other);
  ConcatType& operator=(ConcatType&& other);

  void Forward(const MatType& input, MatType& output);

  void Backward(const MatType& /* input */,
                const MatType& gy,
                MatType& g);

  void Backward(const MatType& /* input */,
                const MatType& gy,
                MatType& g,
                const size_t index);

  void Gradient(const MatType& /* input */,
                const MatType& error,
                MatType& /* gradient */);

  void Gradient(const MatType& input,
                const MatType& error,
                MatType& gradient,
                const size_t index);

  size_t Axis() const { return axis; }

  // We don't need to overload WeightSize(); MultiLayer already computes this
  // correctly.  (It is the sum of weights of all child layers.)

  void ComputeOutputDimensions()
  {
    // The input is sent to every layer.
    for (size_t i = 0; i < this->network.size(); ++i)
    {
      this->network[i]->InputDimensions() = this->inputDimensions;
      this->network[i]->ComputeOutputDimensions();
    }

    const size_t numOutputDimensions = (this->network.size() == 0) ?
        this->inputDimensions.size() :
        this->network[0]->OutputDimensions().size();

    // If the user did not specify an axis, we will use the last one.
    // Otherwise, we must sanity check to ensure that the axis we are
    // concatenating along is valid.
    if (!useAxis)
    {
      axis = this->inputDimensions.size() - 1;
    }
    else if (axis >= numOutputDimensions)
    {
      std::ostringstream oss;
      oss << "Concat::ComputeOutputDimensions(): cannot concatenate outputs "
          << "along axis " << axis << " when input only has "
          << this->inputDimensions.size() << " axes!";
      throw std::invalid_argument(oss.str());
    }

    // Now, we concatenate the output along a specific axis.
    this->outputDimensions = std::vector<size_t>(numOutputDimensions, 0);
    for (size_t i = 0; i < this->outputDimensions.size(); ++i)
    {
      if (i == axis)
      {
        // Accumulate output size along this axis for each layer output.
        for (size_t n = 0; n < this->network.size(); ++n)
          this->outputDimensions[i] += this->network[n]->OutputDimensions()[i];
      }
      else
      {
        // Ensure that the output size is the same along this axis.
        const size_t axisDim = this->network[0]->OutputDimensions()[i];
        for (size_t n = 1; n < this->network.size(); ++n)
        {
          const size_t axisDim2 = this->network[n]->OutputDimensions()[i];
          if (axisDim != axisDim2)
          {
            std::ostringstream oss;
            oss << "Concat::ComputeOutputDimensions(): cannot concatenate "
                << "outputs along axis " << axis << "; held layer " << n
                << " has output size " << axisDim2 << " along axis " << i
                << ", but the first held layer has output size " << axisDim
                << "!  All layers must have identical output size in any "
                << "axis other than the concatenated axis.";
            throw std::invalid_argument(oss.str());
          }
        }

        this->outputDimensions[i] = axisDim;
      }
    }

    // Recompute total input and output sizes.  Note that we pass the input to
    // each layer held in the network, so the "total" input size (which is used
    // by the backwards pass to compute how much memory to use for holding
    // deltas) should be the number of layers multiplied by the input size for
    // each layer.
    this->totalInputSize = 1;
    this->totalOutputSize = 1;
    for (size_t i = 0; i < this->inputDimensions.size(); ++i)
      this->totalInputSize *= this->inputDimensions[i];
    this->totalInputSize *= this->network.size();
    for (size_t i = 0; i < this->outputDimensions.size(); ++i)
      this->totalOutputSize *= this->outputDimensions[i];
  }

  template<typename Archive>
  void serialize(Archive& ar, const uint32_t /* version */);

 private:
  size_t axis;

  bool useAxis;
}; // class ConcatType.

// Standard Concat layer.
typedef ConcatType<arma::mat> Concat;

} // namespace ann
} // namespace mlpack

// Include implementation.
#include "concat_impl.hpp"

#endif