apollo::prediction::network::LSTM类 参考

Long-Short Term Memory unit - Hochreiter 1997. 更多...

#include <net_layer.h>

类 apollo::prediction::network::LSTM 继承关系图:

apollo::prediction::network::LSTM 的协作图:

Public 成员函数
bool	Load (const apollo::prediction::LayerParameter &layer_pb) override
	Load the layer parameter from a pb message
void	Run (const std::vector< Eigen::MatrixXf > &inputs, Eigen::MatrixXf *output) override
	Compute the layer output from inputs
void	ResetState () override
	Reset the internal state and memory cell state as zero-matrix
void	SetState (const std::vector< Eigen::MatrixXf > &states) override
	Set the internal state and memory cell state
void	State (std::vector< Eigen::MatrixXf > *states) const override
	Access to the internal state and memory cell state
Public 成员函数 继承自 apollo::prediction::network::Layer
	Layer ()=default
	Constructor
virtual	~Layer ()=default
	Destructor
std::string	Name () const
	Name of a layer
int	OrderNumber () const
	Order number of a layer in a network

详细描述

Long-Short Term Memory unit - Hochreiter 1997.

For a step-by-step description of the algorithm, see this tutorial.

在文件 net_layer.h 第 322 行定义.

成员函数说明

Load()

bool apollo::prediction::network::LSTM::Load ( const apollo::prediction::LayerParameter &  layer_pb )

overridevirtual

Load the layer parameter from a pb message

参数

A	pb message contains the parameters

返回

True is loaded successively, otherwise False

重载 apollo::prediction::network::Layer .

在文件 net_layer.cc 第 319 行定义.

                                              {
  if (!Layer::Load(layer_pb)) {
    AERROR << "Fail to Load the layer parameters!";
    return false;
  }
  LSTMParameter lstm_pb = layer_pb.lstm();
  if (!lstm_pb.has_units()) {
    ADEBUG << "Fail to Load the number of units.";
    return false;
  } else {
    units_ = lstm_pb.units();
  }
  if (!lstm_pb.has_return_sequences()) {
    ADEBUG << "Set return_sequences at default.";
    return_sequences_ = false;
  } else {
    return_sequences_ = lstm_pb.return_sequences();
  }
  if (!lstm_pb.has_stateful()) {
    ADEBUG << "Set stateful at default.";
    stateful_ = false;
  } else {
    stateful_ = lstm_pb.stateful();
  }
  if (!lstm_pb.has_activation()) {
    ADEBUG << "Set activation function as tanh.";
    kactivation_ = serialize_to_function("tanh");
  } else {
    kactivation_ = serialize_to_function(lstm_pb.activation());
  }
  if (!lstm_pb.has_recurrent_activation()) {
    ADEBUG << "Set recurrent_activation function as hard_tanh.";
    krecurrent_activation_ = serialize_to_function("hard_tanh");
  } else {
    krecurrent_activation_ =
        serialize_to_function(lstm_pb.recurrent_activation());
  }
  if (!lstm_pb.has_use_bias()) {
    ADEBUG << "Set use_bias as true.";
    use_bias_ = true;
  } else {
    use_bias_ = lstm_pb.use_bias();
  }
  if (!lstm_pb.has_unit_forget_bias()) {
    ADEBUG << "Set unit forget bias as true.";
    unit_forget_bias_ = true;
  } else {
    unit_forget_bias_ = lstm_pb.unit_forget_bias();
  }
  if (!lstm_pb.has_weights_input() ||
      !LoadTensor(lstm_pb.weights_input(), &wi_)) {
    AERROR << "Fail to Load input weights!";
    return false;
  }
  if (!lstm_pb.has_weights_forget() ||
      !LoadTensor(lstm_pb.weights_forget(), &wf_)) {
    AERROR << "Fail to Load forget weights!";
    return false;
  }
  if (!lstm_pb.has_weights_cell() ||
      !LoadTensor(lstm_pb.weights_cell(), &wc_)) {
    AERROR << "Fail to Load cell weights!";
    return false;
  }
  if (!lstm_pb.has_weights_output() ||
      !LoadTensor(lstm_pb.weights_output(), &wo_)) {
    AERROR << "Fail to Load output weights!";
    return false;
  }
  if (!lstm_pb.has_bias_input() || !LoadTensor(lstm_pb.bias_input(), &bi_)) {
    AERROR << "Fail to Load input bias!";
    return false;
  }
  if (!lstm_pb.has_bias_forget() || !LoadTensor(lstm_pb.bias_forget(), &bf_)) {
    AERROR << "Fail to Load forget bias!";
    return false;
  }
  if (!lstm_pb.has_bias_cell() || !LoadTensor(lstm_pb.bias_cell(), &bc_)) {
    AERROR << "Fail to Load cell bias!";
    return false;
  }
  if (!lstm_pb.has_bias_output() || !LoadTensor(lstm_pb.bias_output(), &bo_)) {
    AERROR << "Fail to Load output bias!";
    return false;
  }
  if (!lstm_pb.has_recurrent_weights_input() ||
      !LoadTensor(lstm_pb.recurrent_weights_input(), &r_wi_)) {
    AERROR << "Fail to Load recurrent input weights!";
    return false;
  }
  if (!lstm_pb.has_recurrent_weights_forget() ||
      !LoadTensor(lstm_pb.recurrent_weights_forget(), &r_wf_)) {
    AERROR << "Fail to Load recurrent forget weights!";
    return false;
  }
  if (!lstm_pb.has_recurrent_weights_cell() ||
      !LoadTensor(lstm_pb.recurrent_weights_cell(), &r_wc_)) {
    AERROR << "Fail to Load recurrent cell weights!";
    return false;
  }
  if (!lstm_pb.has_recurrent_weights_output() ||
      !LoadTensor(lstm_pb.recurrent_weights_output(), &r_wo_)) {
    AERROR << "Fail to Load recurrent output weights!";
    return false;
  }
  ResetState();
  return true;
}

