Changeset 1206

Timestamp:

Mar 5, 2008, 6:56:01 PM (16 years ago)

Author:

Peter

Message:

fixes #345

Location:

trunk

Files:

• test/ensemble_test.cc (modified) (3 diffs)
• yat/classifier/EnsembleBuilder.h (modified) (4 diffs)
• yat/classifier/KernelLookup.cc (modified) (5 diffs)
• yat/classifier/KernelLookup.h (modified) (8 diffs)
• yat/classifier/SubsetGenerator.h (modified) (7 diffs)

trunk/test/ensemble_test.cc

@@ -32 +32 @@
 #include "yat/classifier/Kernel_MEV.h"
 #include "yat/classifier/MatrixLookup.h"
+#include "yat/classifier/MatrixLookupWeighted.h"
 #include "yat/classifier/NCC.h"
 #include "yat/classifier/PolynomialKernelFunction.h"
@@ -87 +88 @@
     *error << "build ensemble" << std::endl;
     ensemble.build();
+    std::vector<std::vector<statistics::Averager> > result;
+    ensemble.predict(data, result);
+  }
+
+  {
+    *error << "create ensemble of ncc" << std::endl;
+    classifier::MatrixLookupWeighted data_weighted(data);
+    classifier::NCC<statistics::EuclideanDistance> ncc;
+    classifier::CrossValidationSampler sampler(target,3,3);
+    classifier::SubsetGenerator<classifier::MatrixLookupWeighted> 
+      subdata(sampler,data_weighted);
+    classifier::EnsembleBuilder<classifier::SupervisedClassifier,
+      classifier::MatrixLookupWeighted> ensemble(ncc, data_weighted, sampler);
+    *error << "build ensemble" << std::endl;
+    ensemble.build();
+    std::vector<std::vector<statistics::Averager> > result;
+    ensemble.predict(data_weighted, result);
   }
 
@@ -103 +121 @@
   *error << "build ensemble" << std::endl;
   ensemble.build();
+  std::vector<std::vector<statistics::Averager> > result;
+  ensemble.predict(kernel_lookup, result);
   
   utility::Vector out(target.size(),0);

trunk/yat/classifier/EnsembleBuilder.h

@@ -115 +115 @@
     SubsetGenerator<Data>* subset_;
     std::vector<Classifier*> classifier_;
+    KernelLookup test_data(const KernelLookup&, size_t k);
+    MatrixLookup test_data(const MatrixLookup&, size_t k);
+    MatrixLookupWeighted test_data(const MatrixLookupWeighted&, size_t k);
     std::vector<std::vector<statistics::Averager> > validation_result_;
 
@@ -169 +172 @@
 
   template <class C, class D> 
-  u_long EnsembleBuilder<C, D>::size(void) const
-  {
-    return classifier_.size();
-  }
-
-
-  template <class C, class D> 
   void EnsembleBuilder<C, D>::predict
   (const D& data, std::vector<std::vector<statistics::Averager> >& result)
@@ -187 +183 @@
 
     for(u_long k=0;k<subset_->size();++k) {       
-      const D* sub_data =
-        data.selected(subset_->training_features(k));
-      assert(sub_data);
-      classifier(k).predict(*sub_data,prediction);
-      delete sub_data;
+      D sub_data =  test_data(data, k);
+      classifier(k).predict(sub_data,prediction);
     }
 
@@ -200 +193 @@
 
   
+  template <class C, class D> 
+  u_long EnsembleBuilder<C, D>::size(void) const
+  {
+    return classifier_.size();
+  }
+
+
+  template <class C, class D> 
+  MatrixLookup EnsembleBuilder<C, D>::test_data(const MatrixLookup& data, 
+                                                size_t k)
+  {
+    return MatrixLookup(data, subset_->training_features(k), true);
+  }
+  
+
+  template <class C, class D> 
+  MatrixLookupWeighted 
+  EnsembleBuilder<C, D>::test_data(const MatrixLookupWeighted& data, size_t k)
+  {
+    return MatrixLookupWeighted(data, subset_->training_features(k), true);
+  }
+  
+
+  template <class C, class D> 
+  KernelLookup
+  EnsembleBuilder<C, D>::test_data(const KernelLookup& kernel, size_t k)
+  {
+    // weighted case
+    if (kernel.weighted()){
+      assert(false);
+      // no feature selection
+      if (kernel.data_weighted().rows()==subset_->training_features(k).size())
+        return KernelLookup(kernel, subset_->training_index(k), true);
+      MatrixLookupWeighted mlw = test_data(kernel.data_weighted(), k);
+      return subset_->training_data(k).test_kernel(mlw);
+
+    }
+    // unweighted case
+
+    // no feature selection
+    if (kernel.data().rows()==subset_->training_features(k).size())
+      return KernelLookup(kernel, subset_->training_index(k), true);
+    
+    // feature selection
+    return subset_->training_data(k).test_kernel(test_data(kernel.data(),k));
+  }
+  
+
   template <class C, class D> 
   const std::vector<std::vector<statistics::Averager> >& 

