Improve TransposedConvolution layer.

src/mlpack/methods/ann/layer/layer_types.hpp

@@ -213,7 +213,7 @@ using LayerTypes = boost::variant<
                 NaiveConvolution<FullConvolution>,
                 NaiveConvolution<ValidConvolution>, arma::mat, arma::mat>*,
     TransposedConvolution<NaiveConvolution<ValidConvolution>,
-            NaiveConvolution<FullConvolution>,
+            NaiveConvolution<ValidConvolution>,
             NaiveConvolution<ValidConvolution>, arma::mat, arma::mat>*,
     DropConnect<arma::mat, arma::mat>*,
     Dropout<arma::mat, arma::mat>*,

src/mlpack/methods/ann/layer/transposed_convolution.hpp

@@ -40,7 +40,7 @@ namespace ann /** Artificial Neural Network. */ {
  */
 template <
     typename ForwardConvolutionRule = NaiveConvolution<ValidConvolution>,
-    typename BackwardConvolutionRule = NaiveConvolution<FullConvolution>,
+    typename BackwardConvolutionRule = NaiveConvolution<ValidConvolution>,
     typename GradientConvolutionRule = NaiveConvolution<ValidConvolution>,
     typename InputDataType = arma::mat,
     typename OutputDataType = arma::mat
@@ -52,8 +52,14 @@ class TransposedConvolution
   TransposedConvolution();
 
   /**
-   * Create the Transposed Convolution object using the specified number of input maps,
-   * output maps, filter size, stride and padding parameter.
+   * Create the Transposed Convolution object using the specified number of
+   * input maps, output maps, filter size, stride and padding parameter.
+   *
+   * Note: The equivalent stride of a transposed convolution operation is always
+   * equal to 1. In this implementation, stride of filter represents the stride
+   * of the associated convolution operation.
+   * Note: Padding of input represents padding of associated convolution
+   * operation.
    *
    * @param inSize The number of input maps.
    * @param outSize The number of output maps.
@@ -65,6 +71,8 @@ class TransposedConvolution
    * @param padH Padding height of the input.
    * @param inputWidth The width of the input data.
    * @param inputHeight The height of the input data.
+   * @param outputWidth The width of the output data.
+   * @param outputHeight The height of the output data.
    */
   TransposedConvolution(const size_t inSize,
                         const size_t outSize,
@@ -75,7 +83,9 @@ class TransposedConvolution
                         const size_t padW = 0,
                         const size_t padH = 0,
                         const size_t inputWidth = 0,
-                        const size_t inputHeight = 0);
+                        const size_t inputHeight = 0,
+                        const size_t outputWidth = 0,
+                        const size_t outputHeight = 0);
 
   /*
    * Set the weight and bias term.
@@ -173,24 +183,6 @@ class TransposedConvolution
   void serialize(Archive& ar, const unsigned int /* version */);
 
  private:
-  /*
-   * Return the transposed convolution output size.
-   *
-   * @param size The size of the input (row or column).
-   * @param k The size of the filter (width or height).
-   * @param s The stride size (x or y direction).
-   * @param p The size of the padding (width or height).
-   * @return The transposed convolution output size.
-   */
-  size_t TransposedConvOutSize(const size_t size,
-                               const size_t k,
-                               const size_t s,
-                               const size_t p)
-  {
-    size_t out = std::floor(size - k + 2 * p) / s;
-    return out * s + 2 * (k - p) - 1 + ((((size + 2 * p - k) % s) + s) % s);
-  }
-
   /*
    * Rotates a 3rd-order tensor counterclockwise by 180 degrees.
    *
@@ -220,6 +212,119 @@ class TransposedConvolution
     output = arma::fliplr(arma::flipud(input));
   }
 
+  /*
+   * Pad the given input data.
+   *
+   * @param input The input to be padded.
+   * @param wPad Padding width of the input.
+   * @param hPad Padding height of the input.
+   * @param wExtra The number of extra zeros to the right.
+   * @param hExtra The number of extra zeros to the bottom.
+   * @param output The padded output data.
+   */
+  template<typename eT>
+  void Pad(const arma::Mat<eT>& input,
+           const size_t wPad,
+           const size_t hPad,
+           const size_t wExtra,
+           const size_t hExtra,
+           arma::Mat<eT>& output)
+  {
+    if (output.n_rows != input.n_rows + wPad * 2 + wExtra ||
+        output.n_cols != input.n_cols + hPad * 2 + hExtra)
+    {
+      output = arma::zeros(input.n_rows + wPad * 2 + wExtra,
+          input.n_cols + hPad * 2 + hExtra);
+    }
+
+    output.submat(wPad, hPad, wPad + input.n_rows - 1,
+        hPad + input.n_cols - 1) = input;
+  }
+
+  /*
+   * Pad the given input data.
+   *
+   * @param input The input to be padded.
+   * @param wPad Padding width of the input.
+   * @param hPad Padding height of the input.
+   * @param wExtra The number of extra zeros to the right.
+   * @param hExtra The number of extra zeros to the bottom.
+   * @param output The padded output data.
+   */
+  template<typename eT>
+  void Pad(const arma::Cube<eT>& input,
+           const size_t wPad,
+           const size_t hPad,
+           const size_t wExtra,
+           const size_t hExtra,
+           arma::Cube<eT>& output)
+  {
+    output = arma::zeros(input.n_rows + wPad * 2 + wExtra,
+        input.n_cols + hPad * 2 + hExtra, input.n_slices);
+
+    for (size_t i = 0; i < input.n_slices; ++i)
+    {
+      Pad<eT>(input.slice(i), wPad, hPad, wExtra, hExtra, output.slice(i));
+    }
+  }
+
+  /*
+   * Insert zeros between the units of the given input data.
+   * Note: This function should be used before the Pad() function.
+   *
+   * @param input The input to be padded.
+   * @param dW Stride of filter application in the x direction.
+   * @param dH Stride of filter application in the y direction.
+   * @param output The padded output data.
+   */
+  template<typename eT>
+  void InsertZeros(const arma::Mat<eT>& input,
+                   const size_t dW,
+                   const size_t dH,
+                   arma::Mat<eT>& output)
+  {
+    if (output.n_rows != input.n_rows * dW - dW + 1 ||
+        output.n_cols != input.n_cols * dH - dH + 1)
+    {
+      output = arma::zeros(input.n_rows * dW - dW + 1,
+          input.n_cols * dH - dH + 1);
+    }
+
+    for (size_t i = 0; i < output.n_rows; i += dH)
+    {
+      for (size_t j = 0; j < output.n_cols; j += dW)
+      {
+        // TODO: Use [] instead of () for speedup after this is completely
+        // debugged and approved.
+        output(i, j) = input(i / dH, j / dW);
+      }
+    }
+  }
+
+  /*
+   * Insert zeros between the units of the given input data.
+   * Note: This function should be used before the Pad() function.
+   *
+   * @param input The input to be padded.
+   * @param dW Stride of filter application in the x direction.
+   * @param dH Stride of filter application in the y direction.
+   * @param output The padded output data.
+   */
+  template<typename eT>
+  void InsertZeros(const arma::Cube<eT>& input,
+                   const size_t dW,
+                   const size_t dH,
+                   arma::Cube<eT>& output)
+  {
+    output = arma::zeros(input.n_rows * dW - dW + 1,
+        input.n_cols * dH - dH + 1, input.n_slices);
+
+    for (size_t i = 0; i < input.n_slices; ++i)
+    {
+      InsertZeros<eT>(input.slice(i), dW, dH, output.slice(i));
+    }
+  }
+
   //! Locally-stored number of input channels.
   size_t inSize;
 
@@ -247,6 +352,12 @@ class TransposedConvolution
   //! Locally-stored padding height.
   size_t padH;
 
+  //! Locally-stored number of zeros added to the right of input.
+  size_t aW;
+
+  //! Locally-stored number of zeros added to the top of input.
+  size_t aH;
+
   //! Locally-stored weight object.
   OutputDataType weights;
 
@@ -277,6 +388,9 @@ class TransposedConvolution
   //! Locally-stored transformed padded input parameter.
   arma::cube inputPaddedTemp;
 
+  //! Locally-stored transformed expanded input parameter.
+  arma::cube inputExpandedTemp;
+
   //! Locally-stored transformed error parameter.
   arma::cube gTemp;