无人驾驶技术——RMSE

ゞ浴缸里的玫瑰 2024-04-17 22:48 79阅读 0赞

传感器融合流程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70]

# 均方根误差 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70 1]  
均方根误差，可测量估算状态和真实状态之间的偏差。

#include <iostream>
    #include <vector>
    #include "Dense"
    
    using Eigen::MatrixXd;
    using Eigen::VectorXd;
    using std::cout;
    using std::endl;
    using std::vector;
    
    VectorXd CalculateRMSE(const vector<VectorXd> &estimations,
        const vector<VectorXd> &ground_truth);
    
    int main() {
      /**
       * Compute RMSE
       */
      vector<VectorXd> estimations;
      vector<VectorXd> ground_truth;
    
      // the input list of estimations
      VectorXd e(4);
      e << 1, 1, 0.2, 0.1;
      estimations.push_back(e);
      e << 2, 2, 0.3, 0.2;
      estimations.push_back(e);
      e << 3, 3, 0.4, 0.3;
      estimations.push_back(e);
    
      // the corresponding list of ground truth values
      VectorXd g(4);
      g << 1.1, 1.1, 0.3, 0.2;
      ground_truth.push_back(g);
      g << 2.1, 2.1, 0.4, 0.3;
      ground_truth.push_back(g);
      g << 3.1, 3.1, 0.5, 0.4;
      ground_truth.push_back(g);
    
      // call the CalculateRMSE and print out the result
      cout << CalculateRMSE(estimations, ground_truth) << endl;
    
      return 0;
    }
    
    VectorXd CalculateRMSE(const vector<VectorXd> &estimations,
        const vector<VectorXd> &ground_truth) {
    
      VectorXd rmse(4);
      rmse << 0,0,0,0;
    
      // TODO: YOUR CODE HERE
      // check the validity of the following inputs:
      //  * the estimation vector size should not be zero
      //  * the estimation vector size should equal ground truth vector size
    
     if (estimations.size() != ground_truth.size()
          || estimations.size() == 0) {
        cout << "Invalid estimation or ground_truth data" << endl;
        return rmse;
      }
    
      // accumulate squared residuals
      for (unsigned int i=0; i < estimations.size(); ++i) {
    
        VectorXd residual = estimations[i] - ground_truth[i];
    
        // coefficient-wise multiplication
        residual = residual.array()*residual.array();
        rmse += residual;
      }
    
      // calculate the mean
      rmse = rmse/estimations.size();
    
      // calculate the squared root
      rmse = rmse.array().sqrt();
      // return the result
      return rmse;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/c9cbc6dd8c4d42bf8a8d3a7a49303cd6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9fbHhs_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b2def43b03ac46169f111d2a5c0ba15a.png