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

// $Id$

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

#include <c++_tools/classifier/DataLookup1D.h>
#include <c++_tools/classifier/DataLookup2D.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 DataLookup2D& data, const Target& target, 
           const statistics::Distance& distance) 
    : SupervisedClassifier(target), distance_(distance), matrix_(data)
  {   
  }

  NCC::NCC(const DataLookup2D& 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 
  {     
    NCC* ncc= new NCC(data,target,this->distance_);
    ncc->score_=this->score_;
    ncc->nof_inputs_=this->nof_inputs_;
    return ncc;
  }


  bool NCC::train()
  {
    if(ranker_)
      delete ranker_;
    if(score_)
      ranker_=new InputRanker(matrix_, target_, *score_);
    // Markus : ranker_ should be taken into account if used!!!

    // Calculate the centroids for each class
    centroids_=gslapi::matrix(matrix_.rows(),target_.nof_classes());
    gslapi::matrix nof_in_class(matrix_.rows(),target_.nof_classes());
    for(size_t i=0; i<matrix_.rows(); i++) {
      for(size_t j=0; j<matrix_.columns(); j++) {
        if(!std::isnan(matrix_(i,j))) {
          centroids_(i,target_(j)) += matrix_(i,j);
          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
  {
    // Markus : ranker_ should be taken into account if used!!!

    prediction=gslapi::vector(centroids_.columns());    
    gslapi::vector w(input.size(),0);
    for(size_t i=0; i<input.size(); i++)  // take care of missing values
      if(!std::isnan(input(i)))
        w(i)=1.0;
    for(size_t j=0; j<centroids_.columns(); j++) 
      prediction(j)=distance_(gslapi::vector(input),
                             gslapi::vector(centroids_,j,false),w, w);    
  }


  void NCC::predict(const DataLookup2D& input,                    
                    gslapi::matrix& prediction) const
  {
    // Markus : ranker_ should be taken into account if used!!!
    
    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