coco
136 lines
5.2 KiB
C++
136 lines
5.2 KiB
C++
// Copyright (C) 2009 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
#undef DLIB_ROC_TRAINEr_ABSTRACT_
|
|
#ifdef DLIB_ROC_TRAINEr_ABSTRACT_
|
|
|
|
#include "../algs.h"
|
|
|
|
namespace dlib
|
|
{
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename trainer_type
|
|
>
|
|
class roc_trainer_type
|
|
{
|
|
/*!
|
|
REQUIREMENTS ON trainer_type
|
|
- trainer_type == some kind of batch trainer object (e.g. svm_nu_trainer)
|
|
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object is a simple trainer post processor that allows you to
|
|
easily adjust the bias term in a trained decision_function object.
|
|
That is, this object lets you pick a point on the ROC curve and
|
|
it will adjust the bias term appropriately.
|
|
|
|
So for example, suppose you wanted to set the bias term so that
|
|
the accuracy of your decision function on +1 labeled samples was 99%.
|
|
To do this you would use an instance of this object declared as follows:
|
|
roc_trainer_type<trainer_type>(your_trainer, 0.99, +1);
|
|
!*/
|
|
|
|
public:
|
|
typedef typename trainer_type::kernel_type kernel_type;
|
|
typedef typename trainer_type::scalar_type scalar_type;
|
|
typedef typename trainer_type::sample_type sample_type;
|
|
typedef typename trainer_type::mem_manager_type mem_manager_type;
|
|
typedef typename trainer_type::trained_function_type trained_function_type;
|
|
|
|
roc_trainer_type (
|
|
);
|
|
/*!
|
|
ensures
|
|
- This object is in an uninitialized state. You must
|
|
construct a real one with the other constructor and assign it
|
|
to this instance before you use this object.
|
|
!*/
|
|
|
|
roc_trainer_type (
|
|
const trainer_type& trainer_,
|
|
const scalar_type& desired_accuracy_,
|
|
const scalar_type& class_selection_
|
|
);
|
|
/*!
|
|
requires
|
|
- 0 <= desired_accuracy_ <= 1
|
|
- class_selection_ == +1 or -1
|
|
ensures
|
|
- when training is performed using this object it will automatically
|
|
adjust the bias term in the returned decision function so that it
|
|
achieves the desired accuracy on the selected class type.
|
|
!*/
|
|
|
|
template <
|
|
typename in_sample_vector_type,
|
|
typename in_scalar_vector_type
|
|
>
|
|
const trained_function_type train (
|
|
const in_sample_vector_type& samples,
|
|
const in_scalar_vector_type& labels
|
|
) const
|
|
/*!
|
|
requires
|
|
- is_binary_classification_problem(samples, labels) == true
|
|
- x == a matrix or something convertible to a matrix via mat().
|
|
Also, x should contain sample_type objects.
|
|
- y == a matrix or something convertible to a matrix via mat().
|
|
Also, y should contain scalar_type objects.
|
|
ensures
|
|
- performs training using the trainer object given to this object's
|
|
constructor, then modifies the bias term in the returned decision function
|
|
as discussed above, and finally returns the decision function.
|
|
!*/
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename trainer_type
|
|
>
|
|
const roc_trainer_type<trainer_type> roc_c1_trainer (
|
|
const trainer_type& trainer,
|
|
const typename trainer_type::scalar_type& desired_accuracy
|
|
) { return roc_trainer_type<trainer_type>(trainer, desired_accuracy, +1); }
|
|
/*!
|
|
requires
|
|
- 0 <= desired_accuracy <= 1
|
|
- trainer_type == some kind of batch trainer object that creates decision_function
|
|
objects (e.g. svm_nu_trainer)
|
|
ensures
|
|
- returns a roc_trainer_type object that has been instantiated with the given
|
|
arguments. The returned roc trainer will select the decision function
|
|
bias that gives the desired accuracy with respect to the +1 class.
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename trainer_type
|
|
>
|
|
const roc_trainer_type<trainer_type> roc_c2_trainer (
|
|
const trainer_type& trainer,
|
|
const typename trainer_type::scalar_type& desired_accuracy
|
|
) { return roc_trainer_type<trainer_type>(trainer, desired_accuracy, -1); }
|
|
/*!
|
|
requires
|
|
- 0 <= desired_accuracy <= 1
|
|
- trainer_type == some kind of batch trainer object that creates decision_function
|
|
objects (e.g. svm_nu_trainer)
|
|
ensures
|
|
- returns a roc_trainer_type object that has been instantiated with the given
|
|
arguments. The returned roc trainer will select the decision function
|
|
bias that gives the desired accuracy with respect to the -1 class.
|
|
!*/
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
|
|
#endif // DLIB_ROC_TRAINEr_ABSTRACT_
|
|
|
|
|
|
|