source: branches/peters_vector/lib/classifier/NCC.cc @ 469

// $Id$

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

#include <c++_tools/classifier/DataView.h>
#include <c++_tools/classifier/Target.h>
#include <c++_tools/gslapi/vector.h>
#include <c++_tools/statistics/Averager.h>
#include <c++_tools/statistics/AveragerPairWeighted.h>
#include <c++_tools/utility/stl_utility.h>

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

namespace theplu {
namespace classifier {

  NCC::NCC(const DataView& data, const Target& target) 
  {
    Target sorted_target(target);
    sorted_target.sort(); // if targets contain NaN => infinite loop
    
    // Find the classes of targets
    u_int nof_classes=0;
    for (size_t i=0; i<sorted_target.size(); i++) {
      std::pair<const double, u_int> p(sorted_target(i),nof_classes);
      std::pair<std::map<double,u_int>::iterator,bool> 
        status=classes_.insert(p);
      if(status.second==true) {
        nof_classes++;
      }
    }
    
    // Calculate the centroids for each class
    centroids_=gslapi::matrix(data.rows(),classes_.size());
    gslapi::matrix nof_in_class(data.rows(),classes_.size());
    for(size_t i=0; i<data.rows(); i++) {
      for(size_t j=0; j<data.columns(); j++) {
        if(!std::isnan(data(i,j))) {
          centroids_(i,classes_[target(j)]) += data(i,j);
          nof_in_class(i,classes_[target(j)])++;
        }
      }
    }
    centroids_.div_elements(nof_in_class);
  }

  void NCC::predict(const gslapi::vector& input, 
                    statistics::Score& score, 
                    gslapi::vector& prediction) 
  {
    prediction=gslapi::vector(classes_.size());   
    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;
    statistics::AveragerPairWeighted ap;
    for(size_t j=0; j<centroids_.columns(); j++) {
      ap.add(input,gslapi::vector(centroids_,j,false),w, w);
      prediction(j)=ap.correlation();
      ap.reset();
    }
  }

  
  // 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