Fixed a bug which was introduced a few days ago. The problem was that the

validation routines set the detection threshold to negative infinity in an
attempt to elicit all the possible detections for the purpose of computing mean
average precision scores.  This works fine when using the scan_image_boxes
object but causes the detection quality to degrade when the scan_image_pyramid
is used since this object performs random subsampling to avoid producing an
excessive number of detections.  The fix is to allow the user to set the
adjust_threshold parameter themselves to whatever value they feel is reasonable
rather than hard coding it to negative infinity.

dlib/svm/cross_validate_object_detection_trainer.h

@@ -79,15 +79,6 @@ namespace dlib
             return count;
         }
 
-        inline unsigned long number_of_truth_hits (
-            const std::vector<full_object_detection>& truth_boxes,
-            const std::vector<rectangle>& boxes,
-            const double overlap_eps
-        )
-        {
-            double ap;
-            return number_of_truth_hits(truth_boxes, boxes, overlap_eps, ap);
-        }
     }
 
 // ----------------------------------------------------------------------------------------
@@ -100,7 +91,8 @@ namespace dlib
         object_detector_type& detector,
         const image_array_type& images,
         const std::vector<std::vector<full_object_detection> >& truth_dets,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     )
     {
         // make sure requires clause is not broken
@@ -121,25 +113,12 @@ namespace dlib
 
         for (unsigned long i = 0; i < images.size(); ++i)
         {
-            std::vector<std::pair<double,rectangle> > all_dets;
-            detector(images[i], all_dets, -std::numeric_limits<double>::infinity());
-            std::vector<rectangle> hits;
-            for (unsigned long k = 0; k < all_dets.size(); ++k)
-            {
-                if (all_dets[k].first >= 0)
-                    hits.push_back(all_dets[k].second);
-            }
+            const std::vector<rectangle>& hits = detector(images[i], adjust_threshold);
 
+            double ap;
             total_hits += hits.size();
-            correct_hits += impl::number_of_truth_hits(truth_dets[i], hits, overlap_eps);
+            correct_hits += impl::number_of_truth_hits(truth_dets[i], hits, overlap_eps, ap);
             total_true_targets += truth_dets[i].size();
-
-            // now get the average precision 
-            hits.clear();
-            for (unsigned long k = 0; k < all_dets.size(); ++k)
-                hits.push_back(all_dets[k].second);
-            double ap;
-            impl::number_of_truth_hits(truth_dets[i], hits, overlap_eps, ap);
             map.add(ap);
         }
 
@@ -169,7 +148,8 @@ namespace dlib
         object_detector_type& detector,
         const image_array_type& images,
         const std::vector<std::vector<rectangle> >& truth_dets,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     )
     {
         // convert into a list of regular rectangles.
@@ -182,7 +162,7 @@ namespace dlib
             }
         }
 
-        return test_object_detection_function(detector, images, rects, overlap_eps);
+        return test_object_detection_function(detector, images, rects, overlap_eps, adjust_threshold);
     }
 
 // ----------------------------------------------------------------------------------------
@@ -241,7 +221,8 @@ namespace dlib
         const image_array_type& images,
         const std::vector<std::vector<full_object_detection> >& truth_dets,
         const long folds,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     )
     {
         // make sure requires clause is not broken
@@ -285,25 +266,12 @@ namespace dlib
             typename trainer_type::trained_function_type detector = trainer.train(array_subset, training_rects);
             for (unsigned long i = 0; i < test_idx_set.size(); ++i)
             {
-                std::vector<std::pair<double,rectangle> > all_dets;
-                detector(images[test_idx_set[i]], all_dets, -std::numeric_limits<double>::infinity());
-                std::vector<rectangle> hits;
-                for (unsigned long k = 0; k < all_dets.size(); ++k)
-                {
-                    if (all_dets[k].first >= 0)
-                        hits.push_back(all_dets[k].second);
-                }
+                const std::vector<rectangle>& hits = detector(images[test_idx_set[i]], adjust_threshold);
 
+                double ap;
                 total_hits += hits.size();
-                correct_hits += impl::number_of_truth_hits(truth_dets[test_idx_set[i]], hits, overlap_eps);
+                correct_hits += impl::number_of_truth_hits(truth_dets[test_idx_set[i]], hits, overlap_eps, ap);
                 total_true_targets += truth_dets[test_idx_set[i]].size();
-
-                // now get the average precision 
-                hits.clear();
-                for (unsigned long k = 0; k < all_dets.size(); ++k)
-                    hits.push_back(all_dets[k].second);
-                double ap;
-                impl::number_of_truth_hits(truth_dets[test_idx_set[i]], hits, overlap_eps, ap);
                 map.add(ap);
             }
 
@@ -337,7 +305,8 @@ namespace dlib
         const image_array_type& images,
         const std::vector<std::vector<rectangle> >& truth_dets,
         const long folds,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     )
     {
         // convert into a list of regular rectangles.
@@ -350,7 +319,7 @@ namespace dlib
             }
         }
 
-        return cross_validate_object_detection_trainer(trainer, images, dets, folds, overlap_eps);
+        return cross_validate_object_detection_trainer(trainer, images, dets, folds, overlap_eps, adjust_threshold);
     }
 
 // ----------------------------------------------------------------------------------------

dlib/svm/cross_validate_object_detection_trainer_abstract.h

@@ -21,7 +21,8 @@ namespace dlib
         object_detector_type& detector,
         const image_array_type& images,
         const std::vector<std::vector<full_object_detection> >& truth_dets,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     );
     /*!
         requires
@@ -49,15 +50,20 @@ namespace dlib
                   any of the targets.
                 - M(2) == the mean average precision of the detector object.  This is a
                   number in the range [0,1] which measures the overall quality of the
-                  detector when the detector is asked to output a ranked listing of all
-                  possible detections.  In particular, this is accomplished by setting the
-                  detection threshold such that all possible detections are output.  Then
-                  the detections are ordered by their detection score and we use the
-                  average_precision() routine to score each ranked listing, finally setting
-                  M(2) to the mean value over all test images.
+                  detector.  We do this by taking all the detections output by the detector
+                  and ordering them by their detection score.  Then we use the
+                  average_precision() routine to score the ranked listing.  Finally we set
+                  M(2) to the mean value over all test images.  
                 - The rule for deciding if a detector output, D, matches a truth rectangle,
                   T, is the following:
                     T and R match if and only if: T.intersect(R).area()/(T+R).area() > overlap_eps
+                - Note that you can use the adjust_threshold argument to raise or lower the
+                  detection threshold.  This value is passed into the identically named
+                  argument to the detector object and therefore influences the number of
+                  output detections.  It can be useful, for example, to lower the detection
+                  threshold because it results in more detections being output by the
+                  detector, and therefore provides more information in the ranking,
+                  possibly raising the mean average precision.
     !*/
 
     template <
@@ -68,7 +74,8 @@ namespace dlib
         object_detector_type& detector,
         const image_array_type& images,
         const std::vector<std::vector<rectangle> >& truth_dets,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     );
     /*!
         requires
@@ -91,7 +98,8 @@ namespace dlib
         const image_array_type& images,
         const std::vector<std::vector<full_object_detection> >& truth_dets,
         const long folds,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     );
     /*!
         requires
@@ -120,7 +128,8 @@ namespace dlib
         const image_array_type& images,
         const std::vector<std::vector<rectangle> >& truth_dets,
         const long folds,
-        const double overlap_eps = 0.5
+        const double overlap_eps = 0.5,
+        const double adjust_threshold = 0
     );
     /*!
         requires