Changeset 658 for trunk/c++_tools

Timestamp:

Sep 25, 2006, 4:12:03 AM (17 years ago)

Author:

Peter

Message:

added function in KernelLookup? to create a KernelLookup? from inner data and outer (passed) data.

Location:

trunk/c++_tools/classifier

Files:

• DataLookup2D.cc (modified) (1 diff)
• DataLookup2D.h (modified) (1 diff)
• Kernel.cc (modified) (2 diffs)
• Kernel.h (modified) (4 diffs)
• KernelLookup.cc (modified) (4 diffs)
• KernelLookup.h (modified) (2 diffs)
• Kernel_MEV.cc (modified) (3 diffs)
• Kernel_MEV.h (modified) (4 diffs)
• Kernel_SEV.cc (modified) (3 diffs)
• Kernel_SEV.h (modified) (3 diffs)
• MatrixLookup.cc (modified) (1 diff)
• MatrixLookup.h (modified) (3 diffs)
• MatrixLookupWeighted.cc (modified) (1 diff)
• MatrixLookupWeighted.h (modified) (1 diff)

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

@@ -15 +15 @@
 
 
-  DataLookup2D::DataLookup2D()
+  DataLookup2D::DataLookup2D(const bool own)
     : ref_count_(NULL)
   {
+    if (own)
+      ref_count_ = new u_int(1);
   }
 

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

@@ -31 +31 @@
     /// Default constructor.
     ///
-    DataLookup2D(void);
+    DataLookup2D(const bool own=false);
 
 

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

@@ -13 +13 @@
 namespace classifier {
 
-  Kernel::Kernel(const MatrixLookup& data, const KernelFunction& kf) 
-    : data_(&data), data_w_(0), kf_(&kf), data_owner_(false), 
+  Kernel::Kernel(const MatrixLookup& data, const KernelFunction& kf, 
+                 const bool own) 
+    : data_(&data), data_w_(0), kf_(&kf), data_owner_(own), 
       weight_owner_(false)
   {
@@ -20 +21 @@
 
 
-  Kernel::Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf) 
-    : data_(&data), data_w_(&data), kf_(&kf), data_owner_(false), 
-      weight_owner_(false)
+  Kernel::Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf,
+                 const bool own) 
+    : data_(&data), data_w_(&data), kf_(&kf), data_owner_(own), 
+      weight_owner_(own)
   {
   }

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

@@ -47 +47 @@
     /// @note Can not handle NaNs. 
     ///
-    Kernel(const MatrixLookup& data, const KernelFunction& kf); 
+    Kernel(const MatrixLookup& data, const KernelFunction& kf, 
+           const bool own=false); 
 
     ///
@@ -58 +59 @@
     /// @note Can not handle NaNs. 
     ///
-    Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf); 
+    Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf, 
+           const bool own=false); 
 
     ///
@@ -105 +107 @@
 
     ///
+    /// An interface for making new classifier objects. This function
+    /// allows for specification at run-time of which kernel to
+    /// instatiate (see 'Prototype' in Design Patterns).
+    ///
+    /// @Note Returns a dynamically allocated Kernel, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    virtual const Kernel* make_kernel(const MatrixLookup&, const bool) const=0;
+
+
+    ///
+    /// An interface for making new classifier objects. This function
+    /// allows for specification at run-time of which kernel to
+    /// instatiate (see 'Prototype' in Design Patterns).
+    ///
+    /// @Note Returns a dynamically allocated Kernel, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    virtual const Kernel* make_kernel(const MatrixLookupWeighted&, 
+                                      const bool own=false) const=0;
+
+
+    ///
     /// Created Kernel is built from selected features in data. The
     /// @a index corresponds to which rows in data to use for the
@@ -114 +139 @@
     /// to be deleted by the caller to avoid memory leaks.
     ///
+    /// @todo remove this function
     virtual const Kernel* selected(const std::vector<size_t>& index) const=0;
 

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

@@ -3 +3 @@
 #include <c++_tools/classifier/KernelLookup.h>
 #include <c++_tools/classifier/DataLookup2D.h>
+#include <c++_tools/classifier/MatrixLookup.h>
+#include <c++_tools/classifier/MatrixLookupWeighted.h>
 
 
@@ -105 +107 @@
 
   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
@@ -121 +114 @@
 
 
-  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);
-  } 
-
-
   const KernelLookup* 
   KernelLookup::selected(const std::vector<size_t>& inputs) const
@@ -138 +121 @@
   }
 
