net_layer.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2017 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/

#include <string>
#include <vector>

#include "modules/prediction/network/net_util.h"

#pragma once

namespace apollo {
namespace prediction {
namespace network {

class Layer {
 public:
  Layer() = default;

  virtual ~Layer() = default;

  virtual bool Load(const apollo::prediction::LayerParameter& layer_pb);

  virtual void ResetState() {}

  virtual void SetState(const std::vector<Eigen::MatrixXf>& states) {}

  virtual void State(std::vector<Eigen::MatrixXf>* states) const {}

  virtual void Run(const std::vector<Eigen::MatrixXf>& inputs,
                   Eigen::MatrixXf* output) = 0;

  std::string Name() const { return name_; }

  int OrderNumber() const { return order_number_; }

 private:
  std::string name_;
  int order_number_ = -1;
};

class Dense : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  bool Load(const apollo::prediction::DenseParameter& layer_pb);

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  int units_;
  bool use_bias_;
  Eigen::MatrixXf weights_;
  Eigen::VectorXf bias_;
  std::function<float(float)> kactivation_;
};

class Conv1d : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  bool Load(const apollo::prediction::Conv1dParameter& conv1d_pb);

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  std::vector<int> shape_;
  bool use_bias_;
  std::vector<Eigen::MatrixXf> kernel_;
  Eigen::VectorXf bias_;
  int stride_;
};

class MaxPool1d : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  bool Load(const apollo::prediction::MaxPool1dParameter& maxpool1d_pb);

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  int kernel_size_;
  int stride_;
};

class AvgPool1d : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  bool Load(const apollo::prediction::AvgPool1dParameter& avgpool1d_pb);

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  int kernel_size_;
  int stride_;
};

class Activation : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  bool Load(const apollo::prediction::ActivationParameter& activation_pb);

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  std::function<float(float)> kactivation_;
};

class BatchNormalization : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  Eigen::VectorXf mu_;
  Eigen::VectorXf sigma_;
  Eigen::VectorXf gamma_;
  Eigen::VectorXf beta_;
  float epsilon_ = 0.0f;
  float momentum_ = 0.0f;
  int axis_ = 0;
  bool center_ = false;
  bool scale_ = false;
};

class LSTM : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

  void ResetState() override;

  void SetState(const std::vector<Eigen::MatrixXf>& states) override;

  void State(std::vector<Eigen::MatrixXf>* states) const override;

 private:
  void Step(const Eigen::MatrixXf& input, Eigen::MatrixXf* output,
            Eigen::MatrixXf* ht_1, Eigen::MatrixXf* ct_1);

  Eigen::MatrixXf wi_;
  Eigen::MatrixXf wf_;
  Eigen::MatrixXf wc_;
  Eigen::MatrixXf wo_;
  Eigen::VectorXf bi_;
  Eigen::VectorXf bf_;
  Eigen::VectorXf bc_;
  Eigen::VectorXf bo_;

  Eigen::MatrixXf r_wi_;
  Eigen::MatrixXf r_wf_;
  Eigen::MatrixXf r_wc_;
  Eigen::MatrixXf r_wo_;

  Eigen::MatrixXf ht_1_;
  Eigen::MatrixXf ct_1_;
  std::function<float(float)> kactivation_;
  std::function<float(float)> krecurrent_activation_;
  int units_ = 0;
  bool return_sequences_ = false;
  bool stateful_ = false;
  bool use_bias_ = false;
  bool unit_forget_bias_ = false;
};

class Flatten : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;
};

class Input : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  std::vector<int> input_shape_;
  std::string dtype_;
  bool sparse_ = false;
};

class Concatenate : public Layer {
 public:
  bool Load(const apollo::prediction::LayerParameter& layer_pb) override;

  void Run(const std::vector<Eigen::MatrixXf>& inputs,
           Eigen::MatrixXf* output) override;

 private:
  int axis_ = 0;
};

}  // namespace network
}  // namespace prediction
}  // namespace apollo