trunk/yat/classifier/KernelLookup.cc

@@ -131 +131 @@
 
 
-  utility::SmartPtr<const MatrixLookup> KernelLookup::data(void) const
-  {
-    return utility::SmartPtr<const MatrixLookup>
-      (new MatrixLookup(kernel_->data(), column_index_, false));
-  }
-
-
-  utility::SmartPtr<const MatrixLookupWeighted> 
-  KernelLookup::data_weighted(void) const
-  {
-    return utility::SmartPtr<const MatrixLookupWeighted>
-      (new MatrixLookupWeighted(kernel_->data_weighted(),column_index_,false));
+  MatrixLookup KernelLookup::data(void) const
+  {
+    assert(!weighted());
+    return MatrixLookup(kernel_->data(), column_index_, false);
+  }
+
+
+  MatrixLookupWeighted KernelLookup::data_weighted(void) const
+  {
+    assert(weighted());
+    return MatrixLookupWeighted(kernel_->data_weighted(),column_index_,false);
   }
 
@@ -184 +183 @@
 
 
-  utility::SmartPtr<const KernelLookup> 
-  KernelLookup::selected(const utility::Index& inputs) const
+  KernelLookup KernelLookup::selected(const utility::Index& inputs) const
   {
     const Kernel* kernel;
     if (kernel_->weighted()){
-      utility::SmartPtr<const MatrixLookupWeighted> ml = data_weighted();
       const MatrixLookupWeighted* ms = 
-        new MatrixLookupWeighted(*ml,inputs,true);
-      kernel = kernel_->make_kernel(*ms, false);
+        new MatrixLookupWeighted(data_weighted(),inputs,true);
+      kernel = kernel_->make_kernel(*ms, true);
     }
     else {
-      utility::SmartPtr<const MatrixLookup> m = data();
       // matrix with selected features
-      const MatrixLookup* ms = new MatrixLookup(*m,inputs,true);
+      const MatrixLookup* ms = new MatrixLookup(data(),inputs,true);
       kernel = kernel_->make_kernel(*ms,true);
     }
-    return utility::SmartPtr<const KernelLookup>
-      (new KernelLookup(*kernel, true));
-  }
-
-
-  utility::SmartPtr<const KernelLookup> 
-  KernelLookup::test_kernel(const MatrixLookup& data) const
+    return KernelLookup(*kernel, true);
+  }
+
+
+  KernelLookup KernelLookup::test_kernel(const MatrixLookup& data) const
   {
     if (!weighted()){
@@ -240 +234 @@
         kernel_->make_kernel(*tmp, true);
 
-      return utility::SmartPtr<const KernelLookup>
-        (new KernelLookup(*kernel, utility::Index(row_index), 
-                          utility::Index(column_index), true));
+      return KernelLookup(*kernel, utility::Index(row_index), 
+                          utility::Index(column_index), true);
     }
 
@@ -282 +275 @@
 
 
-    return utility::SmartPtr<const KernelLookup>
-      (new KernelLookup(*kernel, row_index_, 
-                        utility::Index(column_index), true));
-  }
-
-
-
-  utility::SmartPtr<const KernelLookup>
-  KernelLookup::test_kernel(const MatrixLookupWeighted& data) const
+    return KernelLookup(*kernel, row_index_, 
+                        utility::Index(column_index), true);
+  }
+
+
+
+  KernelLookup KernelLookup::test_kernel(const MatrixLookupWeighted& data) const
   {
     utility::Matrix* data_all = 
@@ -331 +322 @@
     const Kernel* kernel = 
       kernel_->make_kernel(MatrixLookupWeighted(*data_all, *weight_all, true));
-    return utility::SmartPtr<const KernelLookup>
-      (new KernelLookup(*kernel, row_index_, 
-                        utility::Index(column_index), true));
+    return KernelLookup(*kernel, row_index_, 
+                        utility::Index(column_index), true);
   }
 

trunk/yat/classifier/KernelLookup.h

@@ -49 +49 @@
   /// not contain any data or values, but rather is a lookup into a
   /// Kernel object. Each row and each column corresponds to a row and
-  /// a column in the Kernel, respectively. This design allow for fast
+  /// a column in the Kernel, respectively. This design allows for fast
   /// creation of sub-kernels, which is a common operation in most
   /// traning/validation procedures.
   ///
-  /// A KernelLookup can be created directly from a Kernel or from an
-  /// other KernelLookup. In the latter case, the resulting
+  /// A KernelLookup can be created directly from a Kernel or from
+  /// another KernelLookup. In the latter case, the resulting
   /// KernelLookup is looking directly into the underlying Kernel to
   /// avoid multiple lookups.
@@ -154 +154 @@
 
     ///
