apollo::prediction::LaneAggregatingEvaluator类 参考

#include <lane_aggregating_evaluator.h>

类 apollo::prediction::LaneAggregatingEvaluator 继承关系图:

apollo::prediction::LaneAggregatingEvaluator 的协作图:

Public 成员函数
	LaneAggregatingEvaluator ()
	Constructor
virtual	~LaneAggregatingEvaluator ()=default
	Destructor
bool	Evaluate (Obstacle *obstacle_ptr, ObstaclesContainer *obstacles_container) override
	Override Evaluate
std::string	GetName () override
	Get the name of evaluator.
Public 成员函数 继承自 apollo::prediction::Evaluator
	Evaluator ()=default
	Constructor
virtual	~Evaluator ()=default
	Destructor
virtual bool	Evaluate (Obstacle *obstacle, ObstaclesContainer *obstacles_container, std::vector< Obstacle * > dynamic_env)
	Evaluate an obstacle
virtual bool	Evaluate (const ADCTrajectoryContainer *adc_trajectory_container, Obstacle *obstacle, ObstaclesContainer *obstacles_container)
	Evaluate an obstacle

额外继承的成员函数
Protected 成员函数 继承自 apollo::prediction::Evaluator
std::pair< double, double >	WorldCoordToObjCoord (std::pair< double, double > input_world_coord, std::pair< double, double > obj_world_coord, double obj_world_angle)
std::pair< double, double >	WorldCoordToObjCoordNorth (std::pair< double, double > input_world_coord, std::pair< double, double > obj_world_coord, double obj_world_angle)
double	WorldAngleToObjAngle (double input_world_angle, double obj_world_angle)
Eigen::MatrixXf	VectorToMatrixXf (const std::vector< double > &nums, const int start_index, const int end_index)
Eigen::MatrixXf	VectorToMatrixXf (const std::vector< double > &nums, const int start_index, const int end_index, const int output_num_row, const int output_num_col)
Protected 属性 继承自 apollo::prediction::Evaluator
ObstacleConf::EvaluatorType	evaluator_type_

详细描述

在文件 lane_aggregating_evaluator.h 第 40 行定义.

构造及析构函数说明

LaneAggregatingEvaluator()

apollo::prediction::LaneAggregatingEvaluator::LaneAggregatingEvaluator

(

)

Constructor

在文件 lane_aggregating_evaluator.cc 第 32 行定义.

                                                   : device_(torch::kCPU) {
  evaluator_type_ = ObstacleConf::LANE_AGGREGATING_EVALUATOR;
  LoadModel();
}

~LaneAggregatingEvaluator()

virtual apollo::prediction::LaneAggregatingEvaluator::~LaneAggregatingEvaluator ( )

virtualdefault

Destructor

成员函数说明

Evaluate()

bool apollo::prediction::LaneAggregatingEvaluator::Evaluate ( Obstacle *  obstacle_ptr, ObstaclesContainer *  obstacles_container  )

overridevirtual

Override Evaluate

参数

Obstacle	pointer
Obstacles	container

实现了 apollo::prediction::Evaluator.

