Changeset 607

Timestamp:

Aug 29, 2006, 4:42:28 PM (17 years ago)

Author:

Peter

Message:

ref #96 included FeatureSelection? in CrossSplitter?. Also happened to add properties to files

Location:

trunk/c++_tools/classifier

Files:

• ConsensusInputRanker.cc (modified) (1 prop)
• ConsensusInputRanker.h (modified) (1 prop)
• CrossSplitter.cc (modified) (3 diffs, 1 prop)
• CrossSplitter.h (modified) (4 diffs, 1 prop)
• DataLookup2D.cc (modified) (2 props)
• DataLookup2D.h (modified) (2 diffs, 2 props)
• FeatureSelector.cc (modified) (2 props)
• FeatureSelector.h (modified) (1 diff, 2 props)
• FeatureSelectorIR.cc (modified) (2 props)
• FeatureSelectorIR.h (modified) (2 props)
• GaussianKernelFunction.cc (modified) (1 prop)
• GaussianKernelFunction.h (modified) (1 prop)
• InputRanker.cc (modified) (1 prop)
• InputRanker.h (modified) (1 prop)
• KernelFunction.h (modified) (1 prop)
• KernelLookup.cc (modified) (1 diff)
• KernelLookup.h (modified) (2 diffs)
• Kernel_MEV.h (modified) (1 prop)
• Makefile.am (modified) (1 diff, 2 props)
• MatrixLookup.cc (modified) (1 diff, 2 props)
• MatrixLookup.h (modified) (2 diffs, 2 props)
• MatrixLookupWeighted.cc (modified) (1 diff, 2 props)
• MatrixLookupWeighted.h (modified) (3 diffs, 2 props)
• NCC.cc (modified) (2 props)
• NCC.h (modified) (2 props)
• PolynomialKernelFunction.cc (modified) (1 prop)
• PolynomialKernelFunction.h (modified) (1 prop)
• SVM.cc (modified) (1 prop)
• SVM.h (modified) (1 prop)

trunk/c++_tools/classifier/CrossSplitter.cc

@@ -4 +4 @@
 #include <c++_tools/classifier/CrossSplitter.h>
 #include <c++_tools/classifier/DataLookup2D.h>
+#include <c++_tools/classifier/FeatureSelector.h>
 #include <c++_tools/classifier/Target.h>
 #include <c++_tools/random/random.h>
@@ -41 +42 @@
       validation_target_.push_back(Target(target,validation_index_[i]));
     }
+
+    // No feature selection, hence features same for all partitions
+    // and can be stored in features_[0]
+    features_.resize(1);
+    features_[0].reserve(data.rows());
+    for (size_t i=0; i<data.rows(); ++i)
+      features_[0].push_back(i);
+
     assert(training_data_.size()==N);
     assert(training_weight_.size()==N);
@@ -73 +82 @@
       validation_target_.push_back(Target(target,validation_index_[i]));
     }
