diff options
Diffstat (limited to 'ml/dlib/dlib/svm/structural_svm_object_detection_problem_abstract.h')
| -rw-r--r-- | ml/dlib/dlib/svm/structural_svm_object_detection_problem_abstract.h | 178 |
1 files changed, 178 insertions, 0 deletions
diff --git a/ml/dlib/dlib/svm/structural_svm_object_detection_problem_abstract.h b/ml/dlib/dlib/svm/structural_svm_object_detection_problem_abstract.h new file mode 100644 index 000000000..d73c5920d --- /dev/null +++ b/ml/dlib/dlib/svm/structural_svm_object_detection_problem_abstract.h @@ -0,0 +1,178 @@ +// Copyright (C) 2011 Davis E. King (davis@dlib.net) +// License: Boost Software License See LICENSE.txt for the full license. +#undef DLIB_STRUCTURAL_SVM_ObJECT_DETECTION_PROBLEM_ABSTRACT_Hh_ +#ifdef DLIB_STRUCTURAL_SVM_ObJECT_DETECTION_PROBLEM_ABSTRACT_Hh_ + +#include "../matrix.h" +#include "structural_svm_problem_threaded_abstract.h" +#include <sstream> +#include "../image_processing/full_object_detection_abstract.h" +#include "../image_processing/box_overlap_testing.h" + +namespace dlib +{ + +// ---------------------------------------------------------------------------------------- + + template < + typename image_scanner_type, + typename image_array_type + > + class structural_svm_object_detection_problem : public structural_svm_problem_threaded<matrix<double,0,1> >, + noncopyable + { + /*! + REQUIREMENTS ON image_scanner_type + image_scanner_type must be an implementation of + dlib/image_processing/scan_fhog_pyramid_abstract.h or + dlib/image_processing/scan_image_custom_abstract.h or + dlib/image_processing/scan_image_pyramid_abstract.h or + dlib/image_processing/scan_image_boxes_abstract.h + + REQUIREMENTS ON image_array_type + image_array_type must be an implementation of dlib/array/array_kernel_abstract.h + and it must contain objects which can be accepted by image_scanner_type::load(). + + WHAT THIS OBJECT REPRESENTS + This object is a tool for learning the parameter vector needed to use a + scan_image_pyramid, scan_fhog_pyramid, scan_image_custom, or + scan_image_boxes object. + + It learns the parameter vector by formulating the problem as a structural + SVM problem. The exact details of the method are described in the paper + Max-Margin Object Detection by Davis E. King (http://arxiv.org/abs/1502.00046). + + + !*/ + + public: + + structural_svm_object_detection_problem( + const image_scanner_type& scanner, + const test_box_overlap& overlap_tester, + const bool auto_overlap_tester, + const image_array_type& images, + const std::vector<std::vector<full_object_detection> >& truth_object_detections, + const std::vector<std::vector<rectangle> >& ignore, + const test_box_overlap& ignore_overlap_tester, + unsigned long num_threads = 2 + ); + /*! + requires + - is_learning_problem(images, truth_object_detections) + - ignore.size() == images.size() + - scanner.get_num_detection_templates() > 0 + - scanner.load(images[0]) must be a valid expression. + - for all valid i, j: + - truth_object_detections[i][j].num_parts() == scanner.get_num_movable_components_per_detection_template() + - all_parts_in_rect(truth_object_detections[i][j]) == true + ensures + - This object attempts to learn a mapping from the given images to the + object locations given in truth_object_detections. In particular, it + attempts to learn to predict truth_object_detections[i] based on + images[i]. Or in other words, this object can be used to learn a + parameter vector, w, such that an object_detector declared as: + object_detector<image_scanner_type> detector(scanner,get_overlap_tester(),w) + results in a detector object which attempts to compute the locations of + all the objects in truth_object_detections. So if you called + detector(images[i]) you would hopefully get a list of rectangles back + that had truth_object_detections[i].size() elements and contained exactly + the rectangles indicated by truth_object_detections[i]. + - if (auto_overlap_tester == true) then + - #get_overlap_tester() == a test_box_overlap object that is configured + using the find_tight_overlap_tester() routine and the contents of + truth_object_detections. + - else + - #get_overlap_tester() == overlap_tester + - #get_match_eps() == 0.5 + - This object will use num_threads threads during the optimization + procedure. You should set this parameter equal to the number of + available processing cores on your machine. + - #get_loss_per_missed_target() == 1 + - #get_loss_per_false_alarm() == 1 + - for all valid i: + - Within images[i] any detections that match against a rectangle in + ignore[i], according to ignore_overlap_tester, are ignored. That is, + the optimizer doesn't care if the detector outputs a detection that + matches any of the ignore rectangles or if it fails to output a + detection for an ignore rectangle. Therefore, if there are objects + in your dataset that you are unsure you want to detect or otherwise + don't care if the detector gets or doesn't then you can mark them + with ignore rectangles and the optimizer will simply ignore them. + !*/ + + test_box_overlap get_overlap_tester ( + ) const; + /*! + ensures + - returns the overlap tester used by this object. + !*/ + + void set_match_eps ( + double eps + ); + /*! + requires + - 0 < eps < 1 + ensures + - #get_match_eps() == eps + !*/ + + double get_match_eps ( + ) const; + /*! + ensures + - returns the amount of alignment necessary for a detection to be considered + as matching with a ground truth rectangle. The precise formula for determining + if two rectangles match each other is the following, rectangles A and B match + if and only if: + A.intersect(B).area()/(A+B).area() > get_match_eps() + !*/ + + double get_loss_per_missed_target ( + ) const; + /*! + ensures + - returns the amount of loss experienced for failing to detect one of the + targets. + !*/ + + void set_loss_per_missed_target ( + double loss + ); + /*! + requires + - loss > 0 + ensures + - #get_loss_per_missed_target() == loss + !*/ + + double get_loss_per_false_alarm ( + ) const; + /*! + ensures + - returns the amount of loss experienced for emitting a false alarm detection. + Or in other words, the loss for generating a detection that doesn't correspond + to one of the truth rectangles. + !*/ + + void set_loss_per_false_alarm ( + double loss + ); + /*! + requires + - loss > 0 + ensures + - #get_loss_per_false_alarm() == loss + !*/ + + }; + +// ---------------------------------------------------------------------------------------- + +} + +#endif // DLIB_STRUCTURAL_SVM_ObJECT_DETECTION_PROBLEM_ABSTRACT_Hh_ + + + |