Changeset 509


Ignore:
Timestamp:
Feb 18, 2006, 2:47:32 PM (16 years ago)
Author:
Peter
Message:

added test for target
redesign crossSplitter
added two class function in Target

Location:
trunk
Files:
1 added
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/lib/classifier/CrossSplitter.cc

    r505 r509  
    77#include <c++_tools/random/random.h>
    88
     9#include <algorithm>
     10#include <cassert>
     11#include <utility>
    912#include <vector>
    1013
     
    1619    : k_(k), state_(0), target_(target)
    1720  {
    18     std::vector<size_t> index_pos;
    19     std::vector<size_t> index_neg;
    20 
    21     for (size_t i=0; i<target.size(); i++){
    22       if (target(i)==1)
    23         index_pos.push_back(i);
    24       else
    25         index_neg.push_back(i);
    26     }
    27 
    28     std::vector<size_t> part_pos(index_pos.size()); // [0,k-1]
    29     for (size_t i=0; i<part_pos.size(); i++)
    30       part_pos[i] = int(i*k/part_pos.size());
    31 
    32     std::vector<size_t> part_neg(index_neg.size()); // [0,k-1]
    33     for (size_t i=0; i<part_pos.size(); i++)
    34       part_neg[i] = int(i*k/part_neg.size());
     21    assert(target.size()>1);
     22    std::vector<std::pair<size_t,size_t> > v;
     23    for (size_t i=0; i<target.size(); i++)
     24      v.push_back(std::make_pair(target(i),i));
     25    // sorting with respect to class
     26    std::sort(v.begin(),v.end());
     27   
     28    // my_begin[i] is index of first sample of class i
     29    std::vector<size_t> my_begin;
     30    my_begin.reserve(target.nof_classes());
     31    my_begin.push_back(0);
     32    for (size_t i=1; i<target.size(); i++)
     33      while (v[i].first > my_begin.size()-1)
     34        my_begin.push_back(i);
     35    my_begin.push_back(target.size());
    3536
    3637    random::DiscreteUniform rnd;
    3738
     39    for (size_t i=0; i<N; ) {
    3840
    39     for (size_t i=0; i<N; ) {
    40       random_shuffle(index_neg.begin(), index_neg.end(), rnd);
    41       random_shuffle(index_pos.begin(), index_pos.end(), rnd);
     41      // shuffle indices within class each class
     42      for (size_t j=0; j<target.nof_classes(); j++)
     43        random_shuffle(v.begin()+my_begin[j],v.begin()+my_begin[j+1],rnd);
    4244     
    43       std::vector<size_t> training_index;
    44       std::vector<size_t> validation_index;
    45 
    4645      for (size_t part=0; part<k && i<N; i++, part++) {
    4746       
    48         training_index.clear();
    49         training_index.clear();
    50         for (size_t j=0; j<index_neg.size(); j++) {
    51           if (part_neg[j]==part)
    52             validation_index.push_back(index_neg[j]);
     47        std::vector<size_t> training_index;
     48        std::vector<size_t> validation_index;
     49
     50        for (size_t j=0; j<v.size(); j++) {
     51          if (j%k==part)
     52            validation_index.push_back(v[j].second);
    5353          else
    54             training_index.push_back(index_neg[j]);
    55         }
    56         for (size_t j=0; j<index_pos.size(); j++) {
    57           if (part_pos[j]==part)
    58             validation_index.push_back(index_pos[j]);
    59           else
    60             training_index.push_back(index_pos[j]);
     54            training_index.push_back(v[j].second);
    6155        }
    6256
     
    6559        validation_data_.push_back(data.validation_data(training_index,
    6660                                                        validation_index));
    67        
     61
    6862        training_target_.push_back(Target(target,training_index));
    6963        validation_target_.push_back(Target(target,validation_index));
    70        
    7164        training_index_.push_back(training_index);
    7265        validation_index_.push_back(validation_index);
     66
    7367      }
    7468    }
    75    
     69    assert(training_data_.size()==N);
     70    assert(training_target_.size()==N);
     71    assert(training_index_.size()==N);
     72    assert(validation_data_.size()==N);
     73    assert(validation_target_.size()==N);
     74    assert(validation_index_.size()==N);
    7675  }
    7776
    7877  CrossSplitter::~CrossSplitter()
    7978  {
     79    assert(training_data_.size()==validation_data_.size());
    8080    for (size_t i=0; i<training_data_.size(); i++)
    8181      delete training_data_[i];
  • trunk/lib/classifier/CrossSplitter.h

    r505 r509  
    119119    const size_t k_;
    120120    u_long state_;
    121     const Target& target_;
     121    Target target_;
    122122   
    123123    std::vector<const DataLookup2D*> training_data_;
  • trunk/lib/classifier/EnsembleBuilder.cc

    r505 r509  
    4545    validation_result_.clear();
    4646
    47     validation_result_.reserve(cross_splitter_.target().classes());   
    48     for(size_t i=0; i<cross_splitter_.target().classes();i++)
     47    validation_result_.reserve(cross_splitter_.target().nof_classes());   
     48    for(size_t i=0; i<cross_splitter_.target().nof_classes();i++)
    4949      validation_result_.push_back(std::vector<statistics::Averager>(cross_splitter_.target().size()));
    5050   
  • trunk/lib/classifier/NCC.cc

    r505 r509  
    3636  {
    3737    // Calculate the centroids for each class
    38     centroids_=gslapi::matrix(matrix_.rows(),target_.classes());
    39     gslapi::matrix nof_in_class(matrix_.rows(),target_.classes());
     38    centroids_=gslapi::matrix(matrix_.rows(),target_.nof_classes());
     39    gslapi::matrix nof_in_class(matrix_.rows(),target_.nof_classes());
    4040    for(size_t i=0; i<matrix_.rows(); i++) {
    4141      for(size_t j=0; j<matrix_.columns(); j++) {
    4242        if(!std::isnan(matrix_(i,j))) {
    43           centroids_(i,target_.classes(target_(j))) += matrix_(i,j);
    44           nof_in_class(i,target_.classes(target_(j)))++;
     43          centroids_(i,target_(j)) += matrix_(i,j);
     44          nof_in_class(i,target_(j))++;
    4545        }
    4646      }
  • trunk/lib/classifier/SVM.cc

    r493 r509  
    11// $Id$
    2 
    32
    43#include <c++_tools/classifier/SVM.h>
     
    171170      E(i)=0;
    172171      for (size_t j=0; j<E.size(); j++)
    173         E(i) += kernel_mod(i,j)*target_(j)*alpha_(j);
    174       E(i)=E(i)-target_(i);
     172        E(i) += kernel_mod(i,j)*target(j)*alpha_(j);
     173      E(i)=E(i)-target(i);
    175174    }
    176175    assert(target_.size()==E.size());
     
    194193
    195194      alpha_new2 = ( alpha_(sample_.value_second()) +
    196                      target_(sample_.value_second())*
     195                     target(sample_.value_second())*
    197196                     ( E(sample_.value_first())-E(sample_.value_second()) )/k );
    198197     
     
    214213     
    215214      alpha_new1 = (alpha_(sample_.value_first()) +
    216                     (target_(sample_.value_first()) *
    217                      target_(sample_.value_second()) *
     215                    (target(sample_.value_first()) *
     216                     target(sample_.value_second()) *
    218217                     (alpha_(sample_.value_second()) - alpha_new2) ));
    219218           
     
    232231      for (size_t i=0; i<E.size(); i++) {
    233232        E(i)+=( kernel_mod(i,sample_.value_first())*
    234                 target_(sample_.value_first()) *
     233                target(sample_.value_first()) *
    235234                (alpha_new1-alpha_old1) );
    236235        E(i)+=( kernel_mod(i,sample_.value_second())*
    237                 target_(sample_.value_second()) *
     236                target(sample_.value_second()) *
    238237                (alpha_new2-alpha_old2) );
    239238      }
     
    288287      for (size_t i=sample_.nof_sv(); i<sample_.n();i++){
    289288        //std::cout << "nr: " << i << std::endl;
    290         if (target_(sample_(i))==1){
     289        if (target_.one(sample_(i))){
    291290          if(E(sample_(i)) < E(sample_.value_first()) - 2*tolerance_){
    292291            sample_.update_second(i);
     
    306305    else{
    307306      for (size_t i=0; i<sample_.n(); i++) {
    308         if (target_(sample_(i))==1){
     307        if (target_.one(sample_(i))){
    309308          for (size_t j=0; j<sample_.n(); j++) {
    310             if ( target_(sample_(j))==-1 &&
     309            if ( !target_.one(sample_(j)) &&
    311310                 E(sample_(i)) < E(sample_(j))+2*tolerance_ ){
    312311              sample_.update_first(i);
     
    328327  void SVM::bounds( double& u, double& v) const
    329328  {
    330     if (target_(sample_.value_first())!=target_(sample_.value_second())) {
     329    if (target(sample_.value_first())!=target(sample_.value_second())) {
    331330      if (alpha_(sample_.value_second()) > alpha_(sample_.value_first())) {
    332331        v = std::numeric_limits<double>::max();
     
    361360      output_(i)=0;
    362361      for (size_t j=0; j<output_.size(); j++)
    363         output_(i)+=alpha_(j)*target_(j) * kernel_(i,j);
     362        output_(i)+=alpha_(j)*target(j) * kernel_(i,j);
    364363    }
    365364
     
    374373    bias_=0;
    375374    for (size_t i=0; i<sample_.nof_sv(); i++)
    376       bias_+= ( target_(sample_(i)) * (1-alpha_(sample_(i))*C_inverse_) -
     375      bias_+= ( target(sample_(i)) * (1-alpha_(sample_(i))*C_inverse_) -
    377376                output_(sample_(i)) );
    378377    bias_=bias_/sample_.nof_sv();
  • trunk/lib/classifier/SVM.h

    r505 r509  
    213213    { return i!=j ? (kernel_)(i,j) : (kernel_)(i,j) + C_inverse_; }
    214214   
     215    /// @return 1 if i belong to class one and -1 if i belong to rest
     216    inline int target(size_t i) const { return target_.one(i) ? 1 : -1; }
     217
    215218    gslapi::vector alpha_;
    216219    double bias_;
  • trunk/lib/classifier/Target.cc

    r507 r509  
    55#include <c++_tools/utility/utility.h>
    66
     7#include <cassert>
     8#include <iostream>
     9#include <map>
     10#include <string>
    711#include <sstream>
    812#include <utility>
    913#include <vector>
    10 #include <iostream>
    1114
    1215namespace theplu {
    1316namespace classifier {
    1417
    15   Target::Target(const std::vector<int>& vec)
    16     : vector_(vec)
     18  Target::Target(const std::vector<std::string>& label)
     19    : one_(0)
    1720  {
    18     init_classes();
     21    init(label);
    1922  }
    2023 
    2124  Target::Target(const Target& t,
    2225                 const std::vector<size_t>& index)
     26    : class_map_(t.class_map_), one_(t.one_)
    2327  {
    24     vector_.resize(index.size());
    25     for (size_t i=0; i<index.size(); i++)
    26       vector_[i]=t(index[i]);
    27     // Peter which of the two below do we want here?
    28     //    init_classes();
    29     classes_=t.classes_;
     28    classes_.resize(index.size());
     29    for (size_t i=0; i<index.size(); i++) {
     30      assert(index[i]<t.size());
     31      classes_[i]=t.classes_[index[i]];
     32    }
     33    labels_ = t.labels_;
    3034  }
    3135
     
    3438  Target::Target(std::istream& is, char sep)
    3539    throw (utility::IO_error,std::exception)
     40    : one_(0)
    3641  {
    37     // read the data file and store in stl vectors (dynamically
    38     // expandable)
    39     std::vector<std::vector<int> > data_matrix;
    40     u_int nof_columns=0;
    41     u_int nof_rows=0;
    42     std::string line;
    43     while(getline(is, line, '\n')) {
    44       // Empty lines
    45       if (!line.size())
    46           continue;
    47       nof_rows++;
     42    std::vector<std::string> vec;
     43    std::string word;
     44    bool ok=true;
     45    while(ok) {
     46      if(sep=='\0')
     47        ok=(is>>word);
     48      else
     49        ok=getline(is, word, sep);
     50
     51      // ignore empty words
     52      if (!word.size() || !ok )
     53        continue;
    4854     
    49       std::vector<int> v;
    50       std::string element;
    51       std::stringstream ss(line);
    52       bool ok=true;
    53       while(ok) {
    54         if(sep=='\0')
    55           ok=(ss>>element);
    56         else
    57           ok=getline(ss, element, sep);
    58         if(!ok)
    59           break;       
    60 
    61         if(utility::is_int(element)) {
    62           v.push_back(atoi(element.c_str()));
    63         }
    64         else if (!element.size() || utility::is_nan(element)) {
    65           v.push_back(std::numeric_limits<int>::quiet_NaN());
    66         }
    67         else {
    68           // Jari, this should be communicated with as an exception.
    69           // std::cerr << "Warning: '" << element
    70           //           << "' is not an integer." << std::endl;
    71         }
    72       }
    73       if(sep!='\0' && line[line.size()-1]==sep) // add NaN for final separator
    74           v.push_back(std::numeric_limits<int>::quiet_NaN());
    75       if (!nof_columns)
    76         nof_columns=v.size();
    77       else if (nof_rows && (nof_columns>1)) {
    78         std::ostringstream s;
    79         s << "Target::Target(std::istream&) data file error:\n"
    80           << "    File has inconsistent number of rows (" << nof_rows
    81           << ") and columns (" << nof_columns
    82           << ").\n    Expected a row or a column vector.";
    83         throw utility::IO_error(s.str());
    84       }
    85       else if (v.size()!=nof_columns) {
    86         std::ostringstream s;
    87         s << "Target::Target(std::istream&) data file error:\n"
    88           << "    Line " << nof_rows << " has " << v.size()
    89           << " columns; expected " << nof_columns << " column.";
    90         throw utility::IO_error(s.str());
    91       }
    92       data_matrix.push_back(v);
     55      vec.push_back(word);
    9356    }
    9457
    9558    // manipulate the state of the stream to be good
    9659    is.clear(std::ios::goodbit);
    97     // copy data into vector
    98     if (nof_rows==1)
    99       vector_=data_matrix[0];
    100     else{
    101       vector_.resize(nof_rows);
    102       for (size_t i=0; i<nof_rows; i++)
    103         vector_[i]=data_matrix[i][0];
    104     }
    10560
    106     init_classes();
     61    init(vec);
    10762  }
    10863 
     
    11166  }
    11267
    113   u_int Target::classes(int target) const
     68  void Target::init(const std::vector<std::string>& label)
    11469  {
    115     std::map<int,u_int>::const_iterator i = classes_.find(target);
    116     if(i==classes_.end()) {
    117       // Jari change to exception at some point
    118       std::cerr << "Looking for the class of a non-existant target value!";
    119       return 0;
    120     }     
    121     else
    122       return i->second;
     70    classes_.clear();
     71    classes_.reserve(label.size());
     72    class_map_.clear();
     73    labels_.clear();
     74
     75   
     76    for (size_t i=0; i<label.size(); i++) {
     77      std::map<std::string,size_t>::const_iterator iter =
     78        class_map_.lower_bound(label[i]);
     79
     80      // label in map
     81      if (iter != class_map_.end() &&
     82          !(class_map_.key_comp()(label[i],iter->first)) ){
     83
     84        classes_.push_back(iter->second);
     85      }
     86      // label not found in map
     87      else{
     88        classes_.push_back(class_map_.size());
     89        // Peter, should use iter to hint on position
     90        class_map_.insert(std::make_pair(label[i],classes_[i]));
     91        labels_.push_back(label[i]);
     92      }
     93    }
     94
    12395  }
    12496
    125   const Target& Target::operator*=(const int d)
    126   {
    127     for (size_t i=0; i<size(); i++)
    128       vector_[i]*=d;
    129     init_classes();
    130     return *this;
    131   }
    132 
    133   const Target& Target::operator=(const Target& other)
    134   {
    135     vector_=other.vector_;
    136     classes_=other.classes_;   
    137     return *this;
    138   }
    139 
    140   void Target::init_classes(void)
    141   {
    142     classes_.clear();
    143 
    144     std::vector<int> sorted_target=vector_;
    145     std::sort(sorted_target.begin(),sorted_target.end());
    146     std::vector<int>::iterator i = std::unique(sorted_target.begin(),
    147                                      sorted_target.end());
    148     sorted_target.erase(i, sorted_target.end());
    149 
    150     u_int nof_classes=0;
    151     for (size_t i=0; i<sorted_target.size(); i++) {
    152       std::pair<const int, u_int> p(sorted_target[i],nof_classes);
    153       std::pair<std::map<int,u_int>::iterator,bool>
    154         status=classes_.insert(p);
    155       if(status.second==true) {
    156         nof_classes++;
    157       }
    158     } 
    159   }
     97  //  const Target& Target::operator=(const Target& other)
     98  //{
     99  //  classes_=other.classes_;   
     100  //  class_map_=other.class_map_;   
     101  //  labels_=other.labels_;
     102  //  return *this;
     103  //}
    160104
    161105  std::ostream& operator<<(std::ostream& s, const Target& a)
  • trunk/lib/classifier/Target.h

    r507 r509  
    66#include <c++_tools/utility/Exception.h>
    77
    8 #include <algorithm>
     8#include <cassert>
    99#include <map>
     10#include <string>
    1011#include <vector>
    1112
     
    2324  public:
    2425    ///
    25     /// Default constructor
     26    /// @brief Constructor creating target with @a labels
    2627    ///
    27     inline Target(const size_t n=0,const int init_value=0)
    28       : vector_(std::vector<int>(n,init_value)) {init_classes();}
     28    Target(const std::vector<std::string>& labels);
    2929
    3030    ///
    31     /// Constructor
    32     ///
    33     Target(const std::vector<int>&);
    34 
    35     ///
    36     /// The istream constructor.
     31    /// @brief istream constructor.
    3732    ///
    3833    Target(std::istream&, char sep='\0')
     
    4035
    4136    ///
    42     /// Copy Constructor
     37    /// @brief Copy Constructor
    4338    ///
    44     inline Target(const Target& other)
    45     { vector_=other.vector_; classes_=other.classes_; }
     39    //inline Target(const Target& other)
     40    //  : classes_(other.classes_), class_map_(other.class_map_),
     41    //    labels_(other.labels_) {}
    4642
    4743    ///
    48     /// Constructor taking the index vector as input.
    49     ///
    50     Target(const Target&, const std::vector<size_t>&);
     44    /// Constructor creating a sub-Target from Target @a org. @a vec
     45    /// defines which indices to use.
     46    ///
     47    /// @note class is preserved, i.e., operator() returns the same
     48    /// for the Target as the original Target.
     49    ///
     50    Target(const Target& org, const std::vector<size_t>& vec);
    5151
    5252    ///
    53     /// Destructor
     53    /// @brief Destructor
    5454    ///
    5555    ~Target();
    5656
    5757    ///
     58    /// @return a map with label as key and class as value.
     59    ///
     60    inline const std::map<std::string,size_t>& classes(void) const
     61    { return class_map_; }
     62   
     63    ///
     64    /// This function is equivalent to Target::classes().size()
     65    ///
    5866    /// @return number of classes
    5967    ///
    60     inline size_t classes(void) const { return classes_.size(); }
     68    inline const size_t nof_classes(void) const { return classes().size(); }
     69
     70    ///
     71    /// @return true if class of sample @a i is equal to variable one
     72    ///
     73    /// @see set_one(const size_t one)
     74    ///
     75    inline bool one(const size_t i) const
     76    { assert(i<size()); return classes_[i]==one_; }
    6177   
    6278    ///
    63     /// @return the class of a target value
     79    /// Function to set variable one. This variable is used in 2-class
     80    /// algorithm in rder to use the Targer object in a one-versus-all
     81    /// manner.
    6482    ///
    65     u_int classes(int target) const;
    66    
    67    
     83    /// @see one(const size_t i)
    6884    ///
    69     /// @return size
    70     ///
    71     inline size_t size(void) const { return vector_.size(); }
     85    inline void set_one(const size_t one) { assert(one<size()); one_=one; }
    7286
    7387    ///
    74     /// @brief sort
     88    /// @return number of samples
    7589    ///
    76     inline void sort(void) { std::sort(vector_.begin(), vector_.end()); }
     90    inline size_t size(void) const { return classes_.size(); }
    7791
    78     inline const int& operator()(const size_t i) const { return vector_[i]; }
     92    ///
     93    /// @return number of samples with label @a label
     94    ///
     95    const size_t size(const std::string& label) const;
    7996
    80     inline int& operator()(const size_t i)  { return vector_[i]; }
     97    //
     98    //@brief sort
     99    //
     100    //inline void sort(void) { std::sort(classes_.begin(), classes_.end()); }
    81101
    82     const Target& operator*=(const int d);
     102    ///
     103    /// @return the class of @a sample
     104    ///
     105    inline size_t operator()(const size_t sample) const
     106    { assert(sample<size()); return classes_[sample]; }
    83107
    84     const Target& operator=(const Target& other);
     108    ///
     109    /// @brief assignment operator
     110    ///
     111    //const Target& operator=(const Target& other);
    85112
    86113  private:
    87     std::vector<int> vector_;
    88     std::map<int,u_int> classes_;       
     114    std::vector<size_t> classes_; // class of sample i
     115    std::map<std::string,size_t> class_map_; 
     116    std::vector<std::string> labels_; // label of class i
     117    size_t one_;
    89118   
    90     void init_classes(void);
     119    void init(const std::vector<std::string>&);
    91120
    92121  }; 
  • trunk/lib/statistics/Fisher.cc

    r488 r509  
    116116    a_=b_=c_=d_=0;
    117117    for (size_t i=0; i<target.size(); i++)
    118       if (class_one(target(i)))
     118      if (target.one(i))
    119119        if (value(i)>value_cutoff_)
    120120          a_++;
     
    143143    a_=b_=c_=d_=0;
    144144    for (size_t i=0; i<target.size(); i++)
    145       if (class_one(target(i)))
     145      if (target.one(i))
    146146        if (value(i)>value_cutoff_)
    147147          a_+=weight(i);
  • trunk/lib/statistics/FoldChange.cc

    r475 r509  
    3939
    4040    for (size_t i=0; i<value.size(); i++)
    41       if (class_one(target(i)))
     41      if (target.one(i))
    4242        pos.add(value(i));
    4343      else
     
    5858
    5959    for (size_t i=0; i<value.size(); i++)
    60       if (class_one(target(i)))
     60      if (target.one(i))
    6161        pos.add(value(i),weight(i));
    6262      else
  • trunk/lib/statistics/Pearson.cc

    r475 r509  
    4646    AveragerPair ap;
    4747    for (size_t i=0; i<target.size(); i++){
    48       if (class_one(target(i)))
     48      if (target.one(i))
    4949        ap.add(1, value(i));
    5050      else
     
    6666    AveragerPairWeighted ap;
    6767    for (size_t i=0; i<target.size(); i++){
    68       if (class_one(target(i)))
     68      if (target.one(i))
    6969        ap.add(1, value(i),1,weight(i));
    7070      else
  • trunk/lib/statistics/ROC.cc

    r488 r509  
    6969                    const gslapi::vector& value)
    7070  {
     71    assert(target.size()==value.size());
    7172    weighted_=false;
    7273
    7374    vec_pair_.clear();
    7475    vec_pair_.reserve(target.size());
    75     for (unsigned int i=0; i<target.size(); i++){
    76       int target_tmp = target(i);
    77       double value_tmp = value(i);
    78       vec_pair_.push_back(std::make_pair(target_tmp,value_tmp));
    79       //      vec_pair_.push_back(std::make_pair(target(i),value(i)));
    80     }
     76    for (size_t i=0; i<target.size(); i++)
     77      vec_pair_.push_back(std::make_pair(target.one(i),value(i)));
     78
    8179    std::sort(vec_pair_.begin(),vec_pair_.end(),
    82               utility::pair_value_compare<int, double>());
    83 
    84 
     80              utility::pair_value_compare<bool, double>());
    8581    area_ = 0;
    8682    nof_pos_=0;
    8783    for (size_t i=0; i<n(); i++){
    88       if (class_one(vec_pair_[i].first)){
     84      if (vec_pair_[i].first){
    8985        area_+=i;
    9086        nof_pos_++;
     
    114110    for (unsigned int i=0; i<target.size(); i++)
    115111      if (weight(i))
    116         vec_pair_.push_back(std::make_pair(target(i),value(i)));
     112        vec_pair_.push_back(std::make_pair(target.one(i),value(i)));
    117113
    118114    std::sort(vec_pair_.begin(),vec_pair_.end(),
     
    124120
    125121    for (size_t i=0; i<n(); i++)
    126       if (class_one(target(i)))
     122      if (target.one(i))
    127123        for (size_t j=0; j<n(); j++)
    128           if (!class_one(target(j))){
     124          if (!target.one(j)){
    129125            if (value(i)>value(j))
    130126              area_+=weight(i)*weight(j);
     
    140136  }
    141137
    142   int ROC::target(const size_t i) const
     138  bool ROC::target(const size_t i) const
    143139  {
    144140    return vec_pair_[i].first;
     
    156152      s << sens << "\t";
    157153      s << spec << "\n";
    158       if (r.class_one(r.target(i)))
     154      if (r.target(i))
    159155        spec -= 1/(n-nof_pos);
    160156      else
  • trunk/lib/statistics/ROC.h

    r475 r509  
    7979    inline u_int& minimum_size(void){ return minimum_size_; } 
    8080
    81     int target(const size_t i) const;
     81    bool target(const size_t i) const;
    8282    inline size_t n(void) const { return vec_pair_.size(); }
    8383    inline size_t n_pos(void) const { return nof_pos_; }
     
    9494    u_int minimum_size_;
    9595    u_int nof_pos_;
    96     std::vector<std::pair<int, double> > vec_pair_;
     96    std::vector<std::pair<bool, double> > vec_pair_; // class-value-pair
    9797  };
    9898
  • trunk/lib/statistics/Score.cc

    r475 r509  
    77
    88  Score::Score(bool absolute)
    9     : absolute_(absolute), positive_label_(1)
     9    : absolute_(absolute)
    1010  {
    1111  }
  • trunk/lib/statistics/Score.h

    r475 r509  
    3535    ///
    3636    inline void absolute(bool absolute) {absolute_=absolute;}
    37 
    38     ///
    39     /// Targets with this label are considered to be in positive
    40     /// group. All others are considered to be in negative
    41     /// group. Default is 1.
    42     ///
    43     /// @return label for positive class
    44     ///
    45     inline int& positive_label(void) { return positive_label_; }
    4637
    4738    ///
     
    117108    { return score(target, gslapi::vector(value), gslapi::vector(weight)); }
    118109
    119     inline bool class_one(int i) const { return i==positive_label_; }
    120    
    121110  protected:
    122111    inline bool weighted(void) const { return weighted_; }
    123112
    124113    bool absolute_;
    125     int positive_label_;
    126114    bool weighted_;
    127115
  • trunk/lib/statistics/tScore.cc

    r501 r509  
    2727    dof_=target.size()-2;
    2828    for(size_t i=0; i<target.size(); i++){
    29       if (class_one(target(i)))
     29      if (target.one(i))
    3030        positive.add(value(i));
    3131      else
     
    5252    dof_=target.size()-2;
    5353    for(size_t i=0; i<target.size(); i++){
    54       if (class_one(target(i)))
     54      if (target.one(i))
    5555        positive.add(value(i),weight(i));
    5656      else
  • trunk/test/Makefile.am

    r507 r509  
    66  crossvalidation_test inputranker_test kernel_test matrix_test \
    77  ncc_test nni_test pca_test regression_test rnd_test score_test \
    8   statistics_test stl_utility_test svd_test svm_test vector_test
     8  statistics_test stl_utility_test svd_test svm_test target_test \
     9  vector_test
    910
    1011check_PROGRAMS = $(TESTS)
     
    3334svd_test_SOURCES = svd_test.cc
    3435svm_test_SOURCES = svm_test.cc
     36target_test_SOURCES = target_test.cc
    3537vector_test_SOURCES = vector_test.cc
  • trunk/test/crossvalidation_test.cc

    r482 r509  
    99#include <fstream>
    1010#include <iostream>
     11#include <string>
    1112#include <vector>
    1213
    1314int main(const int argc,const char* argv[])
    1415
    15 
    1616  using namespace theplu;
    1717
     
    2626  *error << "testing crosssplitter" << std::endl;
    2727  bool ok = true;
    28   classifier::Target target(10,1);
    29   for (size_t i=0; i<5; i++)
    30     target(i)=-1;
    3128
     29 
     30  std::vector<std::string> label(10,"default");
     31  label[2]=label[7]="white";
     32  label[4]=label[5]="black";
     33  label[6]=label[3]="green";
     34  label[8]=label[9]="red";
     35                 
     36  classifier::Target target(label);
    3237  gslapi::matrix raw_data(10,10);
    3338  classifier::MatrixLookup data(raw_data);
    3439  classifier::CrossSplitter cv(target,data,3,3);
    35 
     40 
     41  std::vector<size_t> sample_count(10,0);
     42  for (cv.reset(); cv.more(); cv.next()){
     43    std::vector<size_t> class_count(5,0);
     44    if (cv.training_index().size()+cv.validation_index().size()!=target.size()){
     45      ok = false;
     46      *error << "ERROR: size of training samples plus "
     47             << "size of validation samples is invalid." << std::endl;
     48    }
     49    if (cv.validation_index().size()!=3 && cv.validation_index().size()!=4){
     50      ok = false;
     51      *error << "ERROR: size of validation samples is invalid."
     52             << "expected size to be 3 or 4" << std::endl;
     53    }
     54    for (size_t i=0; i<cv.validation_index().size(); i++) {
     55      assert(cv.validation_index()[i]<sample_count.size());
     56      sample_count[cv.validation_index()[i]]++;
     57    }
     58    for (size_t i=0; i<cv.training_index().size(); i++) {
     59      class_count[target(cv.training_index()[i])]++;
     60    }
     61    for (size_t i=0; i<class_count.size(); i++)
     62      if (class_count[i]==0){
     63        ok = false;
     64        *error << "ERROR: class " << i << " was not in training set."
     65                  << " Expected at least one sample from each class."
     66                  << std::endl;
     67      }
     68  }
     69  for (size_t i=0; i<sample_count.size(); i++){
     70    if (sample_count[i]!=1){
     71      ok = false;
     72      *error << "ERROR: sample " << i << " was validated " << sample_count[i]
     73                << " times." << " Expected to be 1 time" << std::endl;
     74    }
     75  }
     76 
    3677  if (error!=&std::cerr)
    3778    delete error;
  • trunk/test/score_test.cc

    r475 r509  
    3232  *error << "testing ROC" << std::endl;
    3333  gslapi::vector value(31);
    34   classifier::Target target(31,-1);
    35   for (unsigned int i=0; i<16; i++)
    36     target(i) = 1;
    37   for (unsigned int i=0; i<value.size(); i++)
     34  std::vector<std::string> label(31,"negative");
     35  for (size_t i=0; i<16; i++)
     36    label[i] = "positive";
     37  classifier::Target target(label);
     38  for (size_t i=0; i<value.size(); i++)
    3839    value(i)=i;
    3940  statistics::ROC roc;
     
    4445    ok = false;
    4546  }
    46   target*=-1;
     47  target.set_one(1);
    4748  area = roc.score(target, value);
    4849  if (area!=1.0){
     
    8182  for (size_t i=0; i<data.rows(); i++){
    8283    gslapi::vector vec(data,i);
     84    if (vec.size()!=target2.size()){
     85      *error << "vec.size() is " << vec.size() << " and target2.size() is "
     86             << target2.size() << ". Should be equal." << std::endl;
     87      ok=false;
     88    }
    8389    area = roc.score(target2,vec);
    8490    if (area<correct_area(i)-tol || area>correct_area(i)+tol){
  • trunk/test/svm_test.cc

    r475 r509  
    3939  data2(0,2)=1;
    4040  data2(1,2)=0;
    41   classifier::Target target2(3);
    42   target2(0)=-1;
    43   target2(1)=1;
    44   target2(2)=1;
     41  std::vector<std::string> label;
     42  label.reserve(3);
     43  label.push_back("-1");
     44  label.push_back("1");
     45  label.push_back("1");
     46  classifier::Target target2(label);
    4547  classifier::KernelFunction* kf2 = new classifier::PolynomialKernelFunction();
    4648  classifier::Kernel_MEV kernel2(data2,*kf2);
     
    5355  *error << "training...";
    5456  classifier2.train();
    55   *error << " done." << std::endl;
     57  *error << " done!" << std::endl;
    5658
    5759  double tmp=0;
    5860  for (size_t i=0; i<target2.size(); i++)
    59     tmp += classifier2.alpha()(i)*target2(i);
    60  
     61    if (target2.one(i))
     62      tmp += classifier2.alpha()(i);
     63    else
     64      tmp -= classifier2.alpha()(i);
     65
    6166  if (tmp){
    62     *error << "condition not fullfilled" << std::endl;
     67    *error << "ERROR: found " << tmp << " expected zero" << std::endl;
    6368    return -1;
    6469  }
    6570
    66   if (classifier2.alpha()(1)!=2 || classifier2.alpha()(2)!=2){
     71  double tol=1e-6;
     72  if (fabs(classifier2.alpha()(1)-2)>tol ||
     73      fabs(classifier2.alpha()(2)-2)>tol){
    6774    *error << "wrong alpha" << std::endl;
    6875    *error << "alpha: " << classifier2.alpha() <<  std::endl;
     
    114121  for (unsigned int i=0; i<target.size(); i++){
    115122    if (output(i)*target(i) < 1){
    116       slack += 1 - output(i)*target(i);
     123      if (target.one(i))
     124        slack += 1 - output(i);
     125      else
     126        slack += 1 + output(i);
    117127    }
    118128  }
Note: See TracChangeset for help on using the changeset viewer.