#include <junction_mlp_evaluator.h>

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

apollo::prediction::JunctionMLPEvaluator 的协作图:

Public 成员函数
	JunctionMLPEvaluator ()
	Constructor

virtual	~JunctionMLPEvaluator ()=default
	Destructor

void	Clear ()
	Clear obstacle feature map

bool	Evaluate (Obstacle obstacle_ptr, ObstaclesContainer obstacles_container) override
	Override Evaluate

void	ExtractFeatureValues (Obstacle obstacle_ptr, ObstaclesContainer obstacles_container, std::vector< double > *feature_values)
	Extract feature vector

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_

详细描述

在文件 junction_mlp_evaluator.h 第 31 行定义.

构造及析构函数说明

◆ JunctionMLPEvaluator()

apollo::prediction::JunctionMLPEvaluator::JunctionMLPEvaluator ( )

Constructor

在文件 junction_mlp_evaluator.cc 第 58 行定义.

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

◆ ~JunctionMLPEvaluator()

virtual apollo::prediction::JunctionMLPEvaluator::~JunctionMLPEvaluator ( )

virtualdefault

Destructor

成员函数说明

◆ Clear()

void apollo::prediction::JunctionMLPEvaluator::Clear ( )

Clear obstacle feature map

在文件 junction_mlp_evaluator.cc 第 63 行定义.

63{}

◆ Evaluate()

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

overridevirtual

Override Evaluate

参数

Obstacle	pointer
Obstacles	container

实现了 apollo::prediction::Evaluator.

在文件 junction_mlp_evaluator.cc 第 65 行定义.

                                                                             {
  // Sanity checks.
  omp_set_num_threads(1);
  Clear();
  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);
 
  // Assume obstacle is NOT closed to any junction exit
  if (!latest_feature_ptr->has_junction_feature() ||
      latest_feature_ptr->junction_feature().junction_exit_size() < 1) {
    ADEBUG << "Obstacle [" << id << "] has no junction_exit.";
    return false;
  }
 
  std::vector<double> feature_values;
  ExtractFeatureValues(obstacle_ptr, obstacles_container, &feature_values);
 
  // Insert features to DataForLearning
  if (FLAGS_prediction_offline_mode ==
      PredictionConstants::kDumpDataForLearning) {
    FeatureOutput::InsertDataForLearning(*latest_feature_ptr, feature_values,
                                         "junction", nullptr);
    ADEBUG << "Save extracted features for learning locally.";
    return true;  // Skip Compute probability for offline mode
  }
  std::vector<torch::jit::IValue> torch_inputs;
  int input_dim = static_cast<int>(
      OBSTACLE_FEATURE_SIZE + EGO_VEHICLE_FEATURE_SIZE + JUNCTION_FEATURE_SIZE);
  torch::Tensor torch_input = torch::zeros({1, input_dim});
  for (size_t i = 0; i < feature_values.size(); ++i) {
    torch_input[0][i] = static_cast<float>(feature_values[i]);
  }
  torch_inputs.push_back(std::move(torch_input.to(device_)));
  std::vector<double> probability;
  if (latest_feature_ptr->junction_feature().junction_exit_size() > 1) {
    at::Tensor torch_output_tensor =
        torch_model_.forward(torch_inputs).toTensor().to(torch::kCPU);
    auto torch_output = torch_output_tensor.accessor<float, 2>();
    for (int i = 0; i < torch_output.size(1); ++i) {
      probability.push_back(static_cast<double>(torch_output[0][i]));
    }
  } else {
    for (int i = 0; i < 12; ++i) {
      probability.push_back(feature_values[OBSTACLE_FEATURE_SIZE +
                                           EGO_VEHICLE_FEATURE_SIZE + 8 * i]);
    }
  }
  for (double prob : probability) {
    latest_feature_ptr->mutable_junction_feature()
        ->add_junction_mlp_probability(prob);
  }
  // assign all lane_sequence probability
  LaneGraph* lane_graph_ptr =
      latest_feature_ptr->mutable_lane()->mutable_lane_graph();
  CHECK_NOTNULL(lane_graph_ptr);
  if (lane_graph_ptr->lane_sequence().empty()) {
    AERROR << "Obstacle [" << id << "] has no lane sequences.";
    return false;
  }
 
  std::unordered_map<std::string, double> junction_exit_prob;
  for (const JunctionExit& junction_exit :
       latest_feature_ptr->junction_feature().junction_exit()) {
    double x =
        junction_exit.exit_position().x() - latest_feature_ptr->position().x();
    double y =
        junction_exit.exit_position().y() - latest_feature_ptr->position().y();
    double angle =
        std::atan2(y, x) - std::atan2(latest_feature_ptr->raw_velocity().y(),
                                      latest_feature_ptr->raw_velocity().x());
    double d_idx = (angle / (2.0 * M_PI) + 1.0 / 24.0) * 12.0;
    int idx = static_cast<int>(floor(d_idx >= 0 ? d_idx : d_idx + 12));
    junction_exit_prob[junction_exit.exit_lane_id()] = probability[idx];
  }
 
  for (int i = 0; i < lane_graph_ptr->lane_sequence_size(); ++i) {
    LaneSequence* lane_sequence_ptr = lane_graph_ptr->mutable_lane_sequence(i);
    CHECK_NOTNULL(lane_sequence_ptr);
    for (const LaneSegment& lane_segment : lane_sequence_ptr->lane_segment()) {
      if (junction_exit_prob.find(lane_segment.lane_id()) !=
          junction_exit_prob.end()) {
        lane_sequence_ptr->set_probability(
            junction_exit_prob[lane_segment.lane_id()]);
      }
    }
  }
  return true;
}

