Changeset 704 for trunk/yat/classifier


Ignore:
Timestamp:
Dec 18, 2006, 5:01:41 PM (15 years ago)
Author:
Markus Ringnér
Message:

Fixes #104. Also fixed inline bug in Averager.h

Location:
trunk/yat/classifier
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/yat/classifier/EnsembleBuilder.cc

    r680 r704  
    4848  void EnsembleBuilder::build(void)
    4949  {
    50     subset_.reset();
    51     while(subset_.more()) {
     50    for(u_long i=0; i<subset_.size();++i) {
    5251      SupervisedClassifier* classifier=
    53         mother_.make_classifier(subset_.training_data(),
    54                                 subset_.training_target());
     52        mother_.make_classifier(subset_.training_data(i),
     53                                subset_.training_target(i));
    5554      classifier->train();
    5655      classifier_.push_back(classifier);
    57       subset_.next();
    5856    }   
    5957  }
     
    6361   std::vector<std::vector<statistics::Averager> >& result)
    6462  {
    65     subset_.reset();
    66 
    6763    result.clear();
    6864    result.reserve(subset_.target().nof_classes());   
     
    7066      result.push_back(std::vector<statistics::Averager>(data.columns()));
    7167   
    72     size_t k=0;
    7368    utility::matrix prediction; 
    7469    try {
    7570      const KernelLookup& kernel = dynamic_cast<const KernelLookup&>(data);
    76       while(subset_.more()) {
    77         KernelLookup kernel_peter(kernel,subset_.training_index(),true);
    78         classifier(k++).predict(kernel_peter,prediction);
     71      for(u_long k=0;k<subset_.size();k++) {
     72        KernelLookup kernel_peter(kernel,subset_.training_index(k),true);
     73        classifier(k).predict(kernel_peter,prediction);
    7974
    8075        for(size_t i=0; i<prediction.rows();i++)
    8176          for(size_t j=0; j<prediction.columns();j++)
    8277            result[i][j].add(prediction(i,j));
    83         subset_.next();
    8478      }
    8579    }
    8680    catch (std::bad_cast) {
    87       while(subset_.more()) {
    88         classifier(k++).predict(data,prediction);
     81      for(u_long k=0;k<subset_.size();k++) {
     82        classifier(k).predict(data,prediction);
    8983        for(size_t i=0; i<prediction.rows();i++)
    9084          for(size_t j=0; j<prediction.columns();j++)
    9185            result[i][j].add(prediction(i,j));
    9286       
    93         subset_.next();
    9487      }
    9588    }
     
    10194  EnsembleBuilder::validate(void)
    10295  {
    103     subset_.reset();
    10496    validation_result_.clear();
    10597
     
    108100      validation_result_.push_back(std::vector<statistics::Averager>(subset_.target().size()));
    109101   
    110     size_t k=0;
    111102    utility::matrix prediction; 
    112     while(subset_.more()) {
    113       classifier(k++).predict(subset_.validation_data(),prediction);
     103    for(u_long k=0;k<subset_.size();k++) {
     104      classifier(k).predict(subset_.validation_data(k),prediction);
    114105
    115106      for(size_t i=0; i<prediction.rows();i++)
    116107        for(size_t j=0; j<prediction.columns();j++) {
    117           validation_result_[i][subset_.validation_index()[j]].
     108          validation_result_[i][subset_.validation_index(k)[j]].
    118109            add(prediction(i,j));
    119         }
    120          
    121       subset_.next();
     110        }           
    122111    }
    123112    return validation_result_;
  • trunk/yat/classifier/SubsetGenerator.cc

    r680 r704  
    4242  SubsetGenerator::SubsetGenerator(const Sampler& sampler,
    4343                                   const DataLookup2D& data)
    44     : f_selector_(NULL), sampler_(sampler), state_(0), weighted_(false)
     44    : f_selector_(NULL), sampler_(sampler), weighted_(false)
    4545  {
    4646    assert(target().size()==data.columns());
     
    8080                                   const DataLookup2D& data,
    8181                                   FeatureSelector& fs)
    82     : f_selector_(&fs), sampler_(sampler), state_(0), weighted_(false)
     82    : f_selector_(&fs), sampler_(sampler), weighted_(false)
    8383  {
    8484    assert(target().size()==data.columns());
     
    9292    const MatrixLookup* ml = dynamic_cast<const MatrixLookup*>(&data);
    9393    if (ml){
    94       for (reset(); more(); next()){
     94      for (size_t k=0; k<size(); k++){
    9595     
    96         training_target_.push_back(Target(target(),training_index()));
    97         validation_target_.push_back(Target(target(),validation_index()));
     96        training_target_.push_back(Target(target(),training_index(k)));
     97        validation_target_.push_back(Target(target(),validation_index(k)));
    9898        // training data with no feature selection
    9999        const MatrixLookup* train_data_all_feat =
    100           ml->training_data(training_index());
     100          ml->training_data(training_index(k));
    101101        // use these data to create feature selection
    102102        assert(train_data_all_feat);
    103         f_selector_->update(*train_data_all_feat, training_target());
     103        f_selector_->update(*train_data_all_feat, training_target(k));
    104104        // get features
    105105        features_.push_back(f_selector_->features());
     
    109109        // Dynamically allocated. Must be deleted in destructor.
    110110        training_data_.push_back(new MatrixLookup(*ml,features_.back(),
    111                                                   training_index()));
     111                                                  training_index(k)));
    112112        validation_data_.push_back(new MatrixLookup(*ml,features_.back(),
    113                                                     validation_index()));     
     113                                                    validation_index(k)));     
    114114      }
    115115    }
     
    118118      const MatrixLookupWeighted* ml =
    119119        dynamic_cast<const MatrixLookupWeighted*>(&data);
    120       if (ml){
    121         for (reset(); more(); next()){
    122      
    123           training_target_.push_back(Target(target(),training_index()));
    124           validation_target_.push_back(Target(target(),validation_index()));
     120      if (ml){       
     121        for (u_long k=0; k<size(); k++){
     122          training_target_.push_back(Target(target(),training_index(k)));
     123          validation_target_.push_back(Target(target(),validation_index(k)));
    125124          // training data with no feature selection
    126125          const MatrixLookupWeighted* train_data_all_feat =
    127             ml->training_data(training_index());
     126            ml->training_data(training_index(k));
    128127          // use these data to create feature selection
    129           f_selector_->update(*train_data_all_feat, training_target());
     128          f_selector_->update(*train_data_all_feat, training_target(k));
    130129          // get features
    131130          features_.push_back(f_selector_->features());
     
    135134          training_data_.push_back(new MatrixLookupWeighted(*ml,
    136135                                                            features_.back(),
    137                                                             training_index()
     136                                                            training_index(k)
    138137                                                            ));
    139138          validation_data_.push_back(new MatrixLookupWeighted(*ml,
    140139                                                              features_.back(),
    141                                                               validation_index()
     140                                                              validation_index(k)
    142141                                                              ));     
    143142        }
     
    147146        const KernelLookup* kernel = dynamic_cast<const KernelLookup*>(&data);
    148147        if (kernel){
    149           for (reset(); more(); next()){
    150             training_target_.push_back(Target(target(),training_index()));
    151             validation_target_.push_back(Target(target(),validation_index()));
     148          for (u_long k=0; k<size(); k++){
     149            training_target_.push_back(Target(target(),training_index(k)));
     150            validation_target_.push_back(Target(target(),validation_index(k)));
    152151            const DataLookup2D* matrix = kernel->data();
    153152            // dynamically allocated must be deleted
    154153            const DataLookup2D* training_matrix =
    155               matrix->training_data(training_index());
     154              matrix->training_data(training_index(k));
    156155            if (matrix->weighted()){
    157156              const MatrixLookupWeighted& ml =
    158157                dynamic_cast<const MatrixLookupWeighted&>(*matrix);
    159               f_selector_->update(MatrixLookupWeighted(ml,training_index(),false),
    160                                   training_target());
     158              f_selector_->update(MatrixLookupWeighted(ml,training_index(k),false),
     159                                  training_target(k));
    161160            }
    162161            else {
    163162              const MatrixLookup& ml =
    164163                dynamic_cast<const MatrixLookup&>(*matrix);
    165               f_selector_->update(MatrixLookup(ml,training_index(), false),
    166                                   training_target());
     164              f_selector_->update(MatrixLookup(ml,training_index(k), false),
     165                                  training_target(k));
    167166            }
    168167            std::vector<size_t> dummie=f_selector_->features();
     
    175174                     
    176175            // Dynamically allocated. Must be deleted in destructor.
    177             training_data_.push_back(kl->training_data(training_index()));
    178             validation_data_.push_back(kl->validation_data(training_index(),
    179                                                            validation_index()));
     176            training_data_.push_back(kl->training_data(training_index(k)));
     177            validation_data_.push_back(kl->validation_data(training_index(k),
     178                                                           validation_index(k)));
    180179            assert(kl);
    181180            delete kl;
     
    194193    assert(validation_data_.size()==size());
    195194    assert(validation_target_.size()==size());
    196     reset();
    197195  }
    198196
  • trunk/yat/classifier/SubsetGenerator.h

    r680 r704  
    6868    ///
    6969    ~SubsetGenerator();
    70 
    71     ///
    72     /// @return true if in a valid state
    73     ///
    74     inline bool more(void) const { return state_<size(); }
    75 
    76     ///
    77     /// Function turning the object to the next state.
    78     ///
    79     inline void next(void) { state_++; }
    80 
    81     ///
    82     /// rewind object to initial state
    83     ///
    84     inline void reset(void) { state_=0; }
    8570 
    8671    ///
     
    10489    /// @return training data
    10590    ///
    106     inline const DataLookup2D& training_data(void) const
    107     { return *(training_data_[state_]); }
     91    inline const DataLookup2D& training_data(std::vector<DataLookup2D*>::
     92                                             size_type i) const
     93    { return *(training_data_[i]); }
    10894
    10995    ///
    11096    /// @return training features
    11197    ///
    112     inline const std::vector<size_t>& training_features(void) const
    113     { return f_selector_ ? features_[state_] : features_[0]; }
     98    inline const std::vector<size_t>& training_features(std::vector<size_t>::
     99                                                        size_type i) const
     100    { return f_selector_ ? features_[i] : features_[0]; }
    114101
    115102
     
    117104    /// @return training index
    118105    ///
    119     inline const std::vector<size_t>& training_index(void) const
    120     { return sampler_.training_index(state_); }
     106    inline const std::vector<size_t>& training_index(std::vector<size_t>::
     107                                                     size_type i) const
     108    { return sampler_.training_index(i); }
    121109
    122110    ///
    123111    /// @return training target
    124112    ///
    125     inline const Target& training_target(void) const
    126     { return training_target_[state_]; }
     113    inline const Target& training_target(std::vector<Target>::
     114                                         size_type i) const
     115    { return training_target_[i]; }
    127116
    128117    ///
    129118    /// @return validation data
    130119    ///
    131     inline const DataLookup2D& validation_data(void) const
    132     { return *(validation_data_[state_]); }
     120    inline const DataLookup2D& validation_data(std::vector<DataLookup2D*>::
     121                                               size_type i) const
     122    { return *(validation_data_[i]); }
    133123
    134124    ///
    135125    /// @return validation index
    136126    ///
    137     inline const std::vector<size_t>& validation_index(void) const
    138     { return sampler_.validation_index(state_); }
     127    inline const std::vector<size_t>& validation_index(std::vector<size_t>::
     128                                                       size_type i) const
     129    { return sampler_.validation_index(i); }
    139130
    140131    ///
    141132    /// @return validation target
    142133    ///
    143     inline const Target& validation_target(void) const
    144     { return validation_target_[state_]; }
     134    inline const Target& validation_target(std::vector<Target>::
     135                                           size_type i) const
     136    { return validation_target_[i]; }
    145137
    146138    ///
     
    156148    std::vector<std::vector<size_t> > features_;
    157149    const Sampler& sampler_;
    158     size_t state_;
    159150    std::vector<const DataLookup2D*> training_data_;
    160151    std::vector<Target> training_target_;
Note: See TracChangeset for help on using the changeset viewer.