Changeset 621


Ignore:
Timestamp:
Sep 5, 2006, 2:21:13 AM (15 years ago)
Author:
Peter
Message:

fixes #108 SubsetGenerator? with featureselection is now supported for MatrixLookup? MatrixLookupWeighted?, and KernelLookup? built on a MatrixLookup? (not KernelLookup? built on two MatrixLookups? see #122)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/c++_tools/classifier/SubsetGenerator.cc

    r619 r621  
    55#include <c++_tools/classifier/DataLookup2D.h>
    66#include <c++_tools/classifier/FeatureSelector.h>
     7#include <c++_tools/classifier/KernelLookup.h>
    78#include <c++_tools/classifier/MatrixLookup.h>
     9#include <c++_tools/classifier/MatrixLookupWeighted.h>
    810#include <c++_tools/classifier/Target.h>
    911
     
    1113#include <cassert>
    1214#include <utility>
     15#include <typeinfo>
    1316#include <vector>
    1417
     
    119122    validation_weight_.reserve(size());
    120123
    121     for (reset(); more(); next()){
     124
     125    // Taking care of three different case.
     126    // We start with the case of MatrixLookup
     127    const MatrixLookup* ml = dynamic_cast<const MatrixLookup*>(&data);
     128    if (ml){
     129      for (reset(); more(); next()){
    122130     
    123       // training data with no feature selection
    124       const DataLookup2D* train_data_all_feat =
    125         data.training_data(training_index());
    126       // use these data to create feature selection
    127       f_selector_->update(*train_data_all_feat, training_target());
    128       // get features
    129       features_.push_back(f_selector_->features());
    130       delete train_data_all_feat;
    131 
    132       // Dynamically allocated. Must be deleted in destructor.
    133       training_data_.push_back(data.training_data(features_.back(),
    134                                                   training_index()));
    135       training_weight_.push_back
    136         (new MatrixLookup(training_data_.back()->rows(),
    137                           training_data_.back()->columns(),1));
    138       validation_data_.push_back(data.validation_data(features_.back(),
    139                                                       training_index(),
    140                                                       validation_index()));
    141       validation_weight_.push_back
    142         (new MatrixLookup(validation_data_.back()->rows(),
    143                           validation_data_.back()->columns(),1));
    144 
    145 
    146       training_target_.push_back(Target(target(),training_index()));
    147       validation_target_.push_back(Target(target(),validation_index()));
    148     }
    149 
     131        // training data with no feature selection
     132        const MatrixLookup* train_data_all_feat =
     133          ml->training_data(training_index());
     134        // use these data to create feature selection
     135        f_selector_->update(*train_data_all_feat, training_target());
     136        // get features
     137        features_.push_back(f_selector_->features());
     138        delete train_data_all_feat;
     139       
     140        // Dynamically allocated. Must be deleted in destructor.
     141        training_data_.push_back(ml->training_data(features_.back(),
     142                                                    training_index()));
     143        training_weight_.push_back
     144          (new MatrixLookup(training_data_.back()->rows(),
     145                            training_data_.back()->columns(),1));
     146        validation_data_.push_back(ml->validation_data(features_.back(),
     147                                                        training_index(),
     148                                                        validation_index()));
     149        validation_weight_.push_back
     150          (new MatrixLookup(validation_data_.back()->rows(),
     151                            validation_data_.back()->columns(),1));
     152       
     153
     154        training_target_.push_back(Target(target(),training_index()));
     155        validation_target_.push_back(Target(target(),validation_index()));
     156      }
     157    }
     158    else {
     159      // Second the case of MatrixLookupWeighted
     160      const MatrixLookupWeighted* ml =
     161        dynamic_cast<const MatrixLookupWeighted*>(&data);
     162      if (ml){
     163        for (reset(); more(); next()){
     164     
     165          // training data with no feature selection
     166          const MatrixLookupWeighted* train_data_all_feat =
     167            ml->training_data(training_index());
     168          // use these data to create feature selection
     169          f_selector_->update(*train_data_all_feat, training_target());
     170          // get features
     171          features_.push_back(f_selector_->features());
     172          delete train_data_all_feat;
     173         
     174          // Dynamically allocated. Must be deleted in destructor.
     175          training_data_.push_back(ml->training_data(features_.back(),
     176                                                     training_index()));
     177          training_weight_.push_back
     178            (new MatrixLookup(training_data_.back()->rows(),
     179                              training_data_.back()->columns(),1));
     180          validation_data_.push_back(ml->validation_data(features_.back(),
     181                                                         training_index(),
     182                                                         validation_index()));
     183          validation_weight_.push_back
     184            (new MatrixLookup(validation_data_.back()->rows(),
     185                              validation_data_.back()->columns(),1));
     186         
     187         
     188          training_target_.push_back(Target(target(),training_index()));
     189          validation_target_.push_back(Target(target(),validation_index()));
     190        }
     191      }
     192      else {
     193        // Third the case of MatrixLookupWeighted
     194        const KernelLookup* kernel =  dynamic_cast<const KernelLookup*>(&data);
     195        if (kernel){
     196          for (reset(); more(); next()){
     197            const KernelLookup* kl=NULL;
     198            if (kernel->weighted()){
     199              std::cerr << "Feature selection with weighted Kernel not "
     200                        << "implemented.\nPlease see http://lev.thep.lu."
     201                        << "se/trac/c++_tools/ticket/116\n";
     202              exit(-1);
     203            }
     204            else {
     205              const MatrixLookup* matrix = kernel->data();
     206              const MatrixLookup* training_matrix =
     207                matrix->training_data(training_index());
     208              f_selector_->update(*training_matrix, training_target());
     209              features_.push_back(f_selector_->features());
     210              kl = kernel->selected(features_.back());
     211              delete matrix;
     212              delete training_matrix;
     213            }
     214           
     215            // Dynamically allocated. Must be deleted in destructor.
     216            training_data_.push_back(kl->training_data(features_.back(),
     217                                                       training_index()));
     218            training_weight_.push_back
     219              (new MatrixLookup(training_data_.back()->rows(),
     220                                training_data_.back()->columns(),1));
     221            validation_data_.push_back(kl->validation_data(features_.back(),
     222                                                           training_index(),
     223                                                           validation_index()));
     224            validation_weight_.push_back
     225              (new MatrixLookup(validation_data_.back()->rows(),
     226                                validation_data_.back()->columns(),1));
     227           
     228           
     229            training_target_.push_back(Target(target(),training_index()));
     230            validation_target_.push_back(Target(target(),validation_index()));
     231            if (kl)
     232              delete kl;
     233          }
     234        }
     235        else {
     236        std::cerr << "Sorry, your type of DataLookup2D " << typeid(data).name()
     237                  << "is not supported in FeatureSelection\n";
     238        exit(-1);
     239        }
     240      }
     241    }
    150242    assert(training_data_.size()==size());
    151243    assert(training_weight_.size()==size());
Note: See TracChangeset for help on using the changeset viewer.