-    /// Constructor taking the column (default) or row index vector as
+    /// Constructor taking the column (default) or row index as
     /// input. If @a row is false the created KernelLookup will have
     /// equally many rows as @a kernel.
@@ -165 +165 @@
     /// undefined.
     ///
-    KernelLookup(const KernelLookup& kernel, const utility::Index&, 
+    KernelLookup(const KernelLookup& kl, const utility::Index&, 
                  const bool row=false);
 
@@ -211 +211 @@
     /// \throw if KernelLookup is weighted
     ///
-    utility::SmartPtr<const MatrixLookup> data(void) const;
+    MatrixLookup data(void) const;
 
     ///
@@ -221 +221 @@
     /// \throw if KernelLookup is unweighted
     ///
-    utility::SmartPtr<const MatrixLookupWeighted> data_weighted(void) const;
+    MatrixLookupWeighted data_weighted(void) const;
 
     /**
@@ -268 +268 @@
        KernelLookup.
     */
-    utility::SmartPtr<const KernelLookup> 
-    selected(const utility::Index& index) const;
+    KernelLookup selected(const utility::Index& index) const;
     
     /**
@@ -281 +280 @@
        this was built from.
     */
-    utility::SmartPtr<const KernelLookup> 
-    test_kernel(const MatrixLookup& data) const;
+    KernelLookup test_kernel(const MatrixLookup& data) const;
 
     /**
@@ -293 +291 @@
        between the passed @a data and the internal underlying data @a
        this was built from.
-    
-       @note Returns a dynamically allocated KernelLookup, which has
-       to be deleted by the caller to avoid memory leaks.
-    */
-    utility::SmartPtr<const KernelLookup> 
-    test_kernel(const MatrixLookupWeighted& data) const;
+    */
+    KernelLookup test_kernel(const MatrixLookupWeighted& data) const;
 
     /**

trunk/yat/classifier/SubsetGenerator.h

@@ -202 +202 @@
   void SubsetGenerator<T>::build(const MatrixLookup& ml)
   {
+    if (!f_selector_)// no feature selection
+      features_.push_back(utility::Index(ml.rows()));
+
     for (size_t k=0; k<size(); k++){
       training_target_.push_back(Target(target(),training_index(k)));
@@ -217 +220 @@
         delete train_data_all_feat;
       }
-      else // no feature selection
-        features_.push_back(utility::Index(ml.rows()));
-
       
       // Dynamically allocated. Must be deleted in destructor.
@@ -234 +234 @@
   void SubsetGenerator<T>::build(const MatrixLookupWeighted& ml)
   {
+    if (!f_selector_)// no feature selection
+      features_.push_back(utility::Index(ml.rows()));
+
     for (u_long k=0; k<size(); k++){
       training_target_.push_back(Target(target(),training_index(k)));
@@ -247 +250 @@
         delete train_data_all_feat;
       }
-      else // no feature selection
-        features_.push_back(utility::Index(ml.rows()));
 
 
@@ -268 +269 @@
       if (f_selector_){
         if (kernel.weighted()){
-          utility::SmartPtr<const MatrixLookupWeighted> ml=
-            kernel.data_weighted();
-          f_selector_->update(MatrixLookupWeighted(*ml,training_index(k),false), 
+          MatrixLookupWeighted ml = kernel.data_weighted();
+          f_selector_->update(MatrixLookupWeighted(ml,training_index(k),false), 
                               training_target(k));
         }
         else {
-          utility::SmartPtr<const MatrixLookup> ml=kernel.data();
-          f_selector_->update(MatrixLookup(*ml,training_index(k), false), 
+          MatrixLookup ml=kernel.data();
+          f_selector_->update(MatrixLookup(ml,training_index(k), false), 
                               training_target(k));
         } 
         features_.push_back(f_selector_->features());
-        utility::SmartPtr<const KernelLookup> kl = 
-          kernel.selected(features_.back());
+        KernelLookup kl = kernel.selected(features_.back());
         // Dynamically allocated. Must be deleted in destructor.
-        training_data_.push_back(new KernelLookup(*kl,training_index(k),
+        training_data_.push_back(new KernelLookup(kl,training_index(k),
                                                   training_index(k)));
-        validation_data_.push_back(new KernelLookup(*kl, training_index(k), 
+        validation_data_.push_back(new KernelLookup(kl, training_index(k), 
                                                     validation_index(k)));
       }
@@ -296 +295 @@
       
     }
+    if (!f_selector_){
+      if (kernel.weighted())
+        features_.push_back(utility::Index(kernel.data_weighted().rows()));
+      else
+        features_.push_back(utility::Index(kernel.data().rows()));
+    }
   }
 
@@ -325 +330 @@
   SubsetGenerator<T>::training_features(size_t i) const
   {
+    utility::yat_assert<std::runtime_error>(features_.size(),
+                                           "SubsetGenerator::training_features");
     return f_selector_ ? features_[i] : features_[0];
   }