weakrule.h

Go to the documentation of this file.

//
//    Omlet - Open Machine Learning Enhanced Toolkit
//
//    Copyright (C) 2014   TALP Research Center
//                         Universitat Politecnica de Catalunya
//
//    This file is part of the Omlet library
//
//    The Omlet library is free software; you can redistribute it 
//    and/or modify it under the terms of the GNU Affero General Public
//    License as published by the Free Software Foundation; either
//    version 3 of the License, or (at your option) any later version.
//
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Affero General Public License for more details.
//
//    You should have received a copy of the GNU Affero General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
//
//    contact: Lluis Padro (padro@lsi.upc.es)
//             TALP Research Center
//             despatx Omega.S112 - Campus Nord UPC
//             08034 Barcelona.  SPAIN
//

//
// Author: Xavier Carreras
//

#ifndef _WEAKRULE
#define _WEAKRULE

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include "freeling/tree.h"
#include "freeling/safe_map.h"
#include "freeling/omlet/dataset.h"

namespace freeling {


  class wr_params {
  public:
    int nlabels;
    double epsilon;

    wr_params (int nl, double e);
  };


  class weak_rule {

  public:
    virtual ~weak_rule() {};
 
    virtual void classify(const example &i,double pred[]) = 0;

    virtual void read_from_stream(std::wistream *is) = 0;
    virtual void write_to_stream(std::wostream *os) = 0;
    
    virtual void learn(const dataset &ds, double &Z) = 0;

    virtual double Zcalculus(const dataset &ds) const;
  };





  class wr_factory {

  public:
    typedef weak_rule* (*WR_constructor)(wr_params*);
    static void initialize();
    static bool register_weak_rule_type(const std::wstring &type, WR_constructor builder);
    static bool unregister_weak_rule_type(const std::wstring &type);
    static weak_rule* create_weak_rule(const std::wstring &type, wr_params *p);
    static weak_rule* create_weak_rule(const std::wstring &type, int nlabels);

  private:
    // store weakrule types registered by user apps
    static safe_map<std::wstring, WR_constructor> wr_types;

  };



  class mlDTree_params : public wr_params {
  public:
    int    max_depth;

    mlDTree_params (int nl, double e, int mxd);
  };


  class dt_node {
    friend class mlDTree;
    //protected:
  public:
    int     feature;              // 0 when leaf
    std::vector<double>  predictions;  // empty when not leaf (when leaf, array of predictions, one for each class)

  public:
    // empty constructor
    dt_node();
    dt_node(int f);
    dt_node(int nl, double pr[]);
    dt_node(const dt_node &n);
  };


  class mlDTree : public weak_rule {

  private:
    // learning parameters for the specific type of weak rule
    mlDTree_params params;

    // decision tree itself
    tree<dt_node> rule;
    // learning auxiliary list.
    std::set<int> used_features; 

    void classify (const example &i, double pred[], tree<dt_node>::iterator t);

    void write_to_stream(tree<dt_node>::iterator t, std::wostream *os);
    tree<dt_node> read_dt(std::wistream *is);
  
    tree<dt_node> learn (const dataset &ds, double &Z, int depth);

    bool stopping_criterion(const dataset &ds, int depth);
    int best_feature(const dataset &ds, double *W);
    void Cprediction(int v, double *W, double result[]);
    double Zcalculus(double *W, int ndim);

    mlDTree(const mlDTree &wr0);

  public:

    // Constructor
    mlDTree(mlDTree_params *p);

    void classify(const example &i, double pred[]);

    void write_to_stream(std::wostream *os);
    void read_from_stream(std::wistream *is);

    void learn(const dataset &ds, double &Z);
  };

} // namespace

#endif