+
+  const KernelLookup* KernelLookup::test_kernel(const MatrixLookup& data) const
+  {
+    assert(data.rows()==kernel_->data().rows());
+    if (!weighted()){
+      utility::matrix* data_all = 
+        new utility::matrix(data.rows(), rows()+data.columns());
+      for (size_t i=0; i<data.rows(); ++i){
+        // first columns are equal to data in kernel_
+        for (size_t j=0; j<row_index_.size(); ++j)
+          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]);
+        // last columns are equal to new data
+        for (size_t j=0;j<data.columns(); ++j)
+          (*data_all)(i,j+row_index_.size()) = data(i,j);
+      }
+      std::vector<size_t> column_index;
+      column_index.reserve(data.columns());
+      for (size_t i=0;i<data.columns(); ++i)
+        column_index.push_back(i+row_index_.size());
+      const Kernel* kernel = 
+        kernel_->make_kernel(MatrixLookup(*data_all, true), true);
+      return new KernelLookup(*kernel, row_index_, column_index, true);
+    }
+
+    // kernel_ holds MatrixLookupWeighted, hence new Kernel also
+    // should hold a MatrixLookupweighted.
+    utility::matrix* data_all = 
+      new utility::matrix(data.rows(), rows()+data.columns());
+    utility::matrix* weight_all = 
+      new utility::matrix(data.rows(), rows()+data.columns(), 1.0);
+    const MatrixLookupWeighted& kernel_data = 
+      dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
+
+    for (size_t i=0; i<data.rows(); ++i){
+      // first columns are equal to data in kernel_
+      for (size_t j=0; j<row_index_.size(); ++j){
+        (*data_all)(i,j) = kernel_data.data(i,row_index_[j]);
+        (*weight_all)(i,j) = kernel_data.weight(i,row_index_[j]);
+      }
+      // last columns are equal to new data
+      for (size_t j=0;j<data.columns(); ++j){
+        (*data_all)(i,j+row_index_.size()) = data(i,j);
+      }
+    }
+    std::vector<size_t> column_index;
+    column_index.reserve(data.columns());
+    for (size_t i=0;i<data.columns(); ++i)
+      column_index.push_back(i+row_index_.size());
+    const Kernel* kernel = 
+      kernel_->make_kernel(MatrixLookupWeighted(*data_all, *weight_all, true));
+    return new KernelLookup(*kernel, row_index_, column_index, true);
+  }
+
+
+
+  const KernelLookup* 
+  KernelLookup::test_kernel(const MatrixLookupWeighted& data) const
+  {
+    utility::matrix* data_all = 
+      new utility::matrix(data.rows(), rows()+data.columns());
+    utility::matrix* weight_all = 
+      new utility::matrix(data.rows(), rows()+data.columns(), 1.0);
+
+    if (weighted()){
+      const MatrixLookupWeighted& kernel_data = 
+        dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
+    
+      for (size_t i=0; i<data.rows(); ++i){
+        // first columns are equal to data in kernel_
+        for (size_t j=0; j<row_index_.size(); ++j){
+          (*data_all)(i,j) = kernel_data.data(i,row_index_[j]);
+          (*weight_all)(i,j) = kernel_data.weight(i,row_index_[j]);
+        }
+      }
+    }
+    else {
+
+        dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
+    
+      for (size_t i=0; i<data.rows(); ++i){
+        // first columns are equal to data in kernel_
+        for (size_t j=0; j<row_index_.size(); ++j)
+          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]);
+      }
+    }
+
+    // last columns are equal to new data
+    for (size_t i=0; i<data.rows(); ++i){
+      for (size_t j=0;j<data.columns(); ++j){
+        (*data_all)(i,j+row_index_.size()) = data.data(i,j);
+        (*weight_all)(i,j+row_index_.size()) = data.weight(i,j);
+      }
+    }
+    
+    std::vector<size_t> column_index;
+    column_index.reserve(data.columns());
+    for (size_t i=0;i<data.columns(); ++i)
+      column_index.push_back(i+row_index_.size());
+    const Kernel* kernel = 
+      kernel_->make_kernel(MatrixLookupWeighted(*data_all, *weight_all, true));
+    return new KernelLookup(*kernel, row_index_, column_index, true);
+  }
+
 }} // of namespace classifier and namespace theplu

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

@@ -139 +139 @@
 
     ///
