#include <cruise_mlp_evaluator.h>

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

apollo::prediction::CruiseMLPEvaluator 的协作图:

Public 成员函数
	CruiseMLPEvaluator ()
	Constructor

virtual	~CruiseMLPEvaluator ()=default
	Destructor

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

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

std::string	GetName () override
	Get the name of evaluator.

void	Clear ()

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_

详细描述

在文件 cruise_mlp_evaluator.h 第 32 行定义.

构造及析构函数说明

◆ CruiseMLPEvaluator()

apollo::prediction::CruiseMLPEvaluator::CruiseMLPEvaluator ( )

Constructor

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

                                       : device_(torch::kCPU) {
  evaluator_type_ = ObstacleConf::CRUISE_MLP_EVALUATOR;
  LoadModels();
}

◆ ~CruiseMLPEvaluator()

virtual apollo::prediction::CruiseMLPEvaluator::~CruiseMLPEvaluator ( )

virtualdefault

Destructor

成员函数说明

◆ Clear()

void apollo::prediction::CruiseMLPEvaluator::Clear ( )

在文件 cruise_mlp_evaluator.cc 第 52 行定义.

52{}

◆ Evaluate()

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

overridevirtual

Override Evaluate

参数

Obstacle	pointer
Obstacles	container

实现了 apollo::prediction::Evaluator.

在文件 cruise_mlp_evaluator.cc 第 54 行定义.

                                                                           {
  // 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);
  if (!latest_feature_ptr->has_lane() ||
      !latest_feature_ptr->lane().has_lane_graph()) {
    ADEBUG << "Obstacle [" << id << "] has no lane graph.";
    return false;
  }
  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;
  }
 
  ADEBUG << "There are " << lane_graph_ptr->lane_sequence_size()
         << " lane sequences with probabilities:";
  // For every possible lane sequence, extract features that are needed
  // to feed into our trained model.
  // Then compute the likelihood of the obstacle moving onto that laneseq.
  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);
    std::vector<double> feature_values;
    ExtractFeatureValues(obstacle_ptr, lane_sequence_ptr, &feature_values);
    if (feature_values.size() !=
        OBSTACLE_FEATURE_SIZE + SINGLE_LANE_FEATURE_SIZE * LANE_POINTS_SIZE) {
      lane_sequence_ptr->set_probability(0.0);
      ADEBUG << "Skip lane sequence due to incorrect feature size";
      continue;
    }
 
    // Insert features to DataForLearning
    if (FLAGS_prediction_offline_mode ==
        PredictionConstants::kDumpDataForLearning) {
      std::vector<double> interaction_feature_values;
      SetInteractionFeatureValues(obstacle_ptr, obstacles_container,
                                  lane_sequence_ptr,
                                  &interaction_feature_values);
      if (interaction_feature_values.size() != INTERACTION_FEATURE_SIZE) {
        ADEBUG << "Obstacle [" << id << "] has fewer than "
               << "expected lane feature_values"
               << interaction_feature_values.size() << ".";
        return false;
      }
      ADEBUG << "Interaction feature size = "
             << interaction_feature_values.size();
      feature_values.insert(feature_values.end(),
                            interaction_feature_values.begin(),
                            interaction_feature_values.end());
      FeatureOutput::InsertDataForLearning(*latest_feature_ptr, feature_values,
                                           "lane_scanning", lane_sequence_ptr);
      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 + SINGLE_LANE_FEATURE_SIZE * LANE_POINTS_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_)));
    if (lane_sequence_ptr->vehicle_on_lane()) {
      ModelInference(torch_inputs, torch_go_model_, lane_sequence_ptr);
    } else {
      ModelInference(torch_inputs, torch_cutin_model_, lane_sequence_ptr);
    }
  }
  return true;
}

◆ ExtractFeatureValues()

void apollo::prediction::CruiseMLPEvaluator::ExtractFeatureValues	(	Obstacle *	obstacle_ptr,
		LaneSequence *	lane_sequence_ptr,
		std::vector< double > *	feature_values
	)

Extract feature vector

参数

Obstacle pointer Lane Sequence pointer

在文件 cruise_mlp_evaluator.cc 第 141 行定义.

                                       {
  // Sanity checks.
  CHECK_NOTNULL(obstacle_ptr);
  CHECK_NOTNULL(lane_sequence_ptr);
  int id = obstacle_ptr->id();
 
  // Extract obstacle related features.
  std::vector<double> obstacle_feature_values;
  SetObstacleFeatureValues(obstacle_ptr, &obstacle_feature_values);
  if (obstacle_feature_values.size() != OBSTACLE_FEATURE_SIZE) {
    ADEBUG << "Obstacle [" << id << "] has fewer than "
           << "expected obstacle feature_values "
           << obstacle_feature_values.size() << ".";
    return;
  }
  ADEBUG << "Obstacle feature size = " << obstacle_feature_values.size();
  feature_values->insert(feature_values->end(), obstacle_feature_values.begin(),
                         obstacle_feature_values.end());
 
  // Extract lane related features.
  std::vector<double> lane_feature_values;
  SetLaneFeatureValues(obstacle_ptr, lane_sequence_ptr, &lane_feature_values);
  if (lane_feature_values.size() !=
      SINGLE_LANE_FEATURE_SIZE * LANE_POINTS_SIZE) {
    ADEBUG << "Obstacle [" << id << "] has fewer than "
           << "expected lane feature_values" << lane_feature_values.size()
           << ".";
    return;
  }
  ADEBUG << "Lane feature size = " << lane_feature_values.size();
  feature_values->insert(feature_values->end(), lane_feature_values.begin(),
                         lane_feature_values.end());
}

◆ GetName()

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

inlineoverridevirtual

Get the name of evaluator.

实现了 apollo::prediction::Evaluator.

在文件 cruise_mlp_evaluator.h 第 64 行定义.

64{ return "CRUISE_MLP_EVALUATOR"; }

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

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

Public 成员函数

额外继承的成员函数