+    assert(training_data_.size()==N);
+    assert(training_weight_.size()==N);
+    assert(training_target_.size()==N);
+    assert(validation_data_.size()==N);
+    assert(validation_weight_.size()==N);
+    assert(validation_target_.size()==N);
+  }
+
+  CrossSplitter::CrossSplitter(const Target& target, const DataLookup2D& data, 
+                               const size_t N, const size_t k, 
+                               FeatureSelector& fs)
+    : k_(k), state_(0), target_(target), weighted_(false), f_selector_(&fs)
+  { 
+    assert(target.size()>1);
+    assert(target.size()==data.columns());
+
+    build(target, N, k);
+    features_.reserve(N);
+    training_data_.reserve(N);
+    training_weight_.reserve(N);
+    validation_data_.reserve(N);
+    validation_weight_.reserve(N);
+      
+    for (size_t i=0; i<N; i++){
+      
+      // training data with no feature selection
+      const DataLookup2D* train_data_all_feat = 
+        data.training_data(training_index_[i]);
+      // use these data to create feature selection
+      f_selector_->update(*train_data_all_feat, training_target_[i]);
+      // get features
+      features_.push_back(f_selector_->features());
+      delete train_data_all_feat;
+
+      // Dynamically allocated. Must be deleted in destructor.
+      training_data_.push_back(data.training_data(features_[i], 
+                                                  training_index_[i]));
+      training_weight_.push_back
+        (new MatrixLookup(training_data_.back()->rows(),
+                          training_data_.back()->columns(),1));
+      validation_data_.push_back(data.validation_data(features_[i],
+                                                      training_index_[i], 
+                                                      validation_index_[i]));
+      validation_weight_.push_back
+        (new MatrixLookup(validation_data_.back()->rows(),
+                          validation_data_.back()->columns(),1));
+
+
+      training_target_.push_back(Target(target,training_index_[i]));
+      validation_target_.push_back(Target(target,validation_index_[i]));
+    }
+
+    // No feature selection, hence features same for all partitions
+    // and can be stored in features_[0]
+    features_.resize(1);
+    features_[0].reserve(data.rows());
+    for (size_t i=0; i<data.rows(); ++i)
+      features_[0].push_back(i);
+
     assert(training_data_.size()==N);
     assert(training_weight_.size()==N);

trunk/c++_tools/classifier/CrossSplitter.h

@@ -14 +14 @@
 namespace classifier {  
   class DataLookup2D;
-
+  class FeatureSelector;
 
   ///
@@ -50 +50 @@
     /// @parameter k for k-fold crossvalidation
     ///
+    /// @todo This most likely be removed.
     CrossSplitter(const Target& target, const DataLookup2D& data, 
                   const MatrixLookup& weight,
                   const size_t N, const size_t k);
 
+    ///
+    /// @brief Constructor 
+    ///  
+    /// @parameter Target targets
+    /// @parameter data data to split up in validation and training.
+    /// @parameter N total number of partitions
+    /// @parameter k for k-fold crossvalidation
+    ///
+    CrossSplitter(const Target& target, const DataLookup2D& data, 
+                  const size_t N, const size_t k, FeatureSelector&);
+
     ///
     /// Destructor
@@ -98 +110 @@
     /// @note if state is invalid the result is undefined
     ///
+    inline const std::vector<size_t>& training_features(void) const
+    { assert(more()); return f_selector_ ? features_[state_] : features_[0]; }
+
+
+    /// @return training index
+    ///
+    /// @note if state is invalid the result is undefined
+    ///
     inline const std::vector<size_t>& training_index(void) const
     { assert(more()); return training_index_[state_]; }
-
 
     ///
@@ -172 +191 @@
     std::vector<std::vector<size_t> > validation_index_;
     std::vector<Target> validation_target_;
+
+    FeatureSelector* f_selector_;
+    std::vector<std::vector<size_t> > features_;
+
   };
 

trunk/c++_tools/classifier/DataLookup2D.h

@@ -82 +82 @@
 
     ///
-    /// @return sub-Lookup of the DataLookup2D
     ///
-    /// @Note Returns a dynamically allocated DataLookup2D, which has
-    /// to be deleted by the caller to avoid memory leaks.
-    ///
-    virtual const DataLookup2D* 
-    training_data(const std::vector<size_t>&) const=0; 
-
-    ///
-    /// @return number of rows
-    ///
-    inline size_t rows(void) const { return row_index_.size(); } 
-
-    ///
-    /// @todo doc
     ///
     virtual const DataLookup2D* selected(const std::vector< size_t > &) const=0;
@@ -107 +93 @@
     ///
     virtual const DataLookup2D* 
+    training_data(const std::vector<size_t>&) const=0; 
+
+    ///
+    /// @return sub-Lookup of the DataLookup2D
+    ///
+    /// @Note Returns a dynamically allocated DataLookup2D, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    virtual const DataLookup2D* 
+    training_data(const std::vector<size_t>& features, 
+                  const std::vector<size_t>& samples) const=0;
+
+    ///
+    /// @return number of rows
+    ///
+    inline size_t rows(void) const { return row_index_.size(); } 
+
+    ///
+    /// @return sub-Lookup of the DataLookup2D
+    ///
+    /// @Note Returns a dynamically allocated DataLookup2D, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    virtual const DataLookup2D* 
     validation_data(const std::vector<size_t>& train,
+                    const std::vector<size_t>& val) const=0; 
+
+    ///
+    /// @return sub-Lookup of the DataLookup2D
+    ///
+    /// @Note Returns a dynamically allocated DataLookup2D, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    virtual const DataLookup2D* 
+    validation_data(const std::vector<size_t>& features,
+                    const std::vector<size_t>& train,
                     const std::vector<size_t>& val) const=0; 
 

trunk/c++_tools/classifier/FeatureSelector.h

@@ -36 +36 @@
 
     ///
+    ///
+    ///
+    inline const std::vector<size_t> features(void) const { return features_; }
+
+    ///
     /// Uses @a data to select features.
     ///

trunk/c++_tools/classifier/KernelLookup.cc

@@ -88 +88 @@
 
   const KernelLookup* 
+  KernelLookup::training_data(const std::vector<size_t>& features, 
+                              const std::vector<size_t>& train) const
+  { 
+    const Kernel* kernel = kernel_->selected(features);
+    return new KernelLookup(*kernel, train, train, true);
+  } 
+
+
+  const KernelLookup* 
   KernelLookup::validation_data(const std::vector<size_t>& train, 
                                 const std::vector<size_t>& validation) const
   { 
     return new KernelLookup(*this,train,validation); 
+  } 
+
+
+  const KernelLookup* 
+  KernelLookup::validation_data(const std::vector<size_t>& features, 
+                                const std::vector<size_t>& train, 
+                                const std::vector<size_t>& validation) const
+  { 
+    const Kernel* kernel = kernel_->selected(features);
+    return new KernelLookup(*kernel, train, validation, true);
   } 
 

trunk/c++_tools/classifier/KernelLookup.h

@@ -135 +135 @@
 
     ///
+    /// @retun a sub-kernel of kernel calculated using data defined by
+    /// @a features. Each row and each columns corresponds to a traing
+    /// sample defined by @a train.
+    ///
+    /// @return pointer to dynamically allocated sub-Lookup of the KernelLookup
+    ///
+    /// @Note Returns a dynamically allocated DataLookup2D, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    const KernelLookup* training_data(const std::vector<size_t>& features,
+                                      const std::vector<size_t>& train) const;
+
+
+    ///
     /// In returned kernel each row corresponds to a training sample
     /// and each column corresponds to a validation sample. The