-    /// @return 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
@@ -168 +154 @@
 
 
-    ///
-    /// 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;
+    /**
+       This function is useful when predicting on a independent data
+       set using a kernel-based classifier. In returned KernelLookup
+       column \f$ i \f$ corresponds to column \f$ i \f$ in @a
+       data. Row \f$ i \f$ in returned KernelLookup corresponds to
+       same sample as row \f$ i \f$ in @a this. In other words, this
+       function returns a KernelLookup containing the kernel elements
+       between the passed @a data and the internal underlying data @a
+       this was built from.
+    
+       @Note Returns a dynamically allocated DataLookup2D, which has
+       to be deleted by the caller to avoid memory leaks.
+    */
+    const KernelLookup* test_kernel(const MatrixLookup& data) const;
+
+
+    /**
+       This function is useful when predicting on a independent data
+       set using a kernel-based classifier. In returned KernelLookup
+       column \f$ i \f$ corresponds to column \f$ i \f$ in @a
+       data. Row \f$ i \f$ in returned KernelLookup corresponds to
+       same sample as row \f$ i \f$ in @a this. In other words, this
+       function returns a KernelLookup containing the kernel elements
+       between the passed @a data and the internal underlying data @a
+       this was built from.
+    
+       @Note Returns a dynamically allocated DataLookup2D, which has
+       to be deleted by the caller to avoid memory leaks.
+    */
+    const KernelLookup* test_kernel(const MatrixLookupWeighted& data) const;
 
 

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

@@ -9 +9 @@
 namespace classifier {  
 
-  Kernel_MEV::Kernel_MEV(const MatrixLookup& data, const KernelFunction& kf)
-    : Kernel(data,kf) 
+  Kernel_MEV::Kernel_MEV(const MatrixLookup& data, const KernelFunction& kf,
+                         const bool own)
+    : Kernel(data,kf,own) 
   {
   }
@@ -16 +17 @@
 
   Kernel_MEV::Kernel_MEV(const MatrixLookupWeighted& data, 
-                         const KernelFunction& kf)
-    : Kernel(data,kf) 
+                         const KernelFunction& kf, const bool own)
+    : Kernel(data,kf,own) 
   {
   }
@@ -26 +27 @@
     : Kernel(kernel,index)
   {
+  }
+
+
+  const Kernel_MEV* Kernel_MEV::make_kernel(const MatrixLookup& data, 
+                                            const bool own) const
+  {
+    return new Kernel_MEV(data, *kf_, own);
+  }
+
+
+  const Kernel_MEV* Kernel_MEV::make_kernel(const MatrixLookupWeighted& data, 
+                                            const bool own) const
+  {
+    return new Kernel_MEV(data, *kf_, own);
   }
 

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

@@ -34 +34 @@
     /// sample. @note Can not handle NaNs. 
     ///
-    Kernel_MEV(const MatrixLookup& data, const KernelFunction& kf);
+    Kernel_MEV(const MatrixLookup& data, const KernelFunction& kf, 
+               const bool own=false);
 
 
@@ -42 +43 @@
     /// sample. @note Can not handle NaNs. 
     ///
-    Kernel_MEV(const MatrixLookupWeighted& data, const KernelFunction& kf);
+    Kernel_MEV(const MatrixLookupWeighted& data, const KernelFunction& kf,
+               const bool own=false);
 
 
@@ -52 +54 @@
 
 
-    ///
-    /// Destructor
-    ///
-    inline virtual ~Kernel_MEV(void) {};
-
     ///
     /// @return Element at position (\a row, \a column) of the Kernel
@@ -63 +60 @@
     double operator()(const size_t row, const size_t column) const;
     
+    ///
+    /// An interface for making new classifier objects. This function
+    /// allows for specification at run-time of which kernel to
+    /// instatiate (see 'Prototype' in Design Patterns).
+    ///
+    /// @Note Returns a dynamically allocated Kernel, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    const Kernel_MEV* make_kernel(const MatrixLookup&, 
+                                  const bool own=false) const;
+
+
+    ///
+    /// An interface for making new classifier objects. This function
+    /// allows for specification at run-time of which kernel to
+    /// instatiate (see 'Prototype' in Design Patterns).
+    ///
+    /// @Note Returns a dynamically allocated Kernel, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    const Kernel_MEV* make_kernel(const MatrixLookupWeighted&, 
+                                  const bool own=false) const;
+
+
     /// 
     /// @see Kernel_MEV(const Kernel_MEV&, const std::vector<size_t>&);

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

