LinearWordKernel.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/LinearWordKernel.h"
00015 #include "features/SimpleFeatures.h"
00016 
00017 using namespace shogun;
00018 
00019 CLinearWordKernel::CLinearWordKernel()
00020 : CSimpleKernel<uint16_t>(0), normal(NULL)
00021 {
00022 }
00023 
00024 CLinearWordKernel::CLinearWordKernel(CSimpleFeatures<uint16_t>* l, CSimpleFeatures<uint16_t>* r)
00025 : CSimpleKernel<uint16_t>(0), normal(NULL)
00026 {
00027     init(l, r);
00028 }
00029 
00030 CLinearWordKernel::~CLinearWordKernel()
00031 {
00032     cleanup();
00033 }
00034 
00035 bool CLinearWordKernel::init(CFeatures* l, CFeatures* r)
00036 {
00037     CSimpleKernel<uint16_t>::init(l, r);
00038     return init_normalizer();
00039 }
00040 
00041 void CLinearWordKernel::cleanup()
00042 {
00043     delete_optimization();
00044 
00045     CKernel::cleanup();
00046 }
00047 
00048 void CLinearWordKernel::clear_normal()
00049 {
00050     int32_t num = lhs->get_num_vectors();
00051     CMath::fill_vector(normal, num, 0.0);
00052 }
00053 
00054 void CLinearWordKernel::add_to_normal(int32_t idx, float64_t weight)
00055 {
00056     int32_t vlen;
00057     bool vfree;
00058     uint16_t* vec=((CSimpleFeatures<uint16_t>*) lhs)->get_feature_vector(idx, vlen, vfree);
00059 
00060     for (int32_t i=0; i<vlen; i++)
00061         normal[i]+= weight*normalizer->normalize_lhs(vec[i], idx);
00062 
00063     ((CSimpleFeatures<uint16_t>*) lhs)->free_feature_vector(vec, idx, vfree);
00064 }
00065 
00066 float64_t CLinearWordKernel::compute(int32_t idx_a, int32_t idx_b)
00067 {
00068     int32_t alen, blen;
00069     bool afree, bfree;
00070 
00071     uint16_t* avec=((CSimpleFeatures<uint16_t>*) lhs)->get_feature_vector(
00072         idx_a, alen, afree);
00073     uint16_t* bvec=((CSimpleFeatures<uint16_t>*) rhs)->get_feature_vector(
00074         idx_b, blen, bfree);
00075     ASSERT(alen==blen);
00076 
00077     float64_t result=CMath::dot(avec, bvec, alen);
00078 
00079     ((CSimpleFeatures<uint16_t>*) lhs)->free_feature_vector(avec, idx_a, afree);
00080     ((CSimpleFeatures<uint16_t>*) rhs)->free_feature_vector(bvec, idx_b, bfree);
00081 
00082     return result;
00083 }
00084 
00085 bool CLinearWordKernel::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<uint16_t>*) lhs)->get_num_features();
00092     ASSERT(num_feat);
00093 
00094     normal=new float64_t[num_feat];
00095     CMath::fill_vector(normal, num_feat, 0.0);
00096 
00097     for (int32_t i=0; i<num_suppvec; i++)
00098     {
00099         uint16_t* avec=((CSimpleFeatures<uint16_t>*) lhs)->get_feature_vector(
00100             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(
00105                 ((float64_t) avec[j]), sv_idx[i]);
00106 
00107         ((CSimpleFeatures<uint16_t>*) lhs)->free_feature_vector(avec, 0, afree);
00108     }
00109 
00110     set_is_initialized(true);
00111     return true;
00112 }
00113 
00114 bool CLinearWordKernel::delete_optimization()
00115 {
00116     delete[] normal;
00117     normal=NULL;
00118     set_is_initialized(false);
00119 
00120     return true;
00121 }
00122 
00123 float64_t CLinearWordKernel::compute_optimized(int32_t idx_b) 
00124 {
00125     int32_t blen;
00126     bool bfree;
00127 
00128     uint16_t* bvec=((CSimpleFeatures<uint16_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<uint16_t>*) rhs)->free_feature_vector(bvec, idx_b, bfree);
00137 
00138     return normalizer->normalize_rhs(result, idx_b);
00139 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation