Method apply_convolution_im2col

src/layers/learning/base_convolution.cpp:805–864

template <typename TensorDataType, El::Device Device>
void base_convolution_layer<TensorDataType, Device>::apply_convolution_im2col(
  bool during_forward_prop)
{

  // Local matrices
  const auto& local_kernel = this->weights_values(0).LockedMatrix();
  const auto& local_input =
    (during_forward_prop ? this->get_local_prev_activations()
                         : this->get_local_prev_error_signals());
  auto& local_output = (during_forward_prop ? this->get_local_activations()
                                            : this->get_local_error_signals());

  // Matrix parameters
  const int output_size = local_output.Height();
  const El::Int local_width = local_input.Width();
  std::vector<int> input_dims, output_dims;
  if (during_forward_prop) {
    input_dims = this->get_input_dims();
    output_dims = this->get_output_dims();
  }
  else {
    input_dims = this->get_output_dims();
    output_dims = this->get_input_dims();
  }
  const auto& kernel_dims = this->get_kernel_dims();
  const auto kernel_size = get_linear_size(kernel_dims);

  // Initialize matrices
  const int m = output_size / output_dims[0];
  const int n = output_dims[0];
  const int k = kernel_size / output_dims[0];
  DMatDT<Device> input_col, output_col;
  DMatDT<Device> im2col_matrix(k, m);
  const DMatDT<Device> kernel_matrix(k, n, local_kernel.LockedBuffer(), k);

  // Iterate through input columns
  for (El::Int col = 0; col < local_width; ++col) {

    // Construct im2col matrix from current input column
    El::LockedView(input_col, local_input, El::ALL, El::IR(col));
    im2col<TensorDataType>(input_col,
                           im2col_matrix,
                           input_dims[0],
                           input_dims.size() - 1,
                           &input_dims[1],
                           m_pads.data(),
                           &kernel_dims[2],
                           m_strides.data());

    // Apply convolution to current input column
    output_col.Attach(m, n, local_output.Buffer(0, col), m);
    El::Gemm(El::TRANSPOSE,
             El::NORMAL,
             El::TypeTraits<TensorDataType>::One(),
             im2col_matrix,
             kernel_matrix,
             El::TypeTraits<TensorDataType>::Zero(),
             output_col);