source: trunk/yat/classifier/NCC.cc @ 857

// $Id$

/*
  Copyright (C) 2005 Markus Ringnér, Peter Johansson
  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
  Copyright (C) 2007 Jari Häkkinen

  This file is part of the yat library, http://lev.thep.lu.se/trac/yat

  The yat 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 2 of the
  License, or (at your option) any later version.

  The yat 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 program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "NCC.h"
#include "DataLookup1D.h"
#include "DataLookup2D.h"
#include "MatrixLookup.h"
#include "MatrixLookupWeighted.h"
#include "Target.h"
#include "yat/utility/matrix.h"
#include "yat/utility/vector.h"
#include "yat/statistics/Distance.h"
#include "yat/utility/stl_utility.h"

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

namespace theplu {
namespace yat {
namespace classifier {

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

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

  NCC::~NCC()   
  {
  }


  const utility::matrix& NCC::centroids(void) const
  {
    return centroids_;
  }

    const DataLookup2D& NCC::data(void) const
    {
    return data_;
    }

  SupervisedClassifier* 
  NCC::make_classifier(const DataLookup2D& data, const Target& target) const 
  {     
    NCC* ncc=0;
    if(data.weighted()) {
      ncc=new NCC(dynamic_cast<const MatrixLookupWeighted&>(data),
                  target,this->distance_);
    }
    else {
      ncc=new NCC(dynamic_cast<const MatrixLookup&>(data),
                  target,this->distance_);
    }
    return ncc;
  }


  bool NCC::train()
  {   
    centroids_.clone(utility::matrix(data_.rows(), target_.nof_classes()));
    utility::matrix nof_in_class(data_.rows(), target_.nof_classes());
    const MatrixLookupWeighted* weighted_data = 
      dynamic_cast<const MatrixLookupWeighted*>(&data_);
    bool weighted = weighted_data;

    for(size_t i=0; i<data_.rows(); i++) {
      for(size_t j=0; j<data_.columns(); j++) {
        centroids_(i,target_(j)) += data_(i,j);
        if (weighted)
          nof_in_class(i,target_(j))+= weighted_data->weight(i,j);
        else
          nof_in_class(i,target_(j))+=1.0;
      }
    }   
    centroids_.div(nof_in_class);
    trained_=true;
    return trained_;
  }


  void NCC::predict(const DataLookup1D& input, const utility::vector& weights,
                    utility::vector& prediction) const
  {
    prediction.clone(utility::vector(centroids_.columns()));

    utility::vector value(input.size(),0);
    for(size_t i=0; i<input.size(); i++)
      value(i)=input(i);
    
    // take care of nan's in centroids
    for(size_t j=0; j<centroids_.columns(); j++) {
      const utility::vector centroid(utility::vector(centroids_,j,false));
      utility::vector wc(centroid.size(),0);
      for(size_t i=0; i<centroid.size(); i++)  { 
        if(!std::isnan(centroid(i)))
          wc(i)=1.0;
      }
      prediction(j)=distance_(value,centroid,weights,wc);   
    }
  }


  void NCC::predict(const DataLookup2D& input,                    
                    utility::matrix& prediction) const
  {   
    prediction.clone(utility::matrix(centroids_.columns(), input.columns()));
    // weighted case
    const MatrixLookupWeighted* data =
      dynamic_cast<const MatrixLookupWeighted*>(&input);  
    if (data) {
      for(size_t j=0; j<input.columns();j++) {     
        DataLookup1D in(input,j,false);
        utility::vector weights(in.size(),0);
        for(size_t i=0; i<in.size();i++) 
          weights(i)=data->weight(i,j);
        utility::vector out;
        predict(in,weights,out);
        prediction.column(j,out);
      }
      return;
    }
    // non-weighted case
    const MatrixLookup* x = dynamic_cast<const MatrixLookup*>(&input);
    if (!x){
      std::string str;
      str = "Error in NCC::predict: DataLookup2D of unexpected class.";
      throw std::runtime_error(str);
    }
    for(size_t j=0; j<input.columns();j++) {     
      DataLookup1D in(input,j,false);
      utility::vector weights(in.size(),1.0);
      utility::vector out;
      predict(in,weights,out);
      prediction.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, yat, and theplu