source: trunk/yat/classifier/KernelLookup.cc

Last change on this file was 2881, checked in by Peter, 9 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.