LinearByteKernel.cpp

Go to the documentation of this file.
00001 /*
00002  * This program is free software; you can redistribute it and/or modify
00003  * it under the terms of the GNU General Public License as published by
00004  * the Free Software Foundation; either version 3 of the License, or
00005  * (at your option) any later version.
00006  *
00007  * Written (W) 1999-2009 Soeren Sonnenburg
00008  * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
00009  */
00010 
00011 #include "lib/common.h"
00012 #include "lib/io.h"
00013 #include "lib/Mathematics.h"
00014 #include "kernel/LinearByteKernel.h"
00015 #include "features/SimpleFeatures.h"
00016 
00017 using namespace shogun;
00018 
00019 CLinearByteKernel::CLinearByteKernel()
00020 : CSimpleKernel<uint8_t>(0), normal(NULL)
00021 {
00022 }
00023 
00024 CLinearByteKernel::CLinearByteKernel(CSimpleFeatures<uint8_t>* l, CSimpleFeatures<uint8_t>* r)
00025 : CSimpleKernel<uint8_t>(0), normal(NULL)
00026 {
00027     init(l, r);
00028 }
00029 
00030 CLinearByteKernel::~CLinearByteKernel()
00031 {
00032     cleanup();
00033 }
00034 
00035 bool CLinearByteKernel::init(CFeatures* l, CFeatures* r)
00036 {
00037     CSimpleKernel<uint8_t>::init(l, r);
00038     return init_normalizer();
00039 }
00040 
00041 void CLinearByteKernel::cleanup()
00042 {
00043     delete_optimization();
00044 
00045     CKernel::cleanup();
00046 }
00047 
00048 void CLinearByteKernel::clear_normal()
00049 {
00050     int32_t num = lhs->get_num_vectors();
00051 
00052     for (int32_t i=0; i<num; i++)
00053         normal[i]=0;
00054 }
00055 
00056 void CLinearByteKernel::add_to_normal(int32_t idx, float64_t weight)
00057 {
00058     int32_t vlen;
00059     bool vfree;
00060     uint8_t* vec=((CSimpleFeatures<uint8_t>*) lhs)->get_feature_vector(idx, vlen, vfree);
00061 
00062     for (int32_t i=0; i<vlen; i++)
00063         normal[i]+= weight*normalizer->normalize_lhs(vec[i], idx);
00064 
00065     ((CSimpleFeatures<uint8_t>*) lhs)->free_feature_vector(vec, idx, vfree);
00066 }
00067 
00068 float64_t CLinearByteKernel::compute(int32_t idx_a, int32_t idx_b)
00069 {
00070   int32_t alen, blen;
00071   bool afree, bfree;
00072 
00073   uint8_t* avec=((CSimpleFeatures<uint8_t>*) lhs)->get_feature_vector(idx_a, alen, afree);
00074   uint8_t* bvec=((CSimpleFeatures<uint8_t>*) rhs)->get_feature_vector(idx_b, blen, bfree);
00075   ASSERT(alen==blen);
00076 
00077   float64_t result=CMath::dot(avec,bvec, alen);
00078 
00079   ((CSimpleFeatures<uint8_t>*) lhs)->free_feature_vector(avec, idx_a, afree);
00080   ((CSimpleFeatures<uint8_t>*) rhs)->free_feature_vector(bvec, idx_b, bfree);
00081 
00082   return result;
00083 }
00084 
00085 bool CLinearByteKernel::init_optimization(
00086     int32_t num_suppvec, int32_t* sv_idx, float64_t* alphas)
00087 {
00088     int32_t alen;
00089     bool afree;
00090 
00091     int32_t num_feat=((CSimpleFeatures<uint8_t>*) lhs)->get_num_features();
00092     ASSERT(num_feat);
00093 
00094     normal=new float64_t[num_feat];
00095     for (int32_t i=0; i<num_feat; i++)
00096         normal[i]=0;
00097 
00098     for (int32_t i=0; i<num_suppvec; i++)
00099     {
00100         uint8_t* avec=((CSimpleFeatures<uint8_t>*) lhs)->get_feature_vector(sv_idx[i], alen, afree);
00101         ASSERT(avec);
00102 
00103         for (int32_t j=0; j<num_feat; j++)
00104             normal[j]+= alphas[i] * normalizer->normalize_lhs(((float64_t) avec[j]), sv_idx[i]);
00105 
00106         ((CSimpleFeatures<uint8_t>*) lhs)->free_feature_vector(avec, 0, afree);
00107     }
00108 
00109     set_is_initialized(true);
00110     return true;
00111 }
00112 
00113 bool CLinearByteKernel::delete_optimization()
00114 {
00115     delete[] normal;
00116     normal=NULL;
00117 
00118     set_is_initialized(false);
00119 
00120     return true;
00121 }
00122 
00123 float64_t CLinearByteKernel::compute_optimized(int32_t idx_b)
00124 {
00125     int32_t blen;
00126     bool bfree;
00127 
00128     uint8_t* bvec=((CSimpleFeatures<uint8_t>*) rhs)->get_feature_vector(idx_b, blen, bfree);
00129 
00130     float64_t result=0;
00131     {
00132         for (int32_t i=0; i<blen; i++)
00133             result+= normal[i] * ((float64_t) bvec[i]);
00134     }
00135 
00136     ((CSimpleFeatures<uint8_t>*) rhs)->free_feature_vector(bvec, idx_b, bfree);
00137 
00138     return normalizer->normalize_rhs(result, idx_b);
00139 }

SHOGUN Machine Learning Toolbox - Documentation