◆ ExtractFeatureValues()

void apollo::prediction::JunctionMLPEvaluator::ExtractFeatureValues	(	Obstacle *	obstacle_ptr,
		ObstaclesContainer *	obstacles_container,
		std::vector< double > *	feature_values
	)

Extract feature vector

参数

Obstacle	pointer
Obstacles	container
Feature	container in a vector for receiving the feature values

在文件 junction_mlp_evaluator.cc 第 164 行定义.

                                       {
  CHECK_NOTNULL(obstacle_ptr);
  int id = obstacle_ptr->id();
 
  std::vector<double> obstacle_feature_values;
  SetObstacleFeatureValues(obstacle_ptr, &obstacle_feature_values);
 
  if (obstacle_feature_values.size() != OBSTACLE_FEATURE_SIZE) {
    AERROR << "Obstacle [" << id << "] has fewer than "
           << "expected obstacle feature_values "
           << obstacle_feature_values.size() << ".";
    return;
  }
 
  std::vector<double> ego_vehicle_feature_values;
  SetEgoVehicleFeatureValues(obstacle_ptr, obstacles_container,
                             &ego_vehicle_feature_values);
  if (ego_vehicle_feature_values.size() != EGO_VEHICLE_FEATURE_SIZE) {
    AERROR << "Obstacle [" << id << "] has fewer than "
           << "expected ego vehicle feature_values"
           << ego_vehicle_feature_values.size() << ".";
    return;
  }
 
  std::vector<double> junction_feature_values;
  SetJunctionFeatureValues(obstacle_ptr, &junction_feature_values);
  if (junction_feature_values.size() != JUNCTION_FEATURE_SIZE) {
    AERROR << "Obstacle [" << id << "] has fewer than "
           << "expected junction feature_values"
           << junction_feature_values.size() << ".";
    return;
  }
 
  feature_values->insert(feature_values->end(), obstacle_feature_values.begin(),
                         obstacle_feature_values.end());
  feature_values->insert(feature_values->end(),
                         ego_vehicle_feature_values.begin(),
                         ego_vehicle_feature_values.end());
  feature_values->insert(feature_values->end(), junction_feature_values.begin(),
                         junction_feature_values.end());
}

◆ GetName()

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

inlineoverridevirtual

Get the name of evaluator.

实现了 apollo::prediction::Evaluator.

在文件 junction_mlp_evaluator.h 第 69 行定义.

69{ return "JUNCTION_MLP_EVALUATOR"; }

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

modules/prediction/evaluator/vehicle/junction_mlp_evaluator.h
modules/prediction/evaluator/vehicle/junction_mlp_evaluator.cc

Public 成员函数

额外继承的成员函数