@@ -147 +161 @@
     const KernelLookup* 
     validation_data(const std::vector<size_t>& train, 
+                    const std::vector<size_t>& validation) const;
+
+
+    ///
+    /// In returned kernel each row corresponds to a training sample
+    /// and each column corresponds to a validation sample. The kernel
+    /// is based on the features defined by @a features.
+    ///
+    /// @Note Returns a dynamically allocated DataLookup2D, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    const KernelLookup* 
+    validation_data(const std::vector<size_t>& features, 
+                    const std::vector<size_t>& train, 
                     const std::vector<size_t>& validation) const;
 

trunk/c++_tools/classifier/Makefile.am

@@ -1 +1 @@
 ## Process this file with automake to produce Makefile.in
 ##
-## $Id: Makefile.am 281 2005-04-20 16:45:02Z peter $
+## $Id$
 
 # Copyright (C) 2005, 2006 Jari Häkkinen, Peter Johansson, Markus Ringnèr

trunk/c++_tools/classifier/MatrixLookup.cc

@@ -140 +140 @@
 
   const MatrixLookup* 
+  MatrixLookup::training_data(const std::vector<size_t>& features,
+                              const std::vector<size_t>& samples) const
+  { 
+    return new MatrixLookup(*this, features, samples); 
+  }
+
+
+
+  const MatrixLookup* 
   MatrixLookup::validation_data(const std::vector<size_t>& train,
                                 const std::vector<size_t>& val) const
   { 
     return new MatrixLookup(*this,val, false); 
+  }
+
+
+
+  const MatrixLookup* 
+  MatrixLookup::validation_data(const std::vector<size_t>& features,
+                                const std::vector<size_t>& train,
+                                const std::vector<size_t>& val) const
+  { 
+    return new MatrixLookup(*this,features, val); 
   }
 

trunk/c++_tools/classifier/MatrixLookup.h

@@ -181 +181 @@
     
     ///
+    /// The created MatrixLookup corresponds the columns defines by @a
+    /// samples and the rows defined by @a samples in the original
+    /// MatrixLookup. The created MatrixLookup will fullfill: \f$
+    /// novel_ml(i,j)=original(samp[i],feat[j]) \f$.
+    ///
+    /// @return pointer to sub-Lookup of the MatrixLookup
+    ///
+    /// @note If underlying matrix goes out of scope or is deleted, the
+    /// returned pointer becomes invalid and the result of further use is
+    /// undefined.
+    ///
+    const MatrixLookup* training_data(const std::vector<size_t>& features,
+                                      const std::vector<size_t>& samples) const;
+    
+    ///
     /// The created MatrixLookup corresponds to all rows and the
     /// columns defined by @a index in the original MatrixLookup. The
