source: branches/0.4-stable/yat/classifier/KernelLookup.cc @ 1392

// $Id$

/*
  Copyright (C) 2005, 2006, 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "KernelLookup.h"
#include "MatrixLookup.h"
#include "MatrixLookupWeighted.h"
#include "yat/utility/Matrix.h"

#include <cassert>

namespace theplu {
namespace yat {
namespace classifier {

  KernelLookup::KernelLookup(const Kernel& kernel, const bool own)
    : kernel_(utility::SmartPtr<const Kernel>(&kernel, own))
  {
    column_index_ = utility::Index(kernel.size());
    row_index_=column_index_;
  }


  KernelLookup::KernelLookup(const Kernel& kernel,
                             const utility::Index& row, 
                             const utility::Index& column,
                             const bool owner)
    : column_index_(column), 
      kernel_(utility::SmartPtr<const Kernel>(&kernel, owner)),
      row_index_(row)
  {
    // Checking that each row index is less than kernel.rows()
    assert(validate(row_index_));
    // Checking that each column index is less than kernel.column()
    assert(validate(column_index_));
  }


  KernelLookup::KernelLookup(const KernelLookup& other, 
                             const utility::Index& row, 
                             const utility::Index& column)
    : kernel_(other.kernel_)
  {
    row_index_ = utility::Index(other.row_index_, row);
    column_index_ = utility::Index(other.column_index_, column);
  }
  

  KernelLookup::KernelLookup(const KernelLookup& other)
    : column_index_(other.column_index_), kernel_(other.kernel_), 
      row_index_(other.row_index_)
  {
    // Checking that each row index is less than kernel.rows()
    assert(validate(row_index_));
    // Checking that each column index is less than kernel.column()
    assert(validate(column_index_));
  }
  

  KernelLookup::KernelLookup(const KernelLookup& other, 
                             const utility::Index& index, 
                             const bool row)
    : kernel_(other.kernel_)
  {
    if (row){
      row_index_ = utility::Index(other.row_index_, index);
      column_index_= other.column_index_;
    }
    else{
      column_index_ = utility::Index(other.column_index_, index);
      row_index_= other.row_index_;
    }
    assert(kernel_->size());

    // Checking that each row index is less than kernel.rows()
    assert(validate(row_index_));
    // Checking that each column index is less than kernel.column()
    assert(validate(column_index_));
  }
  

  KernelLookup::~KernelLookup(void)
  {
  }


  KernelLookup::const_iterator KernelLookup::begin(void) const
  {
    return const_iterator(const_iterator::iterator_type(*this, 0, 0), 1);
  }


  KernelLookup::const_column_iterator 
  KernelLookup::begin_column(size_t i) const
  {
    return const_column_iterator(const_column_iterator::iterator_type(*this,
                                                                      0,i), 
                                 columns());
  }


  KernelLookup::const_row_iterator KernelLookup::begin_row(size_t i) const
  {
    return const_row_iterator(const_row_iterator::iterator_type(*this,i,0), 1);
  }


  size_t KernelLookup::columns(void) const
  {
    return column_index_.size();
  }


  MatrixLookup KernelLookup::data(void) const
  {
    assert(!weighted());
    return MatrixLookup(kernel_->data(), column_index_, false);
  }


  MatrixLookupWeighted KernelLookup::data_weighted(void) const
  {
    assert(weighted());
    return MatrixLookupWeighted(kernel_->data_weighted(),column_index_,false);
  }


  double KernelLookup::element(const DataLookup1D& vec, size_t i) const
  {
    return kernel_->element(vec, row_index_[i]);
  }


  double KernelLookup::element(const DataLookupWeighted1D& vec, size_t i) const
  {
    return kernel_->element(vec, row_index_[i]);
  }


  KernelLookup::const_iterator KernelLookup::end(void) const
  {
    return const_iterator(const_iterator::iterator_type(*this, rows(), 0), 1);
  }


  KernelLookup::const_column_iterator KernelLookup::end_column(size_t i) const
  {
    return const_column_iterator(const_column_iterator::iterator_type(*this, 
                                                                      rows(),i),
                                 columns());
  }


  KernelLookup::const_row_iterator KernelLookup::end_row(size_t i) const
  {
    return const_row_iterator(const_row_iterator::iterator_type(*this,i+1,0),1);
  }


  size_t KernelLookup::rows(void) const
  {
    return row_index_.size();
  }


  KernelLookup KernelLookup::selected(const utility::Index& inputs) const
  {
    const Kernel* kernel;
    if (kernel_->weighted()){
      const MatrixLookupWeighted* ms = 
        new MatrixLookupWeighted(data_weighted(),inputs,true);
      kernel = kernel_->make_kernel(*ms, true);
    }
    else {
      // matrix with selected features
      const MatrixLookup* ms = new MatrixLookup(data(),inputs,true);
      kernel = kernel_->make_kernel(*ms,true);
    }
    return KernelLookup(*kernel, true);
  }


  KernelLookup KernelLookup::test_kernel(const MatrixLookup& data) const
  {
    if (!weighted()){
      assert(data.rows()==kernel_->data().rows());
      utility::Matrix* data_all = 
        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){
          (*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());

      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(*tmp, true);

      return KernelLookup(*kernel, utility::Index(row_index), 
                          utility::Index(column_index), true);
    }

    assert(data.rows()==kernel_->data_weighted().rows());
    // 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 = kernel_->data_weighted();

    for (size_t i=0; i<data.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.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());

    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 KernelLookup(*kernel, row_index_, 
                        utility::Index(column_index), true);
  }



  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 = kernel_->data_weighted();
    
      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 {

      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 KernelLookup(*kernel, row_index_, 
                        utility::Index(column_index), true);
  }


  /*
  const KernelLookup*
  KernelLookup::training_data(const utility::Index& train) const
  {
    return new KernelLookup(*this,train,train);
  }
  */


  bool KernelLookup::validate(const utility::Index& index) const
  {
    for (size_t i=0; i<index.size(); ++i)
      if (index[i]>=kernel_->size())
        return false;
    return true;
  }


  bool KernelLookup::weighted(void) const
  {
    return kernel_->weighted();
  }


  double KernelLookup::operator()(size_t row, size_t column) const
  {
    return (*kernel_)(row_index_[row],column_index_[column]);
  }

}}} // of namespace classifier, yat, and theplu