source: trunk/lib/classifier/NCC.cc @ 526

// $Id$

#include <c++_tools/classifier/NCC.h>

#include <c++_tools/classifier/DataLookup1D.h>
#include <c++_tools/classifier/DataLookup2D.h>
#include <c++_tools/classifier/MatrixLookup.h>
#include <c++_tools/classifier/InputRanker.h>
#include <c++_tools/classifier/Target.h>
#include <c++_tools/gslapi/vector.h>
#include <c++_tools/statistics/Distance.h>
#include <c++_tools/utility/stl_utility.h>

#include<iostream>
#include<iterator>
#include <map>
#include <cmath>

namespace theplu {
namespace classifier {

  NCC::NCC(const MatrixLookup& data, const Target& target, 
           const statistics::Distance& distance) 
    : SupervisedClassifier(target), distance_(distance), matrix_(data)
  {   
  }

  NCC::NCC(const MatrixLookup& data, const Target& target, 
           const statistics::Distance& distance, 
           statistics::Score& score, size_t nof_inputs) 
    : SupervisedClassifier(target, &score, nof_inputs), 
      distance_(distance), matrix_(data)
  {
  }

  NCC::~NCC()   
  {
    if(ranker_)
      delete ranker_;
  }


  SupervisedClassifier* 
  NCC::make_classifier(const DataLookup2D& data, 
                       const Target& target) const 
  {     
    const MatrixLookup& tmp = dynamic_cast<const MatrixLookup&>(data);

    NCC* ncc= new NCC(tmp,target,this->distance_);
    ncc->score_=this->score_;
    ncc->nof_inputs_=this->nof_inputs_;
    return ncc;
  }


  bool NCC::train()
  {
    // If score is set calculate centroids only for nof_inputs_ number
    // of top ranked inputs. Otherwise calculate centroids based on
    // all inputs ( = all rows in data matrix).
    if(ranker_)
      delete ranker_;
    size_t rows=matrix_.rows();
    if(score_) {
      // Markus: missing values should not be handled here, but a weight matrix
      // should be supported throughout the classifier class structure.
      gslapi::matrix weight(matrix_.rows(),matrix_.columns(),0.0);
      for(size_t i=0; i<matrix_.rows(); i++) 
        for(size_t j=0; j<matrix_.columns(); j++) 
          if(!std::isnan(matrix_(i,j))) 
            weight(i,j)=1.0;
      MatrixLookup weightview(weight);
      ranker_=new InputRanker(matrix_, target_, *score_, weightview);
      rows=nof_inputs_;
    }
    centroids_=gslapi::matrix(rows, target_.nof_classes());
    gslapi::matrix nof_in_class(rows, target_.nof_classes());
    for(size_t i=0; i<rows; i++) {
      for(size_t j=0; j<matrix_.columns(); j++) {
        double value=matrix_(i,j);
        if(score_)
          value=matrix_(ranker_->id(i),j);
        if(!std::isnan(value)) {
          centroids_(i,target_(j)) += value;
          nof_in_class(i,target_(j))++;
        }
      }
    }
    centroids_.div_elements(nof_in_class);
    trained_=true;
    return trained_;
  }


  void NCC::predict(const DataLookup1D& input, 
                    gslapi::vector& prediction) const
  {
    prediction=gslapi::vector(centroids_.columns());    
    size_t size=input.size();
    if(ranker_)
      size=nof_inputs_;
    gslapi::vector w(size,0);
    gslapi::vector value(size,0);
    for(size_t i=0; i<size; i++)  { // take care of missing values
      value(i)=input(i);
      if(ranker_)
        value(i)=input(ranker_->id(i));
      if(!std::isnan(value(i)))
        w(i)=1.0;
    }
    for(size_t j=0; j<centroids_.columns(); j++) 
      prediction(j)=distance_(value,gslapi::vector(centroids_,j,false),w, w);   
  }


  void NCC::predict(const DataLookup2D& input,                    
                    gslapi::matrix& prediction) const
  {
    prediction=gslapi::matrix(centroids_.columns(), input.columns());   
    for(size_t j=0; j<input.columns();j++) {     
      DataLookup1D in(input,j,true);
      gslapi::vector out;
      predict(in,out);
      prediction.set_column(j,out);
    }
  }

  
  // additional operators

//  std::ostream& operator<< (std::ostream& s, const NCC& ncc) {
//    std::copy(ncc.classes().begin(), ncc.classes().end(), 
//              std::ostream_iterator<std::map<double, u_int>::value_type>
//              (s, "\n"));
//    s << "\n" << ncc.centroids() << "\n";
//    return s;
//  }

}} // of namespace classifier and namespace theplu