ResetState()

void apollo::prediction::network::LSTM::ResetState ( )

overridevirtual

Reset the internal state and memory cell state as zero-matrix

重载 apollo::prediction::network::Layer .

在文件 net_layer.cc 第 464 行定义.

                      {
  ht_1_.resize(1, units_);
  ct_1_.resize(1, units_);
  ht_1_.fill(0.0);
  ct_1_.fill(0.0);
}

Run()

void apollo::prediction::network::LSTM::Run ( const std::vector< Eigen::MatrixXf > &  inputs, Eigen::MatrixXf *  output  )

overridevirtual

Compute the layer output from inputs

参数

Inputs	to a network layer
Output	of a network layer will be returned

实现了 apollo::prediction::network::Layer.

在文件 net_layer.cc 第 448 行定义.

                                      {
  CHECK_EQ(inputs.size(), 1U);
  Eigen::MatrixXf sequences(inputs[0].rows(), units_);
  Eigen::MatrixXf temp;
  for (int i = 0; i < inputs[0].rows(); ++i) {
    Step(inputs[0].row(i), &temp, &ht_1_, &ct_1_);
    sequences.row(i) = temp.row(0);
  }
  if (return_sequences_) {
    *output = sequences;
  } else {
    *output = temp.row(0);
  }
}

SetState()

void apollo::prediction::network::LSTM::SetState ( const std::vector< Eigen::MatrixXf > &  states )

overridevirtual

Set the internal state and memory cell state

参数

A	vector of Eigen::MatrixXf

重载 apollo::prediction::network::Layer .

在文件 net_layer.cc 第 477 行定义.

                                                          {
  CHECK_EQ(states.size(), 2U);
  CHECK_EQ(states[0].rows(), 1);
  CHECK_EQ(states[1].rows(), 1);
  CHECK_EQ(states[0].cols(), units_);
  CHECK_EQ(states[1].cols(), units_);
  ht_1_ = states[0];
  ct_1_ = states[1];
}

State()

void apollo::prediction::network::LSTM::State ( std::vector< Eigen::MatrixXf > *  states ) const

overridevirtual

Access to the internal state and memory cell state

返回

State in a vector of Eigen::MatrixXf

重载 apollo::prediction::network::Layer .

在文件 net_layer.cc 第 471 行定义.

                                                       {
  states->resize(2);
  states->at(0) = ht_1_;
  states->at(1) = ct_1_;
}

---

该类的文档由以下文件生成:

• modules/prediction/network/net_layer.h
• modules/prediction/network/net_layer.cc