Changeset 659

Timestamp:

Sep 26, 2006, 3:44:24 PM (17 years ago)

Author:

Peter

Message:

fixes #147 and #136

Location:

trunk/c++_tools/classifier

Files:

• DataLookup2D.cc (modified) (1 diff)
• DataLookup2D.h (modified) (1 diff)
• EnsembleBuilder.cc (modified) (1 diff)
• Kernel.cc (modified) (3 diffs)
• Kernel.h (modified) (2 diffs)
• KernelLookup.cc (modified) (9 diffs)
• KernelLookup.h (modified) (2 diffs)
• SVM.cc (modified) (1 diff)

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

@@ -70 +70 @@
 
   DataLookup2D::DataLookup2D(const std::vector<size_t>& row, 
-                             const std::vector<size_t>& col)
+                             const std::vector<size_t>& col,
+                             const bool own)
     : row_index_(row),column_index_(col), ref_count_(NULL)
   {
+    if (own)
+      ref_count_ = new u_int(1);
   }
 

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

@@ -39 +39 @@
     ///
     DataLookup2D(const std::vector<size_t>& row, 
-                 const std::vector<size_t>& column);
+                 const std::vector<size_t>& column,
+                 const bool own=false);
 
     ///

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

@@ -52 +52 @@
     size_t k=0;
     utility::matrix prediction;  
-   
-
     try {
       const KernelLookup& kernel = dynamic_cast<const KernelLookup&>(data);
       while(subset_.more()) {
-        classifier(k++).predict(KernelLookup(kernel,
-                                             subset_.training_index(),
-                                             true),
-                                prediction);
+        KernelLookup kernel_peter(kernel,subset_.training_index(),true);
+        classifier(k++).predict(kernel_peter,prediction);
+
         for(size_t i=0; i<prediction.rows();i++) 
           for(size_t j=0; j<prediction.columns();j++) 

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

@@ -15 +15 @@
   Kernel::Kernel(const MatrixLookup& data, const KernelFunction& kf, 
                  const bool own) 
-    : data_(&data), data_w_(0), kf_(&kf), data_owner_(own), 
-      weight_owner_(false)
+    : data_(&data), data_w_(0), kf_(&kf), ref_count_w_(NULL)
   {
+    if (own)
+      ref_count_ = new u_int(1);
+    else
+      ref_count_ = NULL;
   }
 
@@ -23 +26 @@
   Kernel::Kernel(const MatrixLookupWeighted& data, const KernelFunction& kf,
                  const bool own) 
-    : data_(&data), data_w_(&data), kf_(&kf), data_owner_(own), 
-      weight_owner_(own)
+    : data_(&data), data_w_(&data), kf_(&kf)
   {
+    if (own){
+      ref_count_ = new u_int(1);
+      ref_count_w_ = new u_int(1);
+    }
+    else {
+      ref_count_ = NULL;
+      ref_count_w_ = NULL;
+    }
   }
 
 
   Kernel::Kernel(const Kernel& other, const std::vector<size_t>& index)
-    : kf_(other.kf_), data_owner_(true)
+    : kf_(other.kf_)
   {
     data_ = other.data_->selected(index);
+    ref_count_ = new u_int(1);
+    
     if (other.data_w_){
       data_w_ = other.data_w_->selected(index);
-      weight_owner_=true;
+      ref_count_w_ = new u_int(1);
     }
     else{
       data_w_=NULL;
-      weight_owner_=false;
+      ref_count_w_ = NULL;
     }
 
@@ -46 +58 @@
   Kernel::~Kernel()
   {
-    if (data_owner_)
-      delete data_;
-      
-    if (weight_owner_)
-      if (data_w_)
+    if (ref_count_)
+      if (!--(*ref_count_))
+        delete data_;
+
+    if (ref_count_w_)
+      if (!--(*ref_count_w_))
         delete data_w_;
-      else 
-        std::cerr << "Error in Kernel implementation: probably a constructor"
-                  << std::endl;
-    
+
   }
 

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

@@ -148 +148 @@
 
   protected:
-    /// underlyung data
+    /// underlying data
     const DataLookup2D* data_;
     /// same as data_ if weifghted otherwise a NULL pointer
@@ -154 +154 @@
     /// type of Kernel Function e.g. Gaussian (aka RBF)
     const KernelFunction* kf_;
-    /// if true we own data and will delete it in destructor
-    const bool data_owner_;
-    /// if true we own data_w and will delete it in destructor
-    bool weight_owner_;
+
+    ///
+    /// poiter telling how many owners to underlying data
+    /// (data_). NULL if this is not an owner.
+    ///
+    u_int* ref_count_;
+
+    ///
+    /// poiter telling how many owners to underlying weights
+    /// (data_w_). NULL if this is not an owner.
+    ///
+    u_int* ref_count_w_;
 
   private:

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

@@ -16 +16 @@
 
   KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
-    : DataLookup2D(), kernel_(&kernel)
-  {
-    if (own)
-      ref_count_ = new u_int(1);
-
+    : DataLookup2D(own), kernel_(&kernel)
+  {
     column_index_.reserve(kernel.size());
     for(size_t i=0; i<kernel.size(); i++)
@@ -31 +28 @@
                              const std::vector<size_t>& column,
                              const bool owner)
-    : DataLookup2D(row,column), kernel_(&kernel)
-  {
-    if (owner)
-      ref_count_ = new u_int(1);
-
+    : DataLookup2D(row,column,owner), kernel_(&kernel)
+  {
     // Checking that each row index is less than kernel.rows()
     assert(row.empty() || 
@@ -42 +36 @@
     assert(column.empty() || 
            *(std::max_element(column.begin(),column.end()))<kernel_->size());
-
   }
 
@@ -70 +63 @@
     if (ref_count_)
       ++(*ref_count_);
-
   }
   
@@ -79 +71 @@
     : DataLookup2D(other,index,row), kernel_(other.kernel_)
   {
+    assert(kernel_->size());
+
     // Checking that no index is out of range
     assert(row_index_.empty() || 
@@ -124 +118 @@
   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]);
+        new utility::matrix(data.rows(), row_index_.size()+data.columns());
+
+      for (size_t i=0; i<data_all->rows(); ++i) {
+
+        // first some columns from 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)
+        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;
@@ -140 +140 @@
       for (size_t i=0;i<data.columns(); ++i)
         column_index.push_back(i+row_index_.size());
+
+      std::vector<size_t> row_index;
+      row_index.reserve(row_index_.size());
+      for (size_t i=0;i<row_index_.size(); ++i)
+        row_index.push_back(i);
+
+      const MatrixLookup* tmp = new MatrixLookup(*data_all, true);
+
       const Kernel* kernel = 
-        kernel_->make_kernel(MatrixLookup(*data_all, true), true);
-      return new KernelLookup(*kernel, row_index_, column_index, true);
+        kernel_->make_kernel(*tmp, true);
+
+      return new KernelLookup(*kernel, row_index, column_index, true);
     }
 
@@ -155 +164 @@
 
     for (size_t i=0; i<data.rows(); ++i){
-      // first columns are equal to data in kernel_
+
+      // first some columns from data in kernel_
       for (size_t j=0; j<row_index_.size(); ++j){
-        (*data_all)(i,j) = kernel_data.data(i,row_index_[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){
@@ -169 +180 @@
     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));
+
+    std::vector<size_t> row_index;
+    row_index.reserve(row_index_.size());
+    for (size_t i=0;i<row_index_.size(); ++i)
+      row_index.push_back(i);
+
+    MatrixLookupWeighted* tmp = new MatrixLookupWeighted(*data_all, 
+                                                         *weight_all, true);
+    const Kernel* kernel = kernel_->make_kernel(*tmp, true);
     return new KernelLookup(*kernel, row_index_, column_index, true);
   }

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

@@ -217 +217 @@
 
     ///
-    /// Weighted version of element function. Using weights @a w all
-    /// identical to unity results in same as using the unweighted
-    /// version above. 
+    /// Function to calculate a new Kernel element using the
+    /// underlying KernelFunction. The value is calulated between @a
+    /// vec and the data vector of the \f$ i \f$ th sample, in other
+    /// words, the sample corresponding to the \f$ i \f$ th row or
+    /// \f$ i \f$ th column. In case KernelLookup is a sub-Kernel and not
+    /// symmetric, the kernel value is calculated between @a vec and
+    /// the data vector corresponding to \f$ i \f$ th row.
     ///
     inline double element(const DataLookupWeighted1D& vec, const size_t i) const
@@ -240 +244 @@
     inline bool weighted(void) const { return kernel_->weighted(); }
 
+    inline const Kernel* kernel(void) const { return kernel_; }
+    
   private:
     const KernelLookup& operator=(const KernelLookup&);

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

@@ -95 +95 @@
     const KernelLookup& input_kernel = dynamic_cast<const KernelLookup&>(input);
 
-    const KernelLookup* kernel_pointer;
-    kernel_pointer = &input_kernel;
-
     assert(input.rows()==alpha_.size());
     prediction = utility::matrix(2,input.columns(),0);
     for (size_t i = 0; i<input.columns(); i++){
       for (size_t j = 0; j<input.rows(); j++){
-        prediction(0,i) += target(j)*alpha_(j)*(*kernel_pointer)(j,i);
+        prediction(0,i) += target(j)*alpha_(j)*input_kernel(j,i);
         assert(target(j));
       }