dlib C++ Library - linearly_independent_subset_finder_abstract.h

    // Copyright (C) 2008  Davis E. King (davisking@users.sourceforge.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #undef DLIB_LISf_ABSTRACT_
    #ifdef DLIB_LISf_ABSTRACT_

    #include "../algs.h"
    #include "../serialize.h"
    #include "kernel_abstract.h"

    namespace dlib
    {

        template <
            typename kernel_type
            >
        class linearly_independent_subset_finder
        {
            /*!
                REQUIREMENTS ON kernel_type
                    is a kernel function object as defined in dlib/svm/kernel_abstract.h

                INITIAL VALUE
                    - dictionary_size() == 0

                WHAT THIS OBJECT REPRESENTS
                    This is an implementation of an online algorithm for recursively finding a
                    set of linearly independent vectors in a kernel induced feature space.  To
                    use it you decide how large you would like the set to be and then you feed it
                    sample points.

                    Each time you present it with a new sample point (via this->add()) it either
                    keeps the current set of independent points unchanged, or if the new point
                    is "more linearly independent" than one of the points it already has,
                    it replaces the weakly linearly independent point with the new one.

                    This object uses the Approximately Linearly Dependent metric described in the paper
                    The Kernel Recursive Least Squares Algorithm by Yaakov Engel to decide which
                    points are more linearly independent than others.
            !*/

        public:
            typedef typename kernel_type::scalar_type scalar_type;
            typedef typename kernel_type::sample_type sample_type;
            typedef typename kernel_type::mem_manager_type mem_manager_type;

            linearly_independent_subset_finder (
                const kernel_type& kernel_,
                unsigned long max_dictionary_size,
                scalar_type min_tolerance = 0.001
            );
            /*!
                requires
                    - min_tolerance > 0
                ensures
                    - #minimum_tolerance() == min_tolerance
                    - this object is properly initialized
                    - #get_kernel() == kernel_
                    - #max_dictionary_size() == max_dictionary_size_
            !*/

            const kernel_type& get_kernel (
            ) const;
            /*!
                ensures
                    - returns a const reference to the kernel used by this object
            !*/

            unsigned long max_dictionary_size(
            ) const;
            /*!
                ensures
                    - returns the maximum number of dictionary vectors this object
                      will accumulate.  That is, dictionary_size() will never be
                      greater than max_dictionary_size().
            !*/

            scalar_type minimum_tolerance(
            ) const;
            /*!
                ensures
                    - returns the minimum tolerance to use for the approximately linearly dependent
                      test used for dictionary vector selection (see KRLS paper for ALD details).
                      In other words, this is the minimum threshold for how linearly independent
                      a sample must be for it to even be considered for addition to the dictionary.
                      Moreover, bigger values of this field will make the algorithm run faster but
                      might give less accurate results.
            !*/

            void clear_dictionary (
            );
            /*!
                ensures
                    - clears out all the data (e.g. #dictionary_size() == 0)
            !*/

            void add (
                const sample_type& x
            );
            /*!
                ensures
                    - if (x is linearly independent of the vectors already in this object) then
                        - adds x into the dictionary
                        - if (dictionary_size() < max_dictionary_size()) then
                            - #dictionary_size() == dictionary_size() + 1
                        - else
                            - #dictionary_size() == dictionary_size()
                              (i.e. the number of vectors in this object doesn't change)
                            - the least linearly independent vector in this object is removed
            !*/

            void swap (
                linearly_independent_subset_finder& item
            );
            /*!
                ensures
                    - swaps *this with item
            !*/

            unsigned long dictionary_size (
            ) const;
            /*!
                ensures
                    - returns the number of vectors in the dictionary.
            !*/

            const sample_type& operator[] (
                unsigned long index
            ) const;
            /*!
                requires
                    - index < dictionary_size()
                ensures
                    - returns the index'th element in the set of linearly independent
                      vectors contained in this object.
            !*/

            const matrix<sample_type,0,1,mem_manager_type> get_dictionary (
            ) const;
            /*!
                ensures
                    - returns a column vector that contains all the dictionary
                      vectors in this object.
            !*/

        };

    // ----------------------------------------------------------------------------------------

        template <
            typename kernel_type
            >
        void swap(
            linearly_independent_subset_finder<kernel_type>& a,
            linearly_independent_subset_finder<kernel_type>& b
        ) { a.swap(b); }
        /*!
            provides a global swap function
        !*/

        template <
            typename kernel_type
            >
        void serialize (
            const linearly_independent_subset_finder<kernel_type>& item,
            std::ostream& out
        );
        /*!
            provides serialization support for linearly_independent_subset_finder objects
        !*/

        template <
            typename kernel_type
            >
        void deserialize (
            linearly_independent_subset_finder<kernel_type>& item,
            std::istream& in
        );
        /*!
            provides serialization support for linearly_independent_subset_finder objects
        !*/

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_LISf_ABSTRACT_