在文件 lane_aggregating_evaluator.cc 第 47 行定义.

                                                                     {
  // Sanity checks.
  CHECK_NOTNULL(obstacle_ptr);
 
  obstacle_ptr->SetEvaluatorType(evaluator_type_);
 
  int id = obstacle_ptr->id();
  if (!obstacle_ptr->latest_feature().IsInitialized()) {
    AERROR << "Obstacle [" << id << "] has no latest feature.";
    return false;
  }
  Feature* latest_feature_ptr = obstacle_ptr->mutable_latest_feature();
  CHECK_NOTNULL(latest_feature_ptr);
  if (!latest_feature_ptr->has_lane() ||
      !latest_feature_ptr->lane().has_lane_graph_ordered()) {
    AERROR << "Obstacle [" << id << "] has no lane graph.";
    return false;
  }
  LaneGraph* lane_graph_ptr =
      latest_feature_ptr->mutable_lane()->mutable_lane_graph_ordered();
  CHECK_NOTNULL(lane_graph_ptr);
  if (lane_graph_ptr->lane_sequence().empty()) {
    AERROR << "Obstacle [" << id << "] has no lane sequences.";
    return false;
  }
  ADEBUG << "There are " << lane_graph_ptr->lane_sequence_size()
         << " lane sequences to scan.";
 
  // Extract features, and do model inferencing.
  // 1. Encode the obstacle features.
  std::vector<double> obstacle_feature_values;
  if (!ExtractObstacleFeatures(obstacle_ptr, &obstacle_feature_values)) {
    ADEBUG << "Failed to extract obstacle features for obs_id = " << id;
  }
  if (obstacle_feature_values.size() != OBSTACLE_FEATURE_SIZE) {
    ADEBUG << "Obstacle [" << id << "] has fewer than "
           << "expected obstacle feature_values "
           << obstacle_feature_values.size() << ".";
    return false;
  }
  ADEBUG << "Obstacle feature size = " << obstacle_feature_values.size();
  std::vector<torch::jit::IValue> obstacle_encoding_inputs;
  torch::Tensor obstacle_encoding_inputs_tensor =
      torch::zeros({1, static_cast<int>(obstacle_feature_values.size())});
  for (size_t i = 0; i < obstacle_feature_values.size(); ++i) {
    obstacle_encoding_inputs_tensor[0][i] =
        static_cast<float>(obstacle_feature_values[i]);
  }
  obstacle_encoding_inputs.push_back(
      std::move(obstacle_encoding_inputs_tensor));
  torch::Tensor obstalce_encoding =
      torch_obstacle_encoding_.forward(obstacle_encoding_inputs)
          .toTensor()
          .to(torch::kCPU);
  // 2. Encode the lane features.
  std::vector<std::vector<double>> lane_feature_values;
  std::vector<int> lane_sequence_idx_to_remove;
  if (!ExtractStaticEnvFeatures(obstacle_ptr, lane_graph_ptr,
                                &lane_feature_values,
                                &lane_sequence_idx_to_remove)) {
    AERROR << "Failed to extract static environmental features around obs_id = "
           << id;
  }
  std::vector<torch::Tensor> lane_encoding_list;
  for (const auto& single_lane_feature_values : lane_feature_values) {
    if (single_lane_feature_values.size() !=
        SINGLE_LANE_FEATURE_SIZE *
            (LANE_POINTS_SIZE + BACKWARD_LANE_POINTS_SIZE)) {
      AERROR << "Obstacle [" << id << "] has incorrect lane feature size.";
      return false;
    }
    std::vector<torch::jit::IValue> single_lane_encoding_inputs;
    torch::Tensor single_lane_encoding_inputs_tensor =
        torch::zeros({1, SINGLE_LANE_FEATURE_SIZE * LANE_POINTS_SIZE});
    for (size_t i = 0; i < SINGLE_LANE_FEATURE_SIZE * LANE_POINTS_SIZE; ++i) {
      single_lane_encoding_inputs_tensor[0][i] = static_cast<float>(
          single_lane_feature_values[i + SINGLE_LANE_FEATURE_SIZE *
                                             BACKWARD_LANE_POINTS_SIZE]);
    }
    single_lane_encoding_inputs.push_back(
        std::move(single_lane_encoding_inputs_tensor));
    torch::Tensor single_lane_encoding =
        torch_lane_encoding_.forward(single_lane_encoding_inputs)
            .toTensor()
            .to(torch::kCPU);
    lane_encoding_list.push_back(std::move(single_lane_encoding));
  }
  // 3. Aggregate the lane features.
  // torch::Tensor aggregated_lane_encoding =
  //     AggregateLaneEncodings(lane_encoding_list);
  // 4. Make prediction.
  std::vector<double> prediction_scores;
  for (size_t i = 0; i < lane_encoding_list.size(); ++i) {
    std::vector<torch::jit::IValue> prediction_layer_inputs;
    torch::Tensor prediction_layer_inputs_tensor = torch::zeros(
        {1, OBSTACLE_ENCODING_SIZE + SINGLE_LANE_ENCODING_SIZE + 1});
    for (size_t j = 0; j < OBSTACLE_ENCODING_SIZE; ++j) {
      prediction_layer_inputs_tensor[0][j] = obstalce_encoding[0][j];
    }
    for (size_t j = 0; j + 1 < SINGLE_LANE_ENCODING_SIZE; ++j) {
      prediction_layer_inputs_tensor[0][OBSTACLE_ENCODING_SIZE + j] =
          lane_encoding_list[i][0][j];
    }
    prediction_layer_inputs_tensor[0][OBSTACLE_ENCODING_SIZE +
                                      SINGLE_LANE_ENCODING_SIZE - 1] =
        static_cast<float>(lane_feature_values[i][SINGLE_LANE_FEATURE_SIZE *
                                                  BACKWARD_LANE_POINTS_SIZE]);
    prediction_layer_inputs_tensor[0][OBSTACLE_ENCODING_SIZE +
                                      SINGLE_LANE_ENCODING_SIZE] = 0.0;
    // for (size_t j = 0; j < AGGREGATED_ENCODING_SIZE; ++j) {
    //   prediction_layer_inputs_tensor[0][OBSTACLE_ENCODING_SIZE +
    //                                     SINGLE_LANE_ENCODING_SIZE + j] =
    //       aggregated_lane_encoding[0][j];
    // }
    prediction_layer_inputs.push_back(
        std::move(prediction_layer_inputs_tensor));
    torch::Tensor prediction_layer_output =
        torch_prediction_layer_.forward(prediction_layer_inputs)
            .toTensor()
            .to(torch::kCPU);
    auto prediction_score = prediction_layer_output.accessor<float, 2>();
    prediction_scores.push_back(static_cast<double>(prediction_score[0][0]));
  }
 
  // Pass the predicted result to the predictor to plot trajectory.
  std::vector<double> output_probabilities = StableSoftmax(prediction_scores);
  for (int i = 0; i < lane_graph_ptr->lane_sequence_size(); ++i) {
    lane_graph_ptr->mutable_lane_sequence(i)->set_probability(
        output_probabilities[i]);
    ADEBUG << output_probabilities[i];
  }
 
  *(latest_feature_ptr->mutable_lane()->mutable_lane_graph()) = *lane_graph_ptr;
  return true;
}

GetName()

std::string apollo::prediction::LaneAggregatingEvaluator::GetName ( )

inlineoverridevirtual

Get the name of evaluator.

实现了 apollo::prediction::Evaluator.

在文件 lane_aggregating_evaluator.h 第 63 行定义.

{ return "LANE_AGGREGATING_EVALUATOR"; }

---

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

• modules/prediction/evaluator/vehicle/lane_aggregating_evaluator.h
• modules/prediction/evaluator/vehicle/lane_aggregating_evaluator.cc