@@ -194 +209 @@
     const MatrixLookup* validation_data(const std::vector<size_t>&,
                                         const std::vector<size_t>&) const;
+    ///
+    /// The created MatrixLookup corresponds to rows defined by @a features and 
+    /// columns defined by @a val in the original MatrixLookup. The
+    /// created MatrixLookup will fullfill:
+    /// \f$ novel_ml(i,j)=original(features[i],val[j]) \f$.
+    ///
+    /// @return pointer to sub-Lookup of the MatrixLookup
+    ///
+    /// @note If underlying matrix goes out of scope or is deleted, the
+    /// returned pointer becomes invalid and the result of further use is
+    /// undefined.
+    ///
+    const MatrixLookup* validation_data(const std::vector<size_t>& features,
+                                        const std::vector<size_t>& train,
+                                        const std::vector<size_t>& val) const;
     ///
     /// Access operator

trunk/c++_tools/classifier/MatrixLookupWeighted.cc

@@ -179 +179 @@
 
   const MatrixLookupWeighted* 
+  MatrixLookupWeighted::training_data(const std::vector<size_t>& features,
+                                      const std::vector<size_t>& samples) const
+  { 
+    return new MatrixLookupWeighted(*this,features, samples); 
+  }
+
+
+
+  const MatrixLookupWeighted* 
   MatrixLookupWeighted::validation_data(const std::vector<size_t>& train,
-                                const std::vector<size_t>& val) const
+                                        const std::vector<size_t>& val) const
   { 
     return new MatrixLookupWeighted(*this,val, false); 
+  }
+
+
+
+  const MatrixLookupWeighted* 
+  MatrixLookupWeighted::validation_data(const std::vector<size_t>& features,
+                                        const std::vector<size_t>& training,
+                                        const std::vector<size_t>& val) const
+  { 
+    return new MatrixLookupWeighted(*this,features, val); 
   }
 

trunk/c++_tools/classifier/MatrixLookupWeighted.h

@@ -179 +179 @@
     ///
     /// @todo doc
-    ///   
-    const MatrixLookupWeighted* 
-    selected(const std::vector<size_t>& index) const;
+    ///
+    const MatrixLookupWeighted* selected(const std::vector<size_t>& i) const;
 
     ///
@@ -199 +198 @@
     
     ///
+    /// The created MatrixLookupWeighted corresponds to rows defined
+    /// by @a features and columns defined by @a samples in the
+    /// original MatrixLookupWeighted. The created
+    /// MatrixLookupWeighted will fullfill: 
+    /// \f$ novel_ml(i,j)=original(features[i],samples[j]) \f$.
+    ///
+    /// @return pointer to sub-Lookup of the MatrixLookupWeighted
+    ///
+    /// @note If underlying matrix goes out of scope or is deleted, the
+    /// returned pointer becomes invalid and the result of further use is
+    /// undefined.
+    ///
+    const MatrixLookupWeighted* 
+    training_data(const std::vector<size_t>& features, 
+                  const std::vector<size_t>& samples) const;
+    
+    ///
     /// The created MatrixLookupWeighted corresponds to all rows and the
     /// columns defined by @a index in the original MatrixLookupWeighted. The
@@ -212 +228 @@
     const MatrixLookupWeighted* validation_data(const std::vector<size_t>&,
                                         const std::vector<size_t>&) const;
+
+    ///
+    /// The created MatrixLookupWeighted corresponds to rows defined
+    /// by @a features and columns defined by @a val in the original
+    /// MatrixLookupWeighted. The created MatrixLookupWeighted will
+    /// fullfill: \f$ novel_ml(i,j)=original(features[i],val[j]) \f$.
+    ///
+    /// @return pointer to sub-Lookup of the MatrixLookupWeighted
+    ///
+    /// @note If underlying matrix goes out of scope or is deleted, the
+    /// returned pointer becomes invalid and the result of further use is
+    /// undefined.
+    ///
+    const MatrixLookupWeighted* 
+    validation_data(const std::vector<size_t>& features,
+                    const std::vector<size_t>& training,
+                    const std::vector<size_t>& val) const;
 
     ///