@@ -14 +14 @@
 
 
-  Kernel_SEV::Kernel_SEV(const MatrixLookup& data, const KernelFunction& kf)
-    : Kernel(data,kf)
+  Kernel_SEV::Kernel_SEV(const MatrixLookup& data, const KernelFunction& kf,
+                         const bool own)
+    : Kernel(data,kf, own)
   {
     build_kernel();
@@ -22 +23 @@
 
   Kernel_SEV::Kernel_SEV(const MatrixLookupWeighted& data, 
-                         const KernelFunction& kf)
-    : Kernel(data,kf)
+                         const KernelFunction& kf, const bool own)
+    : Kernel(data,kf, own)
   {
     kernel_matrix_ = utility::matrix(data_->columns(),data_->columns());
@@ -52 +53 @@
 
 
+  double Kernel_SEV::operator()(const size_t row,const size_t column) const
+  { 
+    return kernel_matrix_(row,column); 
+  }
+  
+
+  const Kernel_SEV* Kernel_SEV::make_kernel(const MatrixLookup& data, 
+                                            const bool own) const
+  {
+    return new Kernel_SEV(data, *kf_, own);
+  }
+
+
+  const Kernel_SEV* Kernel_SEV::make_kernel(const MatrixLookupWeighted& data, 
+                            const bool own) const
+  {
+    return new Kernel_SEV(data, *kf_, own);
+  }
+
+
   const Kernel* Kernel_SEV::selected(const std::vector<size_t>& index) const
   {

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

@@ -34 +34 @@
     /// use KernelWeighted_SEV instead.
     ///
-    Kernel_SEV(const MatrixLookup&, const KernelFunction&);
+    Kernel_SEV(const MatrixLookup&, const KernelFunction&,const bool own=false);
     
     ///
@@ -41 +41 @@
     /// use KernelWeighted_SEV instead.
     ///
-    Kernel_SEV(const MatrixLookupWeighted&, const KernelFunction&);
+    Kernel_SEV(const MatrixLookupWeighted&, const KernelFunction&,
+               const bool own=false);
     
     ///
@@ -48 +49 @@
     Kernel_SEV(const Kernel_SEV& kernel, const std::vector<size_t>& index);
 
+
+    ///
+    /// An interface for making new classifier objects. This function
+    /// allows for specification at run-time of which kernel to
+    /// instatiate (see 'Prototype' in Design Patterns).
+    ///
+    /// @Note Returns a dynamically allocated Kernel, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    const Kernel_SEV* make_kernel(const MatrixLookup&, 
+                                  const bool own=false) const;
+
+
+    ///
+    /// An interface for making new classifier objects. This function
+    /// allows for specification at run-time of which kernel to
+    /// instatiate (see 'Prototype' in Design Patterns).
+    ///
+    /// @Note Returns a dynamically allocated Kernel, which has
+    /// to be deleted by the caller to avoid memory leaks.
+    ///
+    const Kernel_SEV* make_kernel(const MatrixLookupWeighted&, 
+                                  const bool own=false) const;
+
+
     ///
     /// @return element at position (\a row, \a column) in the Kernel
     /// matrix
     ///
-    inline double operator()(const size_t row,const size_t column) const
-    { return kernel_matrix_(row,column); }
+    double operator()(const size_t row,const size_t column) const;
+
 
     ///

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

@@ -14 +14 @@
 namespace classifier {
 
-  MatrixLookup::MatrixLookup(const utility::matrix& data)
-    : DataLookup2D(), data_(&data)
+  MatrixLookup::MatrixLookup(const utility::matrix& data, const bool own)
+    : DataLookup2D(own), data_(&data)
   {
     for(size_t i=0;i<(*data_).rows();i++)

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

@@ -30 +30 @@
   ///
   /// There is a possibility to set the MatrixLookup as owner of the
-  /// underlying matrix. In that case the underlying matrix will be
-  /// destroyed in the destructor. Consequently, the underlying matrix
-  /// must have been dynamically allocated and no other MatrixLookup
-  /// can own the Kernel.
+  /// underlying matrix. 
   ///
   class MatrixLookup : public DataLookup2D
@@ -43 +40 @@
     ///
     /// Constructor creating a lookup into the entire @a matrix. 
+    /// @param own if true MatrixLookup owns its underlying @a matrix
     ///
     /// @note If @a matrix goes out of scope or is deleted, the
@@ -48 +46 @@
     /// undefined.
     ///
-    explicit MatrixLookup(const utility::matrix& matrix);
+    MatrixLookup(const utility::matrix& matrix, const bool own=false);
 
     ///

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

@@ -15 +15 @@
 
   MatrixLookupWeighted::MatrixLookupWeighted(const utility::matrix& data, 
-                                             const utility::matrix& weights)
-    : DataLookup2D(), data_(&data), weights_(&weights), ref_count_weights_(NULL)
+                                             const utility::matrix& weights,
+                                             const bool own)
+    : DataLookup2D(own), data_(&data), weights_(&weights), 
+      ref_count_weights_(NULL)
   {
     assert(data.rows()==weights.rows());

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

@@ -44 +44 @@
     ///
     MatrixLookupWeighted(const utility::matrix& matrix, 
-                         const utility::matrix& weights);
+                         const utility::matrix& weights,
+                         const bool owner=false);