source: trunk/yat/classifier/KernelLookup.cc

Last change on this file was 2881, checked in by Peter, 10 years ago

Define PP variables in config.h rather than in CPPFLAGS. Include
config.h into all source files. Only ammend CXXFLAGS with '-Wall
-pedantic' when --enable-debug. In default mode we respect CXXFLAGS
value set by user, or set to default value '-O3'.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date ID
File size: 9.5 KB
Line 
1// $Id$
2
3/*
4  Copyright (C) 2005, 2006, 2007, 2008 Jari Häkkinen, Peter Johansson
5  Copyright (C) 2010, 2012 Peter Johansson
6
7  This file is part of the yat library, http://dev.thep.lu.se/yat
8
9  The yat library is free software; you can redistribute it and/or
10  modify it under the terms of the GNU General Public License as
11  published by the Free Software Foundation; either version 3 of the
12  License, or (at your option) any later version.
13
14  The yat library is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  General Public License for more details.
18
19  You should have received a copy of the GNU General Public License
20  along with yat. If not, see <http://www.gnu.org/licenses/>.
21*/
22
23#include <config.h>
24
25#include "KernelLookup.h"
26#include "MatrixLookup.h"
27#include "MatrixLookupWeighted.h"
28#include "yat/utility/Deleter.h"
29#include "yat/utility/Matrix.h"
30#include "yat/utility/MatrixWeighted.h"
31
32#include <cassert>
33
34namespace theplu {
35namespace yat {
36namespace classifier {
37
38  KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
39    : kernel_(&kernel, utility::Deleter(own))
40  {
41    column_index_ = utility::Index(kernel.size());
42    row_index_=column_index_;
43  }
44
45
46  KernelLookup::KernelLookup(const Kernel& kernel,
47                             const utility::Index& row,
48                             const utility::Index& column,
49                             const bool owner)
50    : column_index_(column),
51      kernel_(&kernel, utility::Deleter(owner)),
52      row_index_(row)
53  {
54    // Checking that each row index is less than kernel.rows()
55    assert(validate(row_index_));
56    // Checking that each column index is less than kernel.column()
57    assert(validate(column_index_));
58  }
59
60
61  KernelLookup::KernelLookup(const KernelLookup& other,
62                             const utility::Index& row,
63                             const utility::Index& column)
64    : kernel_(other.kernel_)
65  {
66    row_index_ = utility::Index(other.row_index_, row);
67    column_index_ = utility::Index(other.column_index_, column);
68  }
69
70
71  KernelLookup::KernelLookup(const KernelLookup& other)
72    : column_index_(other.column_index_), kernel_(other.kernel_),
73      row_index_(other.row_index_)
74  {
75    // Checking that each row index is less than kernel.rows()
76    assert(validate(row_index_));
77    // Checking that each column index is less than kernel.column()
78    assert(validate(column_index_));
79  }
80
81
82  KernelLookup::KernelLookup(const KernelLookup& other,
83                             const utility::Index& index,
84                             const bool row)
85    : kernel_(other.kernel_)
86  {
87    if (row){
88      row_index_ = utility::Index(other.row_index_, index);
89      column_index_= other.column_index_;
90    }
91    else{
92      column_index_ = utility::Index(other.column_index_, index);
93      row_index_= other.row_index_;
94    }
95    assert(kernel_->size());
96
97    // Checking that each row index is less than kernel.rows()
98    assert(validate(row_index_));
99    // Checking that each column index is less than kernel.column()
100    assert(validate(column_index_));
101  }
102
103
104  KernelLookup::~KernelLookup(void)
105  {
106  }
107
108
109  KernelLookup::const_iterator KernelLookup::begin(void) const
110  {
111    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
112  }
113
114
115  KernelLookup::const_column_iterator
116  KernelLookup::begin_column(size_t i) const
117  {
118    return const_column_iterator(const_column_iterator::iterator_type(*this,
119                                                                      0,i),
120                                 columns());
121  }
122
123
124  KernelLookup::const_row_iterator KernelLookup::begin_row(size_t i) const
125  {
126    return const_row_iterator(const_row_iterator::iterator_type(*this,i,0), 1);
127  }
128
129
130  size_t KernelLookup::columns(void) const
131  {
132    return column_index_.size();
133  }
134
135
136  MatrixLookup KernelLookup::data(void) const
137  {
138    assert(!weighted());
139    return MatrixLookup(kernel_->data(), column_index_, false);
140  }
141
142
143  MatrixLookupWeighted KernelLookup::data_weighted(void) const
144  {
145    assert(weighted());
146    using utility::Index; // just to avoid long line
147    return MatrixLookupWeighted(kernel_->data_weighted(),
148                                Index(kernel_->data_weighted().rows()),
149                                column_index_);
150  }
151
152
153  double KernelLookup::element(const DataLookup1D& vec, size_t i) const
154  {
155    return kernel_->element(vec, row_index_[i]);
156  }
157
158
159  double KernelLookup::element(const DataLookupWeighted1D& vec, size_t i) const
160  {
161    return kernel_->element(vec, row_index_[i]);
162  }
163
164
165  KernelLookup::const_iterator KernelLookup::end(void) const
166  {
167    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
168  }
169
170
171  KernelLookup::const_column_iterator KernelLookup::end_column(size_t i) const
172  {
173    return const_column_iterator(const_column_iterator::iterator_type(*this,
174                                                                      rows(),i),
175                                 columns());
176  }
177
178
179  KernelLookup::const_row_iterator KernelLookup::end_row(size_t i) const
180  {
181    return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
182  }
183
184
185  size_t KernelLookup::rows(void) const
186  {
187    return row_index_.size();
188  }
189
190
191  KernelLookup KernelLookup::selected(const utility::Index& inputs) const
192  {
193    const Kernel* kernel;
194    if (kernel_->weighted()){
195      const MatrixLookupWeighted* ms =
196        new MatrixLookupWeighted(data_weighted(),inputs,
197                                 utility::Index(data_weighted().columns()));
198      kernel = kernel_->make_kernel(*ms, true);
199    }
200    else {
201      // matrix with selected features
202      const MatrixLookup* ms = new MatrixLookup(data(),inputs,true);
203      kernel = kernel_->make_kernel(*ms,true);
204    }
205    return KernelLookup(*kernel, true);
206  }
207
208
209  KernelLookup KernelLookup::test_kernel(const MatrixLookup& data) const
210  {
211    if (!weighted()){
212      assert(data.rows()==kernel_->data().rows());
213      utility::Matrix* data_all =
214        new utility::Matrix(data.rows(), row_index_.size()+data.columns());
215
216      for (size_t i=0; i<data_all->rows(); ++i) {
217
218        // first some columns from data in kernel_
219        for (size_t j=0; j<row_index_.size(); ++j){
220          (*data_all)(i,j) = kernel_->data()(i,row_index_[j]);
221        }
222
223        // last columns are equal to new data
224        for (size_t j=0;j<data.columns(); ++j){
225          (*data_all)(i,j+row_index_.size()) = data(i,j);
226        }
227      }
228      std::vector<size_t> column_index;
229      column_index.reserve(data.columns());
230      for (size_t i=0;i<data.columns(); ++i)
231        column_index.push_back(i+row_index_.size());
232
233      std::vector<size_t> row_index;
234      row_index.reserve(row_index_.size());
235      for (size_t i=0;i<row_index_.size(); ++i)
236        row_index.push_back(i);
237
238      const MatrixLookup* tmp = new MatrixLookup(*data_all, true);
239
240      const Kernel* kernel =
241        kernel_->make_kernel(*tmp, true);
242
243      return KernelLookup(*kernel, utility::Index(row_index),
244                          utility::Index(column_index), true);
245    }
246
247    assert(data.rows()==kernel_->data_weighted().rows());
248    // kernel_ holds MatrixLookupWeighted, hence new Kernel also
249    // should hold a MatrixLookupweighted.
250    utility::MatrixWeighted* x_all =
251      new utility::MatrixWeighted(data.rows(), rows()+data.columns());
252    const MatrixLookupWeighted& kernel_data = kernel_->data_weighted();
253
254    for (size_t i=0; i<data.rows(); ++i){
255
256      // first some columns from data in kernel_
257      for (size_t j=0; j<row_index_.size(); ++j){
258        (*x_all)(i,j) = kernel_data(i,row_index_[j]);
259      }
260
261      // last columns are equal to new data
262      for (size_t j=0;j<data.columns(); ++j){
263        (*x_all)(i,j+row_index_.size()).data() = data(i,j);
264      }
265    }
266    std::vector<size_t> column_index;
267    column_index.reserve(data.columns());
268    for (size_t i=0;i<data.columns(); ++i)
269      column_index.push_back(i+row_index_.size());
270
271    std::vector<size_t> row_index;
272    row_index.reserve(row_index_.size());
273    for (size_t i=0;i<row_index_.size(); ++i)
274      row_index.push_back(i);
275
276    MatrixLookupWeighted* tmp = new MatrixLookupWeighted(*x_all, true);
277    const Kernel* kernel = kernel_->make_kernel(*tmp, true);
278
279
280    return KernelLookup(*kernel, row_index_,
281                        utility::Index(column_index), true);
282  }
283
284
285
286  KernelLookup KernelLookup::test_kernel(const MatrixLookupWeighted& data) const
287  {
288    utility::MatrixWeighted* x_all =
289      new utility::MatrixWeighted(data.rows(), rows()+data.columns());
290
291    if (weighted()){
292      const MatrixLookupWeighted& kernel_data = kernel_->data_weighted();
293
294      for (size_t i=0; i<data.rows(); ++i){
295        // first columns are equal to data in kernel_
296        for (size_t j=0; j<row_index_.size(); ++j){
297          (*x_all)(i,j) = kernel_data(i,row_index_[j]);
298        }
299      }
300    }
301    else {
302
303      for (size_t i=0; i<data.rows(); ++i){
304        // first columns are equal to data in kernel_
305        for (size_t j=0; j<row_index_.size(); ++j)
306          (*x_all)(i,j).data() = kernel_->data()(i,row_index_[j]);
307      }
308    }
309
310    // last columns are equal to new data
311    for (size_t i=0; i<data.rows(); ++i){
312      for (size_t j=0;j<data.columns(); ++j){
313        (*x_all)(i,j+row_index_.size()) = data(i,j);
314      }
315    }
316
317    std::vector<size_t> column_index;
318    column_index.reserve(data.columns());
319    for (size_t i=0;i<data.columns(); ++i)
320      column_index.push_back(i+row_index_.size());
321    const Kernel* kernel =
322      kernel_->make_kernel(MatrixLookupWeighted(*x_all, true));
323    return KernelLookup(*kernel, row_index_,
324                        utility::Index(column_index), true);
325  }
326
327
328  /*
329  const KernelLookup*
330  KernelLookup::training_data(const utility::Index& train) const
331  {
332    return new KernelLookup(*this,train,train);
333  }
334  */
335
336
337  bool KernelLookup::validate(const utility::Index& index) const
338  {
339    for (size_t i=0; i<index.size(); ++i)
340      if (index[i]>=kernel_->size())
341        return false;
342    return true;
343  }
344
345
346  bool KernelLookup::weighted(void) const
347  {
348    return kernel_->weighted();
349  }
350
351
352  KernelLookup::const_reference
353  KernelLookup::operator()(size_t row, size_t column) const
354  {
355    return (*kernel_)(row_index_[row],column_index_[column]);
356  }
357
358}}} // of namespace classifier, yat, and theplu
Note: See TracBrowser for help on using the repository browser.