net_layer.h

浏览该文件的文档.

/******************************************************************************
 * 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