learnmodel.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef __LEMGA_LEARNMODEL_H__
#define __LEMGA_LEARNMODEL_H__

#include <assert.h>
#include <vector>
#include "object.h"
#include "dataset.h"
#include "shared_ptr.h"

#define VERBOSE_OUTPUT  1

namespace lemga {

typedef std::vector<REAL> Input;
typedef std::vector<REAL> Output;

typedef dataset<Input,Output> DataSet;
typedef std::vector<REAL> DataWgt;
typedef const_shared_ptr<DataSet> pDataSet;
typedef const_shared_ptr<DataWgt> pDataWgt;

DataSet* load_data (std::istream&, UINT, UINT, UINT);
DataSet* load_data (std::istream&, UINT);

class LearnModel : public Object {
protected:
    UINT _n_in;       
    UINT _n_out;      
    pDataSet ptd;     
    pDataWgt ptw;     
    UINT n_samples;   

    FILE* logf;       

public:
    LearnModel (UINT n_in = 0, UINT n_out = 0);

    virtual LearnModel* create () const = 0;
    virtual LearnModel* clone () const = 0;

    UINT n_input  () const { return _n_in;  }
    UINT n_output () const { return _n_out; }

    void set_log_file (FILE* f) { logf = f; }


    virtual bool support_weighted_data () const { return false; }

    virtual REAL r_error (const Output& out, const Output& y) const;
    virtual REAL c_error (const Output& out, const Output& y) const;

    REAL train_r_error () const;
    REAL train_c_error () const;
    REAL test_r_error (const pDataSet&) const;
    REAL test_c_error (const pDataSet&) const;

    virtual void initialize () {
        std::cerr << "!!! initialize() is depreciated.\n"
                  << "!!! See the documentation of LearnModel and reset().\n";
    }

    virtual void set_train_data (const pDataSet&, const pDataWgt& = 0);
    const pDataSet& train_data () const { return ptd; }
    /* temporarily disabled; ptw in boosting base learners is reset
     * after the training; disabled to be sure no one actually uses it
    const pDataWgt& data_weight () const { return ptw; }
     */

    virtual void train () = 0;

    virtual void reset ();

    virtual Output operator() (const Input&) const = 0;

    virtual Output get_output (UINT idx) const {
        assert(ptw != 0); // no data sampling
        return operator()(ptd->x(idx)); }


    virtual REAL margin_norm () const { return 1; }
    virtual REAL margin_of (const Input& x, const Output& y) const;
    virtual REAL margin (UINT i) const {
        assert(ptw != 0); // no data sampling
        return margin_of(ptd->x(i), ptd->y(i)); }
    REAL min_margin () const;

    bool valid_dimensions (UINT, UINT) const;
    inline bool valid_dimensions (const LearnModel& l) const {
        return valid_dimensions(l.n_input(), l.n_output()); }

    inline bool exact_dimensions (UINT i, UINT o) const {
        return (i > 0 && o > 0 && valid_dimensions(i, o)); }
    inline bool exact_dimensions (const LearnModel& l) const {
        return exact_dimensions(l.n_input(), l.n_output()); }
    inline bool exact_dimensions (const DataSet& d) const {
        assert(d.size() > 0);
        return exact_dimensions(d.x(0).size(), d.y(0).size()); }

protected:
    void set_dimensions (UINT, UINT);
    inline void set_dimensions (const LearnModel& l) {
        set_dimensions(l.n_input(), l.n_output()); }
    inline void set_dimensions (const DataSet& d) {
        assert(exact_dimensions(d));
        set_dimensions(d.x(0).size(), d.y(0).size()); }

    virtual bool serialize (std::ostream&, ver_list&) const;
    virtual bool unserialize (std::istream&, ver_list&, const id_t& = NIL_ID);
};

typedef var_shared_ptr<LearnModel> pLearnModel;
typedef const_shared_ptr<LearnModel> pcLearnModel;

} // namespace lemga

#ifdef  __LEARNMODEL_H__
#warning "This header file may conflict with another `learnmodel.h' file."
#endif
#define __LEARNMODEL_H__
#endif

---