source: branches/peters_vector/lib/statistics/ROC.cc @ 469

// $Id: ROC.cc 469 2005-12-19 14:58:29Z peter $

#include <c++_tools/statistics/ROC.h>

#include <c++_tools/utility/stl_utility.h>
#include <c++_tools/classifier/VectorAbstract.h>

#include <gsl/gsl_cdf.h>

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


namespace theplu {
  class classifier::VectorAbstract;
namespace statistics {  

  ROC::ROC(bool b) 
    : Score(b), area_(0.5), minimum_size_(10), nof_pos_(0)  
  {
  }

  double ROC::get_p_approx(const double area) const
  {
    double x = area - 0.5;
    // Not integrating from the middle of the bin, but from the inner edge.
    if (x>0)
      x -= 0.5/nof_pos_/(n()-nof_pos_);
    else if(x<0)
      x += 0.5/nof_pos_/(n()-nof_pos_);

    double sigma = (std::sqrt( (n()-nof_pos_)*nof_pos_*
                               (n()+1.0)/12 ) /
                    ( n() - nof_pos_ ) / nof_pos_ );
    double p = gsl_cdf_gaussian_Q(x, sigma);
    
    return p;
  }

  double ROC::get_p_exact(const double block, const double nof_pos, 
                          const double nof_neg) const
  {
    double p;
    if (block <= 0.0)
      p = 1.0;
    else if (block > nof_neg*nof_pos)
      p = 0.0;
    else {
      double p1 = get_p_exact(block-nof_neg, nof_pos-1, nof_neg);
      double p2 = get_p_exact(block, nof_pos, nof_neg-1);
      p = nof_pos/(nof_pos+nof_neg)*p1 + nof_neg/(nof_pos+nof_neg)*p2;
    }
    return p;
  }

  double ROC::p_value(void) const
  {
    if (weighted_)
      return 1.0;
    else if (nof_pos_ < minimum_size_ & n()-nof_pos_ < minimum_size_)
      return get_p_exact(area_*nof_pos_*(n()-nof_pos_), 
                          nof_pos_, n()-nof_pos_);
    else
      return get_p_approx(area_);
   
  }

  double ROC::score(const classifier::Target& target, 
                    const classifier::VectorAbstract& value)
  {
    weighted_=false;

    vec_pair_.clear();
    vec_pair_.reserve(target.size());
    for (unsigned int i=0; i<target.size(); i++)
      vec_pair_.push_back(std::make_pair(target(i),value(i)));
    std::sort(vec_pair_.begin(),vec_pair_.end(),
              utility::pair_value_compare<int, double>());

    area_ = 0;
    nof_pos_=0;
    for (size_t i=0; i<n(); i++){
      if (class_one(target(i))){
        area_+=i;
        nof_pos_++;
      }
    }

    // Normalizing the area to [0,1]
    area_ = ( (area_-nof_pos_*(nof_pos_-1)/2 ) /
              (nof_pos_*(n()-nof_pos_)) );
    
    //Returning score larger 0.5 that you get by random
    if (area_<0.5 && absolute_)
      area_=1.0-area_;
    
    return area_;
  }

  double ROC::score(const classifier::Target& target, 
                    const classifier::VectorAbstract& value, 
                    const classifier::VectorAbstract& weight)
  {
    weighted_=true;

    vec_pair_.clear();
    vec_pair_.reserve(target.size());
    for (unsigned int i=0; i<target.size(); i++)
      vec_pair_.push_back(std::make_pair(target(i),value(i)));
    std::sort(vec_pair_.begin(),vec_pair_.end(),
              utility::pair_value_compare<int, double>());

    area_=0;
    nof_pos_=0;
    double max_area=0;

    for (size_t i=0; i<n(); i++){
      if (class_one(target(i))){
        for (size_t j=0; j<n(); j++){
          if (!class_one(target(j))){
            if (value(i) > value(j)){
              area_+=weight(i)*weight(j);
            }
            max_area+=weight(i)*weight(j);
          }
        }
      }
    }
    area_/=max_area;
    
    if (area_<0.5 && absolute_)
      area_=1.0-area_;
    
    return area_;
  }

  int ROC::target(const size_t i) const
  {
    return vec_pair_[i].first;
  }

  std::ostream& operator<<(std::ostream& s, const ROC& r)
  {
    s.setf( std::ios::dec );
    s.precision(12);
    double sens = 1;
    double spec = 0;
    size_t n = r.n();
    double nof_pos = r.n_pos();
    for(size_t i=0; i<n-1; ++i) {
      s << sens << "\t";
      s << spec << "\n";
      if (r.class_one(r.target(i)))
        spec -= 1/(n-nof_pos);
      else 
        sens -= 1/nof_pos;
    }
    s << sens << "\t";
    s << spec ;
    return s;
  }


}} // of namespace statistics and namespace theplu