source: trunk/yat/classifier/KernelLookup.cc @ 680

Last change on this file since 680 was 680, checked in by Jari Häkkinen, 16 years ago

Addresses #153. Introduced yat namespace. Removed alignment namespace. Clean up of code.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date ID
File size: 7.8 KB
Line 
1// $Id$
2
3/*
4  Copyright (C) The authors contributing to this file.
5
6  This file is part of the yat library, http://lev.thep.lu.se/trac/yat
7
8  The yat library is free software; you can redistribute it and/or
9  modify it under the terms of the GNU General Public License as
10  published by the Free Software Foundation; either version 2 of the
11  License, or (at your option) any later version.
12
13  The yat library is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  General Public License for more details.
17
18  You should have received a copy of the GNU General Public License
19  along with this program; if not, write to the Free Software
20  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
21  02111-1307, USA.
22*/
23
24#include "KernelLookup.h"
25#include "DataLookup2D.h"
26#include "MatrixLookup.h"
27#include "MatrixLookupWeighted.h"
28
29#include <cassert>
30#ifndef NDEBUG
31#include <algorithm>
32#endif
33
34namespace theplu {
35namespace yat {
36namespace classifier { 
37
38  KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
39    : DataLookup2D(own), kernel_(&kernel)
40  {
41    column_index_.reserve(kernel.size());
42    for(size_t i=0; i<kernel.size(); i++)
43      column_index_.push_back(i);
44    row_index_=column_index_;
45  }
46 
47  KernelLookup::KernelLookup(const Kernel& kernel,
48                             const std::vector<size_t>& row, 
49                             const std::vector<size_t>& column,
50                             const bool owner)
51    : DataLookup2D(row,column,owner), kernel_(&kernel)
52  {
53    // Checking that each row index is less than kernel.rows()
54    assert(row.empty() || 
55           *(std::max_element(row.begin(),row.end()))<kernel_->size());
56    // Checking that each column index is less than kernel.column()
57    assert(column.empty() || 
58           *(std::max_element(column.begin(),column.end()))<kernel_->size());
59  }
60
61
62  KernelLookup::KernelLookup(const KernelLookup& other, 
63                             const std::vector<size_t>& row, 
64                             const std::vector<size_t>& column)
65    : DataLookup2D(other,row,column), kernel_(other.kernel_)
66  {
67    ref_count_=other.ref_count_;
68    if (ref_count_)
69      ++(*ref_count_);
70  }
71 
72
73  KernelLookup::KernelLookup(const KernelLookup& other)
74    : DataLookup2D(other), kernel_(other.kernel_)
75  {
76    // Checking that no index is out of range
77    assert(row_index_.empty() || 
78           *(max_element(row_index_.begin(), row_index_.end()))<
79           kernel_->size());
80    assert(column_index_.empty() || 
81           *(max_element(column_index_.begin(), column_index_.end()))<
82           kernel_->size());
83    ref_count_=other.ref_count_;
84    if (ref_count_)
85      ++(*ref_count_);
86  }
87 
88
89  KernelLookup::KernelLookup(const KernelLookup& other, 
90                             const std::vector<size_t>& index, 
91                             const bool row)
92    : DataLookup2D(other,index,row), kernel_(other.kernel_)
93  {
94    assert(kernel_->size());
95
96    // Checking that no index is out of range
97    assert(row_index_.empty() || 
98           *(max_element(row_index_.begin(), row_index_.end()))<
99           kernel_->size());
100    assert(column_index_.empty() || 
101           *(max_element(column_index_.begin(), column_index_.end()))<
102           kernel_->size());
103    ref_count_=other.ref_count_;
104    if (ref_count_)
105      ++(*ref_count_);
106  }
107 
108
109  KernelLookup::~KernelLookup(void)
110  {
111    if (ref_count_)
112      if (!--(*ref_count_))
113        delete kernel_;
114  }
115
116  const KernelLookup* 
117  KernelLookup::training_data(const std::vector<size_t>& train) const
118  { 
119    return new KernelLookup(*this,train,train); 
120  } 
121
122
123  const KernelLookup* 
124  KernelLookup::validation_data(const std::vector<size_t>& train, 
125                                const std::vector<size_t>& validation) const
126  { 
127    return new KernelLookup(*this,train,validation); 
128  } 
129
130
131  const KernelLookup* 
132  KernelLookup::selected(const std::vector<size_t>& inputs) const
133  {
134    const Kernel* kernel = kernel_->selected(inputs);
135    return new KernelLookup(*kernel, row_index_, column_index_, true);
136  }
137
138
139  const KernelLookup* KernelLookup::test_kernel(const MatrixLookup& data) const
140  {
141
142    assert(data.rows()==kernel_->data().rows());
143    if (!weighted()){
144      utility::matrix* data_all = 
145        new utility::matrix(data.rows(), row_index_.size()+data.columns());
146
147      for (size_t i=0; i<data_all->rows(); ++i) {
148
149        // first some columns from data in kernel_
150        for (size_t j=0; j<row_index_.size(); ++j){
151          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]); 
152        }
153       
154        // last columns are equal to new data
155        for (size_t j=0;j<data.columns(); ++j){
156          (*data_all)(i,j+row_index_.size()) = data(i,j);
157        }
158      }
159      std::vector<size_t> column_index;
160      column_index.reserve(data.columns());
161      for (size_t i=0;i<data.columns(); ++i)
162        column_index.push_back(i+row_index_.size());
163
164      std::vector<size_t> row_index;
165      row_index.reserve(row_index_.size());
166      for (size_t i=0;i<row_index_.size(); ++i)
167        row_index.push_back(i);
168
169      const MatrixLookup* tmp = new MatrixLookup(*data_all, true);
170
171      const Kernel* kernel = 
172        kernel_->make_kernel(*tmp, true);
173
174      return new KernelLookup(*kernel, row_index, column_index, true);
175    }
176
177    // kernel_ holds MatrixLookupWeighted, hence new Kernel also
178    // should hold a MatrixLookupweighted.
179    utility::matrix* data_all = 
180      new utility::matrix(data.rows(), rows()+data.columns());
181    utility::matrix* weight_all = 
182      new utility::matrix(data.rows(), rows()+data.columns(), 1.0);
183    const MatrixLookupWeighted& kernel_data = 
184      dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
185
186    for (size_t i=0; i<data.rows(); ++i){
187
188      // first some columns from data in kernel_
189      for (size_t j=0; j<row_index_.size(); ++j){
190        (*data_all)(i,j) = kernel_data.data(i,row_index_[j]); 
191        (*weight_all)(i,j) = kernel_data.weight(i,row_index_[j]);
192      }
193
194      // last columns are equal to new data
195      for (size_t j=0;j<data.columns(); ++j){
196        (*data_all)(i,j+row_index_.size()) = data(i,j);
197      }
198    }
199    std::vector<size_t> column_index;
200    column_index.reserve(data.columns());
201    for (size_t i=0;i<data.columns(); ++i)
202      column_index.push_back(i+row_index_.size());
203
204    std::vector<size_t> row_index;
205    row_index.reserve(row_index_.size());
206    for (size_t i=0;i<row_index_.size(); ++i)
207      row_index.push_back(i);
208
209    MatrixLookupWeighted* tmp = new MatrixLookupWeighted(*data_all, 
210                                                         *weight_all, true);
211    const Kernel* kernel = kernel_->make_kernel(*tmp, true);
212    return new KernelLookup(*kernel, row_index_, column_index, true);
213  }
214
215
216
217  const KernelLookup* 
218  KernelLookup::test_kernel(const MatrixLookupWeighted& data) const
219  {
220    utility::matrix* data_all = 
221      new utility::matrix(data.rows(), rows()+data.columns());
222    utility::matrix* weight_all = 
223      new utility::matrix(data.rows(), rows()+data.columns(), 1.0);
224
225    if (weighted()){
226      const MatrixLookupWeighted& kernel_data = 
227        dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
228   
229      for (size_t i=0; i<data.rows(); ++i){
230        // first columns are equal to data in kernel_
231        for (size_t j=0; j<row_index_.size(); ++j){
232          (*data_all)(i,j) = kernel_data.data(i,row_index_[j]);
233          (*weight_all)(i,j) = kernel_data.weight(i,row_index_[j]);
234        }
235      }
236    }
237    else {
238
239        dynamic_cast<const MatrixLookupWeighted&>(kernel_->data());
240   
241      for (size_t i=0; i<data.rows(); ++i){
242        // first columns are equal to data in kernel_
243        for (size_t j=0; j<row_index_.size(); ++j)
244          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]);
245      }
246    }
247
248    // last columns are equal to new data
249    for (size_t i=0; i<data.rows(); ++i){
250      for (size_t j=0;j<data.columns(); ++j){
251        (*data_all)(i,j+row_index_.size()) = data.data(i,j);
252        (*weight_all)(i,j+row_index_.size()) = data.weight(i,j);
253      }
254    }
255   
256    std::vector<size_t> column_index;
257    column_index.reserve(data.columns());
258    for (size_t i=0;i<data.columns(); ++i)
259      column_index.push_back(i+row_index_.size());
260    const Kernel* kernel = 
261      kernel_->make_kernel(MatrixLookupWeighted(*data_all, *weight_all, true));
262    return new KernelLookup(*kernel, row_index_, column_index, true);
263  }
264
265}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.