// Copyright (C) 2012 Davis E. King (davis@dlib.net) // License: Boost Software License See LICENSE.txt for the full license. #undef DLIB_RLS_FiLTER_ABSTRACT_Hh_ #ifdef DLIB_RLS_FiLTER_ABSTRACT_Hh_ #include "../svm/rls_abstract.h" #include "../matrix/matrix_abstract.h" namespace dlib{// ---------------------------------------------------------------------------------------- classrls_filter{/*! WHAT THIS OBJECT REPRESENTS This object is a tool for doing time series prediction using linear recursive least squares. In particular, this object takes a sequence of points from the user and, at each step, attempts to predict the value of the next point. To accomplish this, this object maintains a fixed size buffer of recent points. Each prediction is a linear combination of the points in this history buffer. It uses the recursive least squares algorithm to determine how to best combine the contents of the history buffer to predict each point. Therefore, each time update() is called with a point, recursive least squares updates the linear combination weights, and then it inserts the point into the history buffer. After that, the next prediction is based on these updated weights and the current history buffer. !*/ public:rls_filter( ); /*! ensures - #get_window_size() == 5 - #get_forget_factor() == 0.8 - #get_c() == 100 - #get_predicted_next_state().size() == 0 !*/ explicitrls_filter(unsignedlongsize,doubleforget_factor = 0.8,doubleC = 100 ); /*! requires - 0 < forget_factor <= 1 - 0 < C - size >= 2 ensures - #get_window_size() == size - #get_forget_factor() == forget_factor - #get_c() == C - #get_predicted_next_state().size() == 0 !*/doubleget_c( ) const; /*! ensures - returns the regularization parameter. It is the parameter that determines the trade-off between trying to fit the data points given to update() or allowing more errors but hopefully improving the generalization of the predictions. Larger values encourage exact fitting while smaller values of C may encourage better generalization. !*/doubleget_forget_factor( ) const; /*! ensures - This object uses exponential forgetting in its implementation of recursive least squares. Therefore, this function returns the "forget factor". - if (get_forget_factor() == 1) then - In this case, exponential forgetting is disabled. - The recursive least squares algorithm will implicitly take all previous calls to update(z) into account when estimating the optimal weights for linearly combining the history buffer into a prediction of the next point. - else - Old calls to update(z) are eventually forgotten. That is, the smaller the forget factor, the less recursive least squares will care about attempting to find linear combination weights which would have make good predictions on old points. It will care more about fitting recent points. This is appropriate if the statistical properties of the time series we are modeling are not constant. !*/unsignedlongget_window_size( ) const; /*! ensures - returns the size of the history buffer. This is the number of points which are linearly combine to make the predictions returned by get_predicted_next_state(). !*/voidupdate( ); /*! ensures - Propagates the prediction forward in time. - In particular, the value in get_predicted_next_state() is inserted into the history buffer and then the next prediction is estimated based on this updated history buffer. - #get_predicted_next_state() == the prediction for the next point in the time series. !*/ template <typename EXP>voidupdate( const matrix_exp<EXP>& z ); /*! requires - is_col_vector(z) == true - z.size() != 0 - if (get_predicted_next_state().size() != 0) then - z.size() == get_predicted_next_state().size() (i.e. z must be the same size as all the previous z values given to this function) ensures - Updates the state of this filter based on the current measurement in z. - In particular, the filter weights are updated and z is inserted into the history buffer. Then the next prediction is estimated based on these updated weights and history buffer. - #get_predicted_next_state() == the prediction for the next point in the time series. - #get_predicted_next_state().size() == z.size() !*/ const matrix<double,0,1>&get_predicted_next_state( ) const; /*! ensures - returns the estimate of the next point we will observe in the time series data. !*/}; // ----------------------------------------------------------------------------------------voidserialize( const rls_filter& item, std::ostream& out ); /*! provides serialization support !*/voiddeserialize( rls_filter& item, std::istream& in ); /*! provides deserialization support !*/ // ----------------------------------------------------------------------------------------}#endif // DLIB_RLS_FiLTER_ABSTRACT_Hh_