Method setup_data

src/layers/learning/channelwise_fully_connected.cpp:545–650

template <typename TensorDataType, data_layout Layout, El::Device Device>
void channelwise_fully_connected_layer<TensorDataType, Layout, Device>::
  setup_data(size_t max_mini_batch_size)
{
  data_type_layer<TensorDataType>::setup_data(max_mini_batch_size);

  // Tensor dimensions
  const auto& input_dims = this->get_input_dims();
  const auto& output_dims = this->get_output_dims();
  const std::vector<size_t> input_channel_dims(input_dims.begin() + 1,
                                               input_dims.end());
  const std::vector<size_t> output_channel_dims(output_dims.begin() + 1,
                                                output_dims.end());
  const auto& input_channel_size = std::accumulate(input_channel_dims.begin(),
                                                   input_channel_dims.end(),
                                                   1,
                                                   std::multiplies<size_t>());
  const auto& output_channel_size = std::accumulate(output_channel_dims.begin(),
                                                    output_channel_dims.end(),
                                                    1,
                                                    std::multiplies<size_t>());

  // Set number of weights
  using WeightsType = data_type_weights<TensorDataType>;
  if ((m_has_bias && this->num_weights() > 2) ||
      (!m_has_bias && this->num_weights() > 1)) {
    LBANN_ERROR("attempted to setup ",
                this->get_type(),
                " layer \"",
                this->get_name(),
                "\" ",
                "with an invalid number of weights ",
                "(",
                this->num_weights(),
                ")");
  }
  this->set_num_weights(m_has_bias ? 2 : 1);

  // Create default linearity weights if needed
  if (!this->has_weights(0)) {
    auto w = std::make_shared<WeightsType>(*this->get_comm());
    auto init = std::make_unique<he_initializer<TensorDataType>>(
      probability_distribution::gaussian);
    auto opt = this->m_model->template create_optimizer<TensorDataType>();
    w->set_name(this->get_name() + "_linearity_weights");
    w->set_initializer(std::move(init));
    w->set_optimizer(std::move(opt));
    this->set_weights(0, w);
    this->m_model->add_weights(std::move(w));
  }

  // Setup linearity weights
  {
    auto& linearity_weights = this->get_weights(0);
    auto dist = this->get_prev_activations().DistData();
    if (dist.colDist != El::MC || dist.rowDist != El::MR) {
      dist.colDist = El::STAR;
      dist.rowDist = El::STAR;
    }