目标检测特殊层：SSD目标检测之MultiBox代码解读

最新推荐文章于 2019-06-19 16:43:51 发布
最新推荐文章于 2019-06-19 16:43:51 发布
阅读量581 收藏
点赞数
分类专栏： caffe
这篇博客主要写multibox_loss_layer，multibox_loss_layer也是SSD比较关键内容，主要包括内建了两个layer进行loss回归，还包括比如FindMatches，MineHardExamples，EncodeLocPrediction && EncodeConfPrediction等都是比较重要的函数（其中有一部分在bbox_util中，后面会介绍） 

代码：


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <algorithm>
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <map>
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <utility>
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include <vector>
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include “caffe/layers/multibox_loss_layer.hpp”
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #include “caffe/util/math_functions.hpp”
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       namespace caffe {
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       // layer setup，在这个函数里面还分别新建了两个layer用于loc回归和conf loss的计算
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template <
       
       typename Dtype>
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       void MultiBoxLossLayer<Dtype>::LayerSetUp(
       
       const 
       
       vector<Blob<Dtype>*>& bottom,
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       const 
       
       vector<Blob<Dtype>*>& top) {
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         LossLayer<Dtype>::LayerSetUp(bottom, top);
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (
       
       this->layer_param_.propagate_down_size() == 
       
       0) {
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       this->layer_param_.add_propagate_down(
       
       true);  
       
       // 定位
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       this->layer_param_.add_propagate_down(
       
       true);  
       
       // 分类得分
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       this->layer_param_.add_propagate_down(
       
       false); 
       
       // prior
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       this->layer_param_.add_propagate_down(
       
       false); 
       
       // ground truth
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       const MultiBoxLossParameter& multibox_loss_param =
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       this->layer_param_.multibox_loss_param();
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         multibox_loss_param_ = 
       
       this->layer_param_.multibox_loss_param();  
       
       // 这句话多余吧？
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_ = bottom[
       
       0]->num();  
       
       // batch size
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_priors_ = bottom[
       
       2]->height() / 
       
       4; 
       
       // 先验的个数，每个先验包含左上角和右下角的点坐标
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Get other parameters.
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         CHECK(multibox_loss_param.has_num_classes()) << 
       
       “Must provide num_classes.”; 
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_classes_ = multibox_loss_param.num_classes();    
       
       // 类别个数
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         CHECK_GE(num_classes_, 
       
       1) << 
       
       “num_classes should not be less than 1.”;
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         share_location_ = multibox_loss_param.share_location();  
       
       // 共享类别位置预测 default = true
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_classes_ = share_location_ ? 
       
       1 : num_classes_; 
       
       // 如果shared表示所有的类别同用一个location prediction，否则每一类各自预测。还不是很懂这样做的原因
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         background_label_id_ = multibox_loss_param.background_label_id(); 
       
       // background的id
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         use_difficult_gt_ = multibox_loss_param.use_difficult_gt();  
       
       // 是否使用difficutlt的ground truth，这个具体是什么还有待考虑
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         mining_type_ = multibox_loss_param.mining_type();  
       
       // 这里跟老版SSD代码有些许不同
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (multibox_loss_param.has_do_neg_mining()) {
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LOG(WARNING) << 
       
       “do_neg_mining is deprecated, use mining_type instead.”;
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           do_neg_mining_ = multibox_loss_param.do_neg_mining();  
       
       // 难例挖掘 true
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           CHECK_EQ(do_neg_mining_,
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                    mining_type_ != MultiBoxLossParameter_MiningType_NONE);  
       
       // MultiBoxLossParameter_MiningType_NONE变量？还不清楚具体的用法
      
      
    
     
     
  42. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  43. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         do_neg_mining_ = mining_type_ != MultiBoxLossParameter_MiningType_NONE;
      
      
    
     
     
  44. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  45. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (!
       
       this->layer_param_.loss_param().has_normalization() &&  
       
       // loss normalization,出自LossParameter，默认VALID
      
      
    
     
     
  46. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       this->layer_param_.loss_param().has_normalize()) {
      
      
    
     
     
  47. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           normalization_ = 
       
       this->layer_param_.loss_param().normalize() ?
      
      
    
     
     
  48. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                            LossParameter_NormalizationMode_VALID :
      
      
    
     
     
  49. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                            LossParameter_NormalizationMode_BATCH_SIZE;
      
      
    
     
     
  50. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else {
      
      
    
     
     
  51. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           normalization_ = 
       
       this->layer_param_.loss_param().normalization();
      
      
    
     
     
  52. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  53. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  54. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (do_neg_mining_) {
      
      
    
     
     
  55. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           CHECK(share_location_)
      
      
    
     
     
  56. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               << 
       
       “Currently only support negative mining if share_location is true.”;
      
      
    
     
     
  57. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  58. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  59. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       vector<
       
       int> loss_shape(
       
       1, 
       
       1);
      
      
    
     
     
  60. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Set up localization loss layer.  // 定位loss
      
      
    
     
     
  61. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_weight_ = multibox_loss_param.loc_weight();   
       
       // loc weight 1.0
      
      
    
     
     
  62. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_loss_type_ = multibox_loss_param.loc_loss_type();  
       
       // loss 类型  SMOOTH_L1
      
      
    
     
     
  63. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // fake shape.
      
      
    
     
     
  64. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       vector<
       
       int> loc_shape(
       
       1, 
       
       1);  
       
       // 1维
      
      
    
     
     
  65. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_shape.push_back(
       
       4);       
       
       // 1,4
      
      
    
     
     
  66. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_pred_.Reshape(loc_shape); 
       
       // 1*2  [1,4]
      
      
    
     
     
  67. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_gt_.Reshape(loc_shape);   
       
       // [1,4]
      
      
    
     
     
  68. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_bottom_vec_.push_back(&loc_pred_); 
       
       // 存放前面的指针
      
      
    
     
     
  69. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_bottom_vec_.push_back(&loc_gt_);   
       
       // 存放gt的指针
      
      
    
     
     
  70. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_loss_.Reshape(loss_shape);         
       
       // location的loss [1,4]
      
      
    
     
     
  71. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         loc_top_vec_.push_back(&loc_loss_);    
       
       // 存放top的指针
      
      
    
     
     
  72. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (loc_loss_type_ == MultiBoxLossParameter_LocLossType_L2) {   
       
       // 新建一个层，实现对locationloss的计算
      
      
    
     
     
  73. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LayerParameter layer_param;
      
      
    
     
     
  74. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_name(
       
       this->layer_param_.name() + 
       
       “_l2_loc”);  
      
      
    
     
     
  75. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_type(
       
       “EuclideanLoss”);
      
      
    
     
     
  76. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.add_loss_weight(loc_weight_);
      
      
    
     
     
  77. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_layer_ = LayerRegistry<Dtype>::CreateLayer(layer_param);
      
      
    
     
     
  78. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_layer_->SetUp(loc_bottom_vec_, loc_top_vec_);
      
      
    
     
     
  79. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else 
       
       if (loc_loss_type_ == MultiBoxLossParameter_LocLossType_SMOOTH_L1) {  
       
       // SMOOTH_L1,SSD是选这个
      
      
    
     
     
  80. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LayerParameter layer_param;
      
      
    
     
     
  81. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_name(
       
       this->layer_param_.name() + 
       
       “_smooth_L1_loc”); 
       
       // mbox_loss_smooth_L1_loc
      
      
    
     
     
  82. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_type(
       
       “SmoothL1Loss”);
      
      
    
     
     
  83. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.add_loss_weight(loc_weight_);  
       
       // 1.0
      
      
    
     
     
  84. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_layer_ = LayerRegistry<Dtype>::CreateLayer(layer_param);  
       
       // 创建layer
      
      
    
     
     
  85. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_layer_->SetUp(loc_bottom_vec_, loc_top_vec_); 
       
       //送入推断和gt，输出loc_loss，有一点不太清楚loc_bottom_vec_是两个地址，后面怎么弄？
      
      
    
     
     
  86. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else {
      
      
    
     
     
  87. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LOG(FATAL) << 
       
       “Unknown localization loss type.”;
      
      
    
     
     
  88. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  89. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Set up confidence loss layer. 
      
      
    
     
     
  90. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // 新建一个层，实现的是对confidence loss的计算
      
      
    
     
     
  91. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         conf_loss_type_ = multibox_loss_param.conf_loss_type();  
       
       // SOFTMAX
      
      
    
     
     
  92. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         conf_bottom_vec_.push_back(&conf_pred_);  
       
       // conf_pred_ 是blob
      
      
    
     
     
  93. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         conf_bottom_vec_.push_back(&conf_gt_);    
       
       // conf_gt_ 是blob
      
      
    
     
     
  94. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         conf_loss_.Reshape(loss_shape);           
       
       // [1,4]
      
      
    
     
     
  95. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         conf_top_vec_.push_back(&conf_loss_);     
       
       // 也是一维向量
      
      
    
     
     
  96. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (conf_loss_type_ == MultiBoxLossParameter_ConfLossType_SOFTMAX) {
      
      
    
     
     
  97. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           CHECK_GE(background_label_id_, 
       
       0)
      
      
    
     
     
  98. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               << 
       
       “background_label_id should be within [0, num_classes) for Softmax.”;
      
      
    
     
     
  99. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           CHECK_LT(background_label_id_, num_classes_)
      
      
    
     
     
  100. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               << 
       
       “background_label_id should be within [0, num_classes) for Softmax.”;
      
      
    
     
     
  101. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LayerParameter layer_param;
      
      
    
     
     
  102. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_name(
       
       this->layer_param_.name() + 
       
       “_softmax_conf”);  
       
       // mbox_loss_softmax_conf
      
      
    
     
     
  103. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_type(
       
       “SoftmaxWithLoss”);
      
      
    
     
     
  104. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.add_loss_weight(Dtype(
       
       1.));                             
       
       // 1.0
      
      
    
     
     
  105. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.mutable_loss_param()->set_normalization(
      
      
    
     
     
  106. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               LossParameter_NormalizationMode_NONE);  
      
      
    
     
     
  107. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           SoftmaxParameter* softmax_param = layer_param.mutable_softmax_param();
      
      
    
     
     
  108. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           softmax_param->set_axis(
       
       1);
      
      
    
     
     
  109. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       // Fake reshape.
      
      
    
     
     
  110. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       vector<
       
       int> conf_shape(
       
       1, 
       
       1);
      
      
    
     
     
  111. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_gt_.Reshape(conf_shape);        
       
       // [1]
      
      
    
     
     
  112. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_shape.push_back(num_classes_);  
       
       // 这两个参数没有用到
      
      
    
     
     
  113. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_pred_.Reshape(conf_shape);
      
      
    
     
     
  114. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_layer_ = LayerRegistry<Dtype>::CreateLayer(layer_param);
      
      
    
     
     
  115. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_layer_->SetUp(conf_bottom_vec_, conf_top_vec_);
      
      
    
     
     
  116. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else 
       
       if (conf_loss_type_ == MultiBoxLossParameter_ConfLossType_LOGISTIC) {
      
      
    
     
     
  117. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LayerParameter layer_param;
      
      
    
     
     
  118. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_name(
       
       this->layer_param_.name() + 
       
       “_logistic_conf”);
      
      
    
     
     
  119. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.set_type(
       
       “SigmoidCrossEntropyLoss”);
      
      
    
     
     
  120. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           layer_param.add_loss_weight(Dtype(
       
       1.));
      
      
    
     
     
  121. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       // Fake reshape.
      
      
    
     
     
  122. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       vector<
       
       int> conf_shape(
       
       1, 
       
       1);
      
      
    
     
     
  123. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_shape.push_back(num_classes_);
      
      
    
     
     
  124. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_gt_.Reshape(conf_shape);
      
      
    
     
     
  125. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_pred_.Reshape(conf_shape);
      
      
    
     
     
  126. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_layer_ = LayerRegistry<Dtype>::CreateLayer(layer_param);
      
      
    
     
     
  127. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_layer_->SetUp(conf_bottom_vec_, conf_top_vec_);
      
      
    
     
     
  128. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else {
      
      
    
     
     
  129. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LOG(FATAL) << 
       
       “Unknown confidence loss type.”;
      
      
    
     
     
  130. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  131. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }  
       
       // layer setup 结束
      
      
    
     
     
  132. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  133. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template <
       
       typename Dtype>
      
      
    
     
     
  134. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       void MultiBoxLossLayer<Dtype>::Reshape(
       
       const 
       
       vector<Blob<Dtype>*>& bottom,
      
      
    
     
     
  135. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       const 
       
       vector<Blob<Dtype>*>& top) {
      
      
    
     
     
  136. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         LossLayer<Dtype>::Reshape(bottom, top);
      
      
    
     
     
  137. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_ = bottom[
       
       0]->num();                   
       
       // batch num
      
      
    
     
     
  138. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_priors_ = bottom[
       
       2]->height() / 
       
       4;     
       
       // 这里的blob维度还需要再仔细分析下
      
      
    
     
     
  139. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_gt_ = bottom[
       
       3]->height();
      
      
    
     
     
  140. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         CHECK_EQ(bottom[
       
       0]->num(), bottom[
       
       1]->num());
      
      
    
     
     
  141. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         CHECK_EQ(num_priors_ * loc_classes_ * 
       
       4, bottom[
       
       0]->channels())  
       
       // loc_classes_共享是1，不共享就是classes数
      
      
    
     
     
  142. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             << 
       
       “Number of priors must match number of location predictions.”;
      
      
    
     
     
  143. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         CHECK_EQ(num_priors_ * num_classes_, bottom[
       
       1]->channels())
      
      
    
     
     
  144. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             << 
       
       “Number of priors must match number of confidence predictions.”;
      
      
    
     
     
  145. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  146. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  147. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       // 预测loction bottom[0] dimension is [N*C*1*1],confidence bottom[1] dimension is [N*C*1*1]
      
      
    
     
     
  148. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       // priors bottom[2] dimension is [N*1*2*W], gound truth bottom[3] dimension is [N*1*H*8]
      
      
    
     
     
  149. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template <
       
       typename Dtype>
      
      
    
     
     
  150. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       void MultiBoxLossLayer<Dtype>::Forward_cpu(
       
       const 
       
       vector<Blob<Dtype>*>& bottom,
      
      
    
     
     
  151. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       const 
       
       vector<Blob<Dtype>*>& top) {
      
      
    
     
     
  152. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       const Dtype* loc_data = bottom[
       
       0]->cpu_data();
      
      
    
     
     
  153. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       const Dtype* conf_data = bottom[
       
       1]->cpu_data();
      
      
    
     
     
  154. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       const Dtype* prior_data = bottom[
       
       2]->cpu_data();
      
      
    
     
     
  155. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       const Dtype* gt_data = bottom[
       
       3]->cpu_data();
      
      
    
     
     
  156. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Retrieve all ground truth.
      
      
    
     
     
  157. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       /*
      
      
    
     
     
  158. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         message NormalizedBBox {
      
      
    
     
     
  159. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional float xmin = 1;
      
      
    
     
     
  160. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional float ymin = 2;
      
      
    
     
     
  161. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional float xmax = 3;
      
      
    
     
     
  162. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional float ymax = 4;
      
      
    
     
     
  163. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional int32 label = 5;
      
      
    
     
     
  164. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional bool difficult = 6;
      
      
    
     
     
  165. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional float score = 7;
      
      
    
     
     
  166. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         optional float size = 8;
      
      
    
     
     
  167. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  168. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         */
      
      
    
     
     
  169. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Retrieve all ground truth.
      
      
    
     
     
  170. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       map<
       
       int, 
       
       vector<NormalizedBBox> > all_gt_bboxes; 
       
       //转化ground truth bounding box，存放在all_gt_bboxes
      
      
    
     
     
  171. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         GetGroundTruth(gt_data, num_gt_, background_label_id_, use_difficult_gt_,  
       
       // background_label_id_=0,use_difficult_gt_=true
      
      
    
     
     
  172. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                        &all_gt_bboxes);  
      
      
    
     
     
  173. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  174. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Retrieve all prior bboxes. It is same within a batch since we assume all
      
      
    
     
     
  175. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // images in a batch are of same dimension.
      
      
    
     
     
  176. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // 把prior box 存入prior_bboxes，把variances存入prior_variances
      
      
    
     
     
  177. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       vector<NormalizedBBox> prior_bboxes;
      
      
    
     
     
  178. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       vector<
       
       vector<
       
       float> > prior_variances;
      
      
    
     
     
  179. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         GetPriorBBoxes(prior_data, num_priors_, &prior_bboxes, &prior_variances);  
      
      
    
     
     
  180. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  181. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  182. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Retrieve all predictions.
      
      
    
     
     
  183. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       vector<LabelBBox> all_loc_preds;   
       
       // map<int, vector<NormalizedBBox> > LabelBBox;
      
      
    
     
     
  184. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         GetLocPredictions(loc_data, num_, num_priors_, loc_classes_, share_location_,
      
      
    
     
     
  185. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                           &all_loc_preds);  
       
       // 这里是把所有预测的box写入了all_loc_preds，这些box就是bottom[0]，loc_data
      
      
    
     
     
  186. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  187. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Find matches between source bboxes and ground truth bboxes.
      
      
    
     
     
  188. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       vector<
       
       map<
       
       int, 
       
       vector<
       
       float> > > all_match_overlaps;
      
      
    
     
     
  189. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         FindMatches(all_loc_preds, all_gt_bboxes, prior_bboxes, prior_variances,
      
      
    
     
     
  190. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                     multibox_loss_param_, &all_match_overlaps, &all_match_indices_);
      
      
    
     
     
  191. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  192. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         num_matches_ = 
       
       0;
      
      
    
     
     
  193. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       int num_negs = 
       
       0;
      
      
    
     
     
  194. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Sample hard negative (and positive) examples based on mining type.
      
      
    
     
     
  195. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         MineHardExamples(*bottom[
       
       1], all_loc_preds, all_gt_bboxes, prior_bboxes,
      
      
    
     
     
  196. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                          prior_variances, all_match_overlaps, multibox_loss_param_,
      
      
    
     
     
  197. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                          &num_matches_, &num_negs, &all_match_indices_,
      
      
    
     
     
  198. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                          &all_neg_indices_);
      
      
    
     
     
  199. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  200. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (num_matches_ >= 
       
       1) {
      
      
    
     
     
  201. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       // Form data to pass on to loc_loss_layer_.
      
      
    
     
     
  202. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       vector<
       
       int> loc_shape(
       
       2);
      
      
    
     
     
  203. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_shape[
       
       0] = 
       
       1;
      
      
    
     
     
  204. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_shape[
       
       1] = num_matches_ * 
       
       4;
      
      
    
     
     
  205. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_pred_.Reshape(loc_shape);  
       
       // 地址已经存放进了loc_bottom_vec_
      
      
    
     
     
  206. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_gt_.Reshape(loc_shape);    
      
      
    
     
     
  207. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype* loc_pred_data = loc_pred_.mutable_cpu_data();
      
      
    
     
     
  208. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype* loc_gt_data = loc_gt_.mutable_cpu_data();
      
      
    
     
     
  209. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           EncodeLocPrediction(all_loc_preds, all_gt_bboxes, all_match_indices_,
      
      
    
     
     
  210. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                               prior_bboxes, prior_variances, multibox_loss_param_,
      
      
    
     
     
  211. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                               loc_pred_data, loc_gt_data);
      
      
    
     
     
  212. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_layer_->Reshape(loc_bottom_vec_, loc_top_vec_);
      
      
    
     
     
  213. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_layer_->Forward(loc_bottom_vec_, loc_top_vec_);   
       
       // 前向计算
      
      
    
     
     
  214. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else {
      
      
    
     
     
  215. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           loc_loss_.mutable_cpu_data()[
       
       0] = 
       
       0;
      
      
    
     
     
  216. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }   
       
       // 这里完成loc的loss前向计算
      
      
    
     
     
  217. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  218. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Form data to pass on to conf_loss_layer_.
      
      
    
     
     
  219. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (do_neg_mining_) {  
       
       // 计算positive和negative样本
      
      
    
     
     
  220. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           num_conf_ = num_matches_ + num_negs;
      
      
    
     
     
  221. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else {
      
      
    
     
     
  222. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           num_conf_ = num_ * num_priors_;
      
      
    
     
     
  223. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  224. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (num_conf_ >= 
       
       1) {
      
      
    
     
     
  225. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       // Reshape the confidence data.
      
      
    
     
     
  226. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       vector<
       
       int> conf_shape;
      
      
    
     
     
  227. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if (conf_loss_type_ == MultiBoxLossParameter_ConfLossType_SOFTMAX) {  
       
       // 选softmax
      
      
    
     
     
  228. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_shape.push_back(num_conf_);
      
      
    
     
     
  229. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_gt_.Reshape(conf_shape);
      
      
    
     
     
  230. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_shape.push_back(num_classes_);
      
      
    
     
     
  231. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_pred_.Reshape(conf_shape);
      
      
    
     
     
  232. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           } 
       
       else 
       
       if (conf_loss_type_ == MultiBoxLossParameter_ConfLossType_LOGISTIC) {
      
      
    
     
     
  233. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_shape.push_back(
       
       1);
      
      
    
     
     
  234. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_shape.push_back(num_conf_);
      
      
    
     
     
  235. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_shape.push_back(num_classes_);
      
      
    
     
     
  236. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_gt_.Reshape(conf_shape);
      
      
    
     
     
  237. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_pred_.Reshape(conf_shape);
      
      
    
     
     
  238. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           } 
       
       else {
      
      
    
     
     
  239. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             LOG(FATAL) << 
       
       “Unknown confidence loss type.”;
      
      
    
     
     
  240. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  241. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if (!do_neg_mining_) {
      
      
    
     
     
  242. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Consider all scores.
      
      
    
     
     
  243. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Share data and diff with bottom[1].
      
      
    
     
     
  244. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             CHECK_EQ(conf_pred_.count(), bottom[
       
       1]->count());
      
      
    
     
     
  245. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_pred_.ShareData(*(bottom[
       
       1]));
      
      
    
     
     
  246. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  247. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype* conf_pred_data = conf_pred_.mutable_cpu_data();
      
      
    
     
     
  248. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype* conf_gt_data = conf_gt_.mutable_cpu_data();
      
      
    
     
     
  249. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           caffe_set(conf_gt_.count(), Dtype(background_label_id_), conf_gt_data);
      
      
    
     
     
  250. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           EncodeConfPrediction(conf_data, num_, num_priors_, multibox_loss_param_,
      
      
    
     
     
  251. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                all_match_indices_, all_neg_indices_, all_gt_bboxes,
      
      
    
     
     
  252. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                conf_pred_data, conf_gt_data);
      
      
    
     
     
  253. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_layer_->Reshape(conf_bottom_vec_, conf_top_vec_);
      
      
    
     
     
  254. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_layer_->Forward(conf_bottom_vec_, conf_top_vec_);
      
      
    
     
     
  255. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         } 
       
       else {
      
      
    
     
     
  256. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conf_loss_.mutable_cpu_data()[
       
       0] = 
       
       0;
      
      
    
     
     
  257. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }  
       
       // 这里结束conf的loss计算
      
      
    
     
     
  258. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  259. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         top[
       
       0]->mutable_cpu_data()[
       
       0] = 
       
       0;
      
      
    
     
     
  260. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (
       
       this->layer_param_.propagate_down(
       
       0)) {  
       
       // true 正则化一下 loc_loss
      
      
    
     
     
  261. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype normalizer = LossLayer<Dtype>::GetNormalizer(
      
      
    
     
     
  262. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               normalization_, num_, num_priors_, num_matches_);
      
      
    
     
     
  263. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           top[
       
       0]->mutable_cpu_data()[
       
       0] +=
      
      
    
     
     
  264. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               loc_weight_ * loc_loss_.cpu_data()[
       
       0] / normalizer;
      
      
    
     
     
  265. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  266. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (
       
       this->layer_param_.propagate_down(
       
       1)) {  
       
       // true   conf_loss
      
      
    
     
     
  267. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype normalizer = LossLayer<Dtype>::GetNormalizer(
      
      
    
     
     
  268. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               normalization_, num_, num_priors_, num_matches_);
      
      
    
     
     
  269. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           top[
       
       0]->mutable_cpu_data()[
       
       0] += conf_loss_.cpu_data()[
       
       0] / normalizer;
      
      
    
     
     
  270. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  271. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       } 
       
       // 结束Forward计算
      
      
    
     
     
  272. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  273. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       template <
       
       typename Dtype>
      
      
    
     
     
  274. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       void MultiBoxLossLayer<Dtype>::Backward_cpu(
       
       const 
       
       vector<Blob<Dtype>*>& top,
      
      
    
     
     
  275. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       const 
       
       vector<
       
       bool>& propagate_down,
      
      
    
     
     
  276. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       const 
       
       vector<Blob<Dtype>*>& bottom) {
      
      
    
     
     
  277. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  278. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (propagate_down[
       
       2]) {   
      
      
    
     
     
  279. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LOG(FATAL) << 
       
       this->type()
      
      
    
     
     
  280. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               << 
       
       ” Layer cannot backpropagate to prior inputs.”;
      
      
    
     
     
  281. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  282. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (propagate_down[
       
       3]) {
      
      
    
     
     
  283. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           LOG(FATAL) << 
       
       this->type()
      
      
    
     
     
  284. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               << 
       
       ” Layer cannot backpropagate to label inputs.”;
      
      
    
     
     
  285. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  286. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  287. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Back propagate on location prediction.
      
      
    
     
     
  288. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (propagate_down[
       
       0]) {   
       
       // 先回传 loc_loss
      
      
    
     
     
  289. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype* loc_bottom_diff = bottom[
       
       0]->mutable_cpu_diff();
      
      
    
     
     
  290. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           caffe_set(bottom[
       
       0]->count(), Dtype(
       
       0), loc_bottom_diff);
      
      
    
     
     
  291. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if (num_matches_ >= 
       
       1) {
      
      
    
     
     
  292. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       vector<
       
       bool> loc_propagate_down;
      
      
    
     
     
  293. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Only back propagate on prediction, not ground truth.
      
      
    
     
     
  294. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             loc_propagate_down.push_back(
       
       true);
      
      
    
     
     
  295. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             loc_propagate_down.push_back(
       
       false);
      
      
    
     
     
  296. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             loc_loss_layer_->Backward(loc_top_vec_, loc_propagate_down,
      
      
    
     
     
  297. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                       loc_bottom_vec_);
      
      
    
     
     
  298. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Scale gradient.
      
      
    
     
     
  299. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             Dtype normalizer = LossLayer<Dtype>::GetNormalizer(
      
      
    
     
     
  300. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                 normalization_, num_, num_priors_, num_matches_);
      
      
    
     
     
  301. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             Dtype loss_weight = top[
       
       0]->cpu_diff()[
       
       0] / normalizer;
      
      
    
     
     
  302. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             caffe_scal(loc_pred_.count(), loss_weight, loc_pred_.mutable_cpu_diff());
      
      
    
     
     
  303. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Copy gradient back to bottom[0].
      
      
    
     
     
  304. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       const Dtype* loc_pred_diff = loc_pred_.cpu_diff();
      
      
    
     
     
  305. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       int count = 
       
       0;
      
      
    
     
     
  306. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       for (
       
       int i = 
       
       0; i < num_; ++i) {
      
      
    
     
     
  307. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for (
       
       map<
       
       int, 
       
       vector<
       
       int> >::iterator it =
      
      
    
     
     
  308. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                    all_match_indices_[i].begin();
      
      
    
     
     
  309. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                    it != all_match_indices_[i].end(); ++it) {
      
      
    
     
     
  310. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       const 
       
       int label = share_location_ ? 
       
       0 : it->first;
      
      
    
     
     
  311. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       const 
       
       vector<
       
       int>& match_index = it->second;
      
      
    
     
     
  312. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       for (
       
       int j = 
       
       0; j < match_index.size(); ++j) {
      
      
    
     
     
  313. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if (match_index[j] <= 
       
       -1) {
      
      
    
     
     
  314. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                  
       
       continue;
      
      
    
     
     
  315. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   }
      
      
    
     
     
  316. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       // Copy the diff to the right place.
      
      
    
     
     
  317. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       int start_idx = loc_classes_ * 
       
       4 * j + label * 
       
       4;
      
      
    
     
     
  318. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   caffe_copy<Dtype>(
       
       4, loc_pred_diff + count * 
       
       4,
      
      
    
     
     
  319. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                     loc_bottom_diff + start_idx);
      
      
    
     
     
  320. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   ++count;
      
      
    
     
     
  321. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                 }
      
      
    
     
     
  322. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  323. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               loc_bottom_diff += bottom[
       
       0]->offset(
       
       1);
      
      
    
     
     
  324. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             }
      
      
    
     
     
  325. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  326. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  327. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  328. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // Back propagate on confidence prediction.
      
      
    
     
     
  329. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       if (propagate_down[
       
       1]) {
      
      
    
     
     
  330. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           Dtype* conf_bottom_diff = bottom[
       
       1]->mutable_cpu_diff();
      
      
    
     
     
  331. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           caffe_set(bottom[
       
       1]->count(), Dtype(
       
       0), conf_bottom_diff);
      
      
    
     
     
  332. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if (num_conf_ >= 
       
       1) {
      
      
    
     
     
  333. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       vector<
       
       bool> conf_propagate_down;
      
      
    
     
     
  334. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Only back propagate on prediction, not ground truth.
      
      
    
     
     
  335. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_propagate_down.push_back(
       
       true);
      
      
    
     
     
  336. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_propagate_down.push_back(
       
       false);
      
      
    
     
     
  337. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             conf_loss_layer_->Backward(conf_top_vec_, conf_propagate_down,
      
      
    
     
     
  338. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                        conf_bottom_vec_);
      
      
    
     
     
  339. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Scale gradient.
      
      
    
     
     
  340. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             Dtype normalizer = LossLayer<Dtype>::GetNormalizer(
      
      
    
     
     
  341. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                 normalization_, num_, num_priors_, num_matches_);
      
      
    
     
     
  342. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             Dtype loss_weight = top[
       
       0]->cpu_diff()[
       
       0] / normalizer;
      
      
    
     
     
  343. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             caffe_scal(conf_pred_.count(), loss_weight,
      
      
    
     
     
  344. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                        conf_pred_.mutable_cpu_diff());
      
      
    
     
     
  345. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       // Copy gradient back to bottom[1].
      
      
    
     
     
  346. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       const Dtype* conf_pred_diff = conf_pred_.cpu_diff();
      
      
    
     
     
  347. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
          
       
       if (do_neg_mining_) {
      
      
    
     
     
  348. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       int count = 
       
       0;
      
      
    
     
     
  349. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       for (
       
       int i = 
       
       0; i < num_; ++i) {
      
      
    
     
     
  350. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       // Copy matched (positive) bboxes scores’ diff.
      
      
    
     
     
  351. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       const 
       
       map<
       
       int, 
       
       vector<
       
       int> >& match_indices = all_match_indices_[i];
      
      
    
     
     
  352. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       for (
       
       map<
       
       int, 
       
       vector<
       
       int> >::const_iterator it =
      
      
    
     
     
  353. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                      match_indices.begin(); it != match_indices.end(); ++it) {
      
      
    
     
     
  354. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       const 
       
       vector<
       
       int>& match_index = it->second;
      
      
    
     
     
  355. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   CHECK_EQ(match_index.size(), num_priors_);
      
      
    
     
     
  356. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       for (
       
       int j = 
       
       0; j < num_priors_; ++j) {
      
      
    
     
     
  357. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                  
       
       if (match_index[j] <= 
       
       -1) {
      
      
    
     
     
  358. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       continue;
      
      
    
     
     
  359. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                     }
      
      
    
     
     
  360. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                  
       
       // Copy the diff to the right place.
      
      
    
     
     
  361. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                     caffe_copy<Dtype>(num_classes_,
      
      
    
     
     
  362. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                       conf_pred_diff + count * num_classes_,
      
      
    
     
     
  363. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                       conf_bottom_diff + j * num_classes_);
      
      
    
     
     
  364. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                     ++count;
      
      
    
     
     
  365. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   }
      
      
    
     
     
  366. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                 }
      
      
    
     
     
  367. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       // Copy negative bboxes scores’ diff.
      
      
    
     
     
  368. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
              
       
       for (
       
       int n = 
       
       0; n < all_neg_indices_[i].size(); ++n) {
      
      
    
     
     
  369. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       int j = all_neg_indices_[i][n];
      
      
    
     
     
  370. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   CHECK_LT(j, num_priors_);
      
      
    
     
     
  371. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   caffe_copy<Dtype>(num_classes_,
      
      
    
     
     
  372. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                     conf_pred_diff + count * num_classes_,
      
      
    
     
     
  373. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                     conf_bottom_diff + j * num_classes_);
      
      
    
     
     
  374. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   ++count;
      
      
    
     
     
  375. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                 }
      
      
    
     
     
  376. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                 conf_bottom_diff += bottom[
       
       1]->offset(
       
       1);
      
      
    
     
     
  377. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               }
      
      
    
     
     
  378. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             } 
       
       else {
      
      
    
     
     
  379. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       // The diff is already computed and stored.
      
      
    
     
     
  380. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               bottom[
       
       1]->ShareDiff(conf_pred_);
      
      
    
     
     
  381. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
             }
      
      
    
     
     
  382. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           }
      
      
    
     
     
  383. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         }
      
      
    
     
     
  384. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  385. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
      
       
       // After backward, remove match statistics.
      
      
    
     
     
  386. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         all_match_indices_.clear();
      
      
    
     
     
  387. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
         all_neg_indices_.clear();
      
      
    
     
     
  388. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }
      
      
    
     
     
  389. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  390. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       INSTANTIATE_CLASS(MultiBoxLossLayer);
      
      
    
     
     
  391. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       REGISTER_LAYER_CLASS(MultiBoxLoss);
      
      
    
     
     
  392. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  393. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       }  
       
       // namespace caffe
      
      
    
     
     

   
   

            </div>
qq_34132426
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSD: Single Shot MultiBox Detector
Surge
07-10 7414
SSD: Single Shot MultiBox Detector 背景介绍    基于“Proposal + Classification” 的 Object Detection 的方法，R-CNN 系列（R-CNN、SPPnet、Fast R-CNN 以及 Faster R-CNN），取得了非常好的结果，但是在速度方面离实时效果还比较远    在提高 mAP 的同时兼顾速度
SSD：Single Shot MultiBox Detector（四）
FelixFuu的博客
02-08 6053
这都是个人学习SSD所做记录，仅作为个人备忘录 SSD：Single Shot MultiBox Detector（一）： http://blog.csdn.net/u011956147/article/details/73028773 SSD：Single Shot MultiBox Detector（二）： http://blog.csdn.net/u011956147/article/d...
SSD（single shot multibox detector）
dihe3772的博客
03-18 448
SSD，全称Single Shot MultiBox Detector，是Wei Liu在ECCV 2016上提出的一种目标检测算法，截至目前是主要的检测框架之一，相比Faster RCNN有明显的速度优势，相比YOLO又有明显的mAP优势（不过已经被CVPR 2017的YOLO9000超越） 在VOC2007上，SSD300比Faster R-CNN的FPS高了6.6倍 在VO...
目标检测模型-SSD检测模型-Pytorch版本
05-14
SSD（Single Shot MultiBox Detector）是一种流行的目标检测框架，它以其速度快和性能好而闻名。SSD通过单次前向传播即可预测图像中的目标位置和类别。以下是SSD模型的详细介绍： 1. SSD概述 SSD是由Wei Liu等人在...
目标检测模型-SSD512-SSD300-Pytorch版本
05-13
单次检测：SSD的核心特性是它能够在单次前向传播中预测图像中所有目标的边界框和类别。 多尺度预测：SSD通过在不同尺度的特征图上进行检测，能够检测不同大小的目标。 默认框（Default Boxes）：SSD使用了一系列预...
目标检测 pytorch复现SSD目标检测项目项目源码
04-24
SSD（Single Shot MultiBox Detector）是大神Wei Liu在 ECCV 2016上发表的一种的目标检测算法。对于输入图像大小300x300的版本在VOC2007数据集上达到了72.1%mAP的准确率并且检测速度达到了惊人的58FPS（ Faster RCNN...
基于图片的目标目标检测SSD算法
05-15
2. **多尺度预测**：SSD利用不同大小的特征层来检测不同尺寸的物体，解决了小物体检测的难题。 3. **偏移量预测**：除了预测边界框的四个坐标，SSD还预测每个候选框相对于预先定义的默认框的偏移量，使得模型可以...
目标检测代码示例.rar
最新发布
05-22
4. **SSD**：Single Shot MultiBox Detector，通过在不同尺度的特征图上预测边界框和类别，同时完成定位和分类，也是实时目标检测的优秀选择。 5. **Mask R-CNN**：在 Faster R-CNN 的基础上增加了分支用于实例分割...
深度学习SSD(Single Shot MultiBox Detector)
07-10
SSD(Single Shot MultiBox Detector) 深度学习
SSD_Single Shot MultiBox Detector.pdf
09-27
SSD_Single Shot MultiBox Detector 2016.pdf, 目标检测中比较经典的算法，速度快，效果好，而且代码相比faster-rcnn要简单易懂，代码在我的上一个上传资源里
SSD（single shot multibox detector）翻译
03-03
SSD（single shot multibox detector）翻译，含原论文
【目标检测】SSD: Single Shot MultiBox Detector
阿辉的博客
06-19 181
文章目录SSDSSD的模型架构训练实验结论 论文 SSD SSD是在YOLO之后出的一个single stage的检测模型，精度与Faster R-CNN相当，但速度可以达到59FPS。 SSD的模型架构 特征提取 采用VGG-16提取特征，将两个全连接层换成了两个卷积层，并在后面额外增加了4组共计8个卷积层（每一组都是1×1卷积接3×3卷积），这样得到了多个尺度不同的特征图。 anchors生...
论文笔记 | SSD: Single Shot MultiBox Detector
bea_tree的博客
06-21 5163
AuthorsWei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, Alexander C. Berg Wei LiuAbstractOur approach, named SSD, discretizes the output space of bounding box
SSD：Single Shot MultiBox Detector（一）
FelixFuu的博客
02-08 8604
这都是个人学习SSD所做记录，仅作为个人备忘录 SSD：Single Shot MultiBox Detector（一）： http://blog.csdn.net/u011956147/article/details/73028773 SSD：Single Shot MultiBox Detector（二）： http://blog.csdn.net/u011956147/article/d...
SSD（Single Shot MultiBoxDetector）目标检测
思考人生
08-11 2214
借鉴YOLO：直接回归bbox和分类概率； 借鉴Faster R-CNN：使用anchor提升识别准确度; 借鉴FPN：加入金字塔的检测方式； 结合两者优点，提高速度上超过YOLO，精度上与Faster R-CNN媲美； 网络结构 base network 采用VGG19提取卷积特征，在后面添加一系列卷积层，进行多尺度检测，低层特征保留图像的细节信息，用于检测较小的目标，高层...
SSD: Single Shot MultiBox Detector思想精要&技术细节
qiusuoxiaozi的博客
10-31 577
一、理解SSD：这大半个月来一直在捣弄SSD。一篇文章在handle一个task的时候，总是有其隐藏在其背后，独特的处理问题的思想，为了避免过目就忘，决定把SSD的思想提炼总结一下，原则就是简而精：往大了看，SSD其实就是由两个subtask构成的。这两个subtask绝大多数时候是相互独立的，各做各的事，自己优化自己，不存在交叉优化或者joint training，可以说是并不相关的。只有在最后t
SSD: Single Shot MultiBox Detector解读
Sundrops的专栏
11-29 4824
此SSD非彼SSD，不过都有一个特点快，我之前读过了这篇，这次算是重温，而且前面介绍了很多检测网络，尤其是FPN时更是对SSD有一个很根本的解读，所以这篇博客算是一个SSD精华介绍，哈哈。 贡献和特点 SSD最大的贡献，就是在多个feature map上进行预测，这点我在上一篇FPN也说过它的好处，可以适应更多的scale。第二个是用小的卷积进行分类回归，区别于YOLO及其faster
数据集-从零开始学习SSD目标检测算法训练自己的数据集.pdf
02-09
数据集 数据集_从零开始学习SSD目标检测算法训练自己的数据集

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值