weakrule.h

Go to the documentation of this file.

//
//    Omlet - Open Machine Learning Enhanced Toolkit
//
//    Copyright (C) 2006   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 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
//    General Public License for more details.
//
//    You should have received a copy of the GNU 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/omlet/dataset.h"



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:
  static std::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);
};


#endif