source: trunk/c++_tools/classifier/ConsensusInputRanker.cc @ 667

// $Id$

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

#include <c++_tools/classifier/InputRanker.h>
#include <c++_tools/classifier/IRRetrieve.h>
#include <c++_tools/classifier/MatrixLookup.h>
#include <c++_tools/classifier/MatrixLookupWeighted.h>
#include <c++_tools/classifier/Sampler.h>
#include <c++_tools/classifier/Target.h>
#include <c++_tools/statistics/Score.h>
#include <c++_tools/statistics/utility.h>
#include <c++_tools/utility/stl_utility.h>

#include <cassert>
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
#include <cmath>

namespace theplu {
namespace classifier {  

  ConsensusInputRanker::ConsensusInputRanker(const IRRetrieve& retriever)
    : retriever_(retriever)
  {
  }


  ConsensusInputRanker::ConsensusInputRanker(const Sampler& sampler, 
                                             const MatrixLookup& data, 
                                             statistics::Score& score,
                                             const IRRetrieve& retriever)
    : retriever_(retriever)
  {
    assert(sampler.size());
    id_.resize(data.rows());
    rank_.resize(data.rows());
    for (size_t i=0; i<sampler.size(); ++i){
      input_rankers_.push_back(InputRanker(MatrixLookup(data,sampler.training_index(i), false), 
                                           sampler.training_target(i), 
                                           score));       
    }
    update();
  }

  ConsensusInputRanker::ConsensusInputRanker(const Sampler& sampler, 
                                             const MatrixLookupWeighted& data, 
                                             statistics::Score& score,
                                             const IRRetrieve& retriever)
    : retriever_(retriever)
  {
    assert(sampler.size());
    id_.resize(data.rows());
    rank_.resize(data.rows());
  
    for (size_t i=0; i<sampler.size(); ++i){
      input_rankers_.push_back(InputRanker(MatrixLookupWeighted(data,sampler.training_index(i), false), 
                                           sampler.training_target(i), 
                                           score));       
    }
    update();
  }

  void ConsensusInputRanker::update(void)
  {

    // Sorting with respect to median info (from retriever_)
    std::vector<std::pair<double,size_t> > medians(id_.size());
    for (size_t i=0; i<id_.size(); i++){ 
      std::vector<double> scores;
      scores.reserve(input_rankers_.size());
      for (size_t j=0; j<input_rankers_.size(); j++) {
        scores.push_back(retriever_(input_rankers_[j],i));
      }
      medians[i].first = statistics::median(scores);
      medians[i].second = i;
    }
    
    //sort medians and assign id_ and rank_
    sort(medians.begin(), medians.end(),
         std::greater<std::pair<double, size_t> >()); 
         
    for (size_t i=0; i<medians.size(); i++){
      id_[i]=medians[i].second;
      rank_[id_[i]]=i;
    }
  }


}} // of namespace classifier and namespace theplu