SHOGUN
v2.0.0
|
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-2008 Soeren Sonnenburg 00008 * Written (W) 1999-2008 Gunnar Raetsch 00009 * Copyright (C) 1999-2008 Fraunhofer Institute FIRST and Max-Planck-Society 00010 */ 00011 00012 #include <shogun/ui/SGInterface.h> 00013 #include <shogun/ui/GUIKernel.h> 00014 #include <shogun/ui/GUIPluginEstimate.h> 00015 00016 #include <shogun/lib/config.h> 00017 #include <shogun/io/SGIO.h> 00018 #include <shogun/io/AsciiFile.h> 00019 #include <shogun/kernel/Kernel.h> 00020 #include <shogun/kernel/CombinedKernel.h> 00021 #include <shogun/kernel/Chi2Kernel.h> 00022 #include <shogun/kernel/LinearKernel.h> 00023 #include <shogun/kernel/string/LinearStringKernel.h> 00024 #include <shogun/kernel/string/WeightedDegreeStringKernel.h> 00025 #include <shogun/kernel/WeightedDegreeRBFKernel.h> 00026 #include <shogun/kernel/string/SpectrumMismatchRBFKernel.h> 00027 #include <shogun/kernel/string/WeightedDegreePositionStringKernel.h> 00028 #include <shogun/kernel/string/FixedDegreeStringKernel.h> 00029 #include <shogun/kernel/string/LocalityImprovedStringKernel.h> 00030 #include <shogun/kernel/string/SimpleLocalityImprovedStringKernel.h> 00031 #include <shogun/kernel/PolyKernel.h> 00032 #include <shogun/kernel/CustomKernel.h> 00033 #include <shogun/kernel/ConstKernel.h> 00034 #include <shogun/kernel/string/PolyMatchWordStringKernel.h> 00035 #include <shogun/kernel/string/PolyMatchStringKernel.h> 00036 #include <shogun/kernel/string/LocalAlignmentStringKernel.h> 00037 #include <shogun/kernel/string/MatchWordStringKernel.h> 00038 #include <shogun/kernel/string/CommWordStringKernel.h> 00039 #include <shogun/kernel/string/WeightedCommWordStringKernel.h> 00040 #include <shogun/kernel/string/CommUlongStringKernel.h> 00041 #include <shogun/kernel/string/HistogramWordStringKernel.h> 00042 #include <shogun/kernel/string/SalzbergWordStringKernel.h> 00043 #include <shogun/kernel/GaussianKernel.h> 00044 #include <shogun/kernel/GaussianShiftKernel.h> 00045 #include <shogun/kernel/SigmoidKernel.h> 00046 #include <shogun/kernel/DiagKernel.h> 00047 #include <shogun/kernel/string/OligoStringKernel.h> 00048 #include <shogun/kernel/DistanceKernel.h> 00049 #include <shogun/kernel/TensorProductPairKernel.h> 00050 #include <shogun/kernel/normalizer/AvgDiagKernelNormalizer.h> 00051 #include <shogun/kernel/normalizer/RidgeKernelNormalizer.h> 00052 #include <shogun/kernel/normalizer/FirstElementKernelNormalizer.h> 00053 #include <shogun/kernel/normalizer/IdentityKernelNormalizer.h> 00054 #include <shogun/kernel/normalizer/SqrtDiagKernelNormalizer.h> 00055 #include <shogun/kernel/normalizer/VarianceKernelNormalizer.h> 00056 #include <shogun/kernel/normalizer/ScatterKernelNormalizer.h> 00057 #include <shogun/classifier/svm/SVM.h> 00058 #include <shogun/kernel/normalizer/ZeroMeanCenterKernelNormalizer.h> 00059 #include <shogun/kernel/WaveletKernel.h> 00060 00061 #include <string.h> 00062 00063 using namespace shogun; 00064 00065 CGUIKernel::CGUIKernel(CSGInterface* ui_) 00066 : CSGObject(), ui(ui_) 00067 { 00068 kernel=NULL; 00069 } 00070 00071 CGUIKernel::~CGUIKernel() 00072 { 00073 SG_UNREF(kernel); 00074 } 00075 00076 CKernel* CGUIKernel::get_kernel() 00077 { 00078 return kernel; 00079 } 00080 00081 CKernel* CGUIKernel::create_oligo(int32_t size, int32_t k, float64_t width) 00082 { 00083 CKernel* kern=new COligoStringKernel(size, k, width); 00084 SG_DEBUG("created OligoStringKernel (%p) with size %d, k %d, width %f.\n", kern, size, k, width); 00085 00086 return kern; 00087 } 00088 00089 CKernel* CGUIKernel::create_diag(int32_t size, float64_t diag) 00090 { 00091 CKernel* kern=new CDiagKernel(size, diag); 00092 if (!kern) 00093 SG_ERROR("Couldn't create DiagKernel with size %d, diag %f.\n", size, diag); 00094 else 00095 SG_DEBUG("created DiagKernel (%p) with size %d, diag %f.\n", kern, size, diag); 00096 00097 return kern; 00098 } 00099 00100 CKernel* CGUIKernel::create_const(int32_t size, float64_t c) 00101 { 00102 CKernel* kern=new CConstKernel(c); 00103 if (!kern) 00104 SG_ERROR("Couldn't create ConstKernel with c %f.\n", c); 00105 else 00106 SG_DEBUG("created ConstKernel (%p) with c %f.\n", kern, c); 00107 00108 kern->set_cache_size(size); 00109 00110 return kern; 00111 } 00112 00113 CKernel* CGUIKernel::create_custom(float64_t* kmatrix, int32_t num_feat, int32_t num_vec, bool source_is_diag, bool dest_is_diag) 00114 { 00115 CCustomKernel* kern=new CCustomKernel(); 00116 SG_DEBUG("created CustomKernel (%p).\n", kern); 00117 00118 SGMatrix<float64_t> km=SGMatrix<float64_t>(kmatrix, num_feat, num_vec); 00119 00120 if (source_is_diag && dest_is_diag && num_feat==1) 00121 { 00122 kern->set_triangle_kernel_matrix_from_triangle( 00123 SGVector<float64_t>(kmatrix, num_vec)); 00124 } 00125 else if (!source_is_diag && dest_is_diag && num_vec==num_feat) 00126 kern->set_triangle_kernel_matrix_from_full(km); 00127 else 00128 kern->set_full_kernel_matrix_from_full(km); 00129 00130 return kern; 00131 } 00132 00133 00134 CKernel* CGUIKernel::create_gaussianshift( 00135 int32_t size, float64_t width, int32_t max_shift, int32_t shift_step) 00136 { 00137 CKernel* kern=new CGaussianShiftKernel(size, width, max_shift, shift_step); 00138 if (!kern) 00139 SG_ERROR("Couldn't create GaussianShiftKernel with size %d, width %f, max_shift %d, shift_step %d.\n", size, width, max_shift, shift_step); 00140 else 00141 SG_DEBUG("created GaussianShiftKernel (%p) with size %d, width %f, max_shift %d, shift_step %d.\n", kern, size, width, max_shift, shift_step); 00142 00143 return kern; 00144 } 00145 00146 CKernel* CGUIKernel::create_sparsegaussian(int32_t size, float64_t width) 00147 { 00148 CKernel* kern=new CGaussianKernel(size, width); 00149 if (!kern) 00150 SG_ERROR("Couldn't create GaussianKernel with size %d, width %f.\n", size, width); 00151 else 00152 SG_DEBUG("created GaussianKernel (%p) with size %d, width %f.\n", kern, size, width); 00153 00154 return kern; 00155 } 00156 00157 CKernel* CGUIKernel::create_gaussian(int32_t size, float64_t width) 00158 { 00159 CKernel* kern=new CGaussianKernel(size, width); 00160 if (!kern) 00161 SG_ERROR("Couldn't create GaussianKernel with size %d, width %f.\n", size, width); 00162 else 00163 SG_DEBUG("created GaussianKernel (%p) with size %d, width %f.\n", kern, size, width); 00164 00165 return kern; 00166 } 00167 00168 CKernel* CGUIKernel::create_sigmoid( 00169 int32_t size, float64_t gamma, float64_t coef0) 00170 { 00171 CKernel* kern=new CSigmoidKernel(size, gamma, coef0); 00172 if (!kern) 00173 SG_ERROR("Couldn't create SigmoidKernel with size %d, gamma %f, coef0 %f.\n", size, gamma, coef0); 00174 else 00175 SG_DEBUG("created SigmoidKernel (%p) with size %d, gamma %f, coef0 %f.\n", kern, size, gamma, coef0); 00176 00177 return kern; 00178 } 00179 CKernel* CGUIKernel::create_wavelet( 00180 int32_t size, float64_t Wdilation, float64_t Wtranslation) 00181 { 00182 CKernel* kern=new CWaveletKernel(size, Wdilation, Wtranslation); 00183 if (!kern) 00184 SG_ERROR("Couldn't create WaveletKernel with size %d, Wdilation %f, Wtranslation %f.\n", size, Wdilation, Wtranslation); 00185 else 00186 SG_DEBUG("created WaveletKernel (%p) with size %d, Wdilation %f, Wtranslation %f.\n", kern, size, Wdilation, Wtranslation); 00187 00188 return kern; 00189 } 00190 CKernel* CGUIKernel::create_sparsepoly( 00191 int32_t size, int32_t degree, bool inhomogene, bool normalize) 00192 { 00193 CKernel* kern=new CPolyKernel(size, degree, inhomogene); 00194 if (!normalize) 00195 kern->set_normalizer(new CIdentityKernelNormalizer()); 00196 SG_DEBUG("created PolyKernel with size %d, degree %d, inhomogene %d normalize %d.\n", kern, size, degree, inhomogene, normalize); 00197 00198 return kern; 00199 } 00200 00201 CKernel* CGUIKernel::create_poly( 00202 int32_t size, int32_t degree, bool inhomogene, bool normalize) 00203 { 00204 CKernel* kern=new CPolyKernel(size, degree, inhomogene); 00205 if (!normalize) 00206 kern->set_normalizer(new CIdentityKernelNormalizer()); 00207 SG_DEBUG("created PolyKernel (%p) with size %d, degree %d, inhomogene %d, normalize %d.\n", kern, size, degree, inhomogene, normalize); 00208 00209 return kern; 00210 } 00211 00212 CKernel* CGUIKernel::create_localityimprovedstring( 00213 int32_t size, int32_t length, int32_t inner_degree, int32_t outer_degree, 00214 EKernelType ktype) 00215 { 00216 CKernel* kern=NULL; 00217 00218 if (ktype==K_SIMPLELOCALITYIMPROVED) 00219 { 00220 kern=new CSimpleLocalityImprovedStringKernel( 00221 size, length, inner_degree, outer_degree); 00222 } 00223 else if (ktype==K_LOCALITYIMPROVED) 00224 { 00225 kern=new CLocalityImprovedStringKernel( 00226 size, length, inner_degree, outer_degree); 00227 } 00228 00229 if (!kern) 00230 SG_ERROR("Couldn't create (Simple)LocalityImprovedStringKernel with size %d, length %d, inner_degree %d, outer_degree %d.\n", size, length, inner_degree, outer_degree); 00231 else 00232 SG_DEBUG("created (Simple)LocalityImprovedStringKernel with size %d, length %d, inner_degree %d, outer_degree %d.\n", kern, size, length, inner_degree, outer_degree); 00233 00234 return kern; 00235 } 00236 00237 CKernel* CGUIKernel::create_weighteddegreestring( 00238 int32_t size, int32_t order, int32_t max_mismatch, bool use_normalization, 00239 int32_t mkl_stepsize, bool block_computation, int32_t single_degree) 00240 { 00241 float64_t* weights=get_weights(order, max_mismatch); 00242 00243 int32_t i=0; 00244 if (single_degree>=0) 00245 { 00246 ASSERT(single_degree<order); 00247 for (i=0; i<order; i++) 00248 { 00249 if (i!=single_degree) 00250 weights[i]=0; 00251 else 00252 weights[i]=1; 00253 } 00254 } 00255 00256 CKernel* kern=new CWeightedDegreeStringKernel(SGVector<float64_t>(weights, order)); 00257 00258 SG_DEBUG("created WeightedDegreeStringKernel (%p) with size %d, order %d, " 00259 "max_mismatch %d, use_normalization %d, mkl_stepsize %d, " 00260 "block_computation %d, single_degree %d.\n", 00261 kern, size, order, max_mismatch, (int) use_normalization, mkl_stepsize, 00262 block_computation, single_degree); 00263 00264 if (!use_normalization) 00265 kern->set_normalizer(new CIdentityKernelNormalizer()); 00266 00267 ((CWeightedDegreeStringKernel*) kern)-> 00268 set_use_block_computation(block_computation); 00269 ((CWeightedDegreeStringKernel*) kern)->set_max_mismatch(max_mismatch); 00270 ((CWeightedDegreeStringKernel*) kern)->set_mkl_stepsize(mkl_stepsize); 00271 ((CWeightedDegreeStringKernel*) kern)->set_which_degree(single_degree); 00272 00273 return kern; 00274 } 00275 00276 CKernel* CGUIKernel::create_weighteddegreepositionstring( 00277 int32_t size, int32_t order, int32_t max_mismatch, int32_t length, 00278 int32_t center, float64_t step) 00279 { 00280 int32_t i=0; 00281 int32_t* shifts=SG_MALLOC(int32_t, length); 00282 00283 for (i=center; i<length; i++) 00284 shifts[i]=(int32_t) floor(((float64_t) (i-center))/step); 00285 00286 for (i=center-1; i>=0; i--) 00287 shifts[i]=(int32_t) floor(((float64_t) (center-i))/step); 00288 00289 for (i=0; i<length; i++) 00290 { 00291 if (shifts[i]>length) 00292 shifts[i]=length; 00293 } 00294 00295 for (i=0; i<length; i++) 00296 SG_INFO( "shift[%i]=%i\n", i, shifts[i]); 00297 00298 float64_t* weights=get_weights(order, max_mismatch); 00299 00300 CKernel* kern=new CWeightedDegreePositionStringKernel(size, weights, order, max_mismatch, shifts, length); 00301 if (!kern) 00302 SG_ERROR("Couldn't create WeightedDegreePositionStringKernel with size %d, order %d, max_mismatch %d, length %d, center %d, step %f.\n", size, order, max_mismatch, length, center, step); 00303 else 00304 SG_DEBUG("created WeightedDegreePositionStringKernel with size %d, order %d, max_mismatch %d, length %d, center %d, step %f.\n", kern, size, order, max_mismatch, length, center, step); 00305 00306 SG_FREE(weights); 00307 SG_FREE(shifts); 00308 return kern; 00309 } 00310 00311 CKernel* CGUIKernel::create_weighteddegreepositionstring3( 00312 int32_t size, int32_t order, int32_t max_mismatch, int32_t* shifts, 00313 int32_t length, int32_t mkl_stepsize, float64_t* position_weights) 00314 { 00315 float64_t* weights=get_weights(order, max_mismatch); 00316 00317 CKernel* kern=new CWeightedDegreePositionStringKernel(size, weights, order, max_mismatch, shifts, length, mkl_stepsize); 00318 kern->set_normalizer(new CIdentityKernelNormalizer()); 00319 00320 SG_DEBUG("created WeightedDegreePositionStringKernel (%p) with size %d, order %d, max_mismatch %d, length %d and position_weights (MKL stepsize: %d).\n", kern, size, order, max_mismatch, length, mkl_stepsize); 00321 00322 if (!position_weights) 00323 { 00324 position_weights=SG_MALLOC(float64_t, length); 00325 for (int32_t i=0; i<length; i++) 00326 position_weights[i]=1.0/length; 00327 } 00328 ((CWeightedDegreePositionStringKernel*) kern)-> 00329 set_position_weights(SGVector<float64_t>(position_weights, length)); 00330 00331 SG_FREE(weights); 00332 return kern; 00333 } 00334 00335 CKernel* CGUIKernel::create_weighteddegreepositionstring2( 00336 int32_t size, int32_t order, int32_t max_mismatch, int32_t* shifts, 00337 int32_t length, bool use_normalization) 00338 { 00339 float64_t* weights=get_weights(order, max_mismatch); 00340 00341 CKernel* kern=new CWeightedDegreePositionStringKernel(size, weights, order, max_mismatch, shifts, length); 00342 if (!use_normalization) 00343 kern->set_normalizer(new CIdentityKernelNormalizer()); 00344 00345 00346 SG_DEBUG("created WeightedDegreePositionStringKernel (%p) with size %d, order %d, max_mismatch %d, length %d, use_normalization %d.\n", kern, size, order, max_mismatch, length, use_normalization); 00347 00348 SG_FREE(weights); 00349 return kern; 00350 } 00351 00352 float64_t* CGUIKernel::get_weights(int32_t order, int32_t max_mismatch) 00353 { 00354 float64_t *weights=SG_MALLOC(float64_t, order*(1+max_mismatch)); 00355 float64_t sum=0; 00356 int32_t i=0; 00357 00358 for (i=0; i<order; i++) 00359 { 00360 weights[i]=order-i; 00361 sum+=weights[i]; 00362 } 00363 for (i=0; i<order; i++) 00364 weights[i]/=sum; 00365 00366 for (i=0; i<order; i++) 00367 { 00368 for (int32_t j=1; j<=max_mismatch; j++) 00369 { 00370 if (j<i+1) 00371 { 00372 int32_t nk=CMath::nchoosek(i+1, j); 00373 weights[i+j*order]=weights[i]/(nk*CMath::pow(3, j)); 00374 } 00375 else 00376 weights[i+j*order]=0; 00377 } 00378 } 00379 00380 return weights; 00381 } 00382 00383 CKernel* CGUIKernel::create_weighteddegreerbf(int32_t size, int32_t degree, int32_t nof_properties, float64_t width) 00384 { 00385 CKernel* kern=new CWeightedDegreeRBFKernel(size, width, degree, nof_properties); 00386 if (!kern) 00387 SG_ERROR("Couldn't create WeightedDegreeRBFKernel with size %d, width %f, degree %d, nof_properties %d.\n", size, width, degree, nof_properties); 00388 else 00389 SG_DEBUG("created WeightedDegreeRBFKernel (%p) with size %d, width %f, degree %d, nof_properties %d.\n", kern, size, width, degree, nof_properties); 00390 00391 return kern; 00392 } 00393 00394 CKernel* CGUIKernel::create_spectrummismatchrbf(int32_t size, float64_t* AA_matrix, int32_t nr, int32_t nc, int32_t max_mismatch, int32_t degree, float64_t width) 00395 { 00396 00397 CKernel* kern = new CSpectrumMismatchRBFKernel(size, AA_matrix, nr, nc, degree, max_mismatch, width); 00398 if (!kern) 00399 SG_ERROR("Couldn't create SpectrumMismatchRBFKernel with size %d, width %f, degree %d, max_mismatch %d.\n", size, width, degree, max_mismatch); 00400 else 00401 SG_DEBUG("created SpectrumMismatchRBFKernel (%p) with size %d, width %f, degree %d, max_mismatch %d.\n", kern, size, width, degree, max_mismatch); 00402 00403 return kern; 00404 00405 } 00406 00407 00408 CKernel* CGUIKernel::create_localalignmentstring(int32_t size) 00409 { 00410 CKernel* kern=new CLocalAlignmentStringKernel(size); 00411 if (!kern) 00412 SG_ERROR("Couldn't create LocalAlignmentStringKernel with size %d.\n", size); 00413 else 00414 SG_DEBUG("created LocalAlignmentStringKernel (%p) with size %d.\n", kern, size); 00415 00416 return kern; 00417 } 00418 00419 CKernel* CGUIKernel::create_fixeddegreestring(int32_t size, int32_t d) 00420 { 00421 CKernel* kern=new CFixedDegreeStringKernel(size, d); 00422 if (!kern) 00423 SG_ERROR("Couldn't create FixedDegreeStringKernel with size %d and d %d.\n", size, d); 00424 else 00425 SG_DEBUG("created FixedDegreeStringKernel (%p) with size %d and d %d.\n", kern, size, d); 00426 00427 return kern; 00428 } 00429 00430 CKernel* CGUIKernel::create_chi2(int32_t size, float64_t width) 00431 { 00432 CKernel* kern=new CChi2Kernel(size, width); 00433 if (!kern) 00434 SG_ERROR("Couldn't create Chi2Kernel with size %d and width %f.\n", size, width); 00435 else 00436 SG_DEBUG("created Chi2Kernel (%p) with size %d and width %f.\n", kern, size, width); 00437 00438 return kern; 00439 } 00440 00441 CKernel* CGUIKernel::create_commstring( 00442 int32_t size, bool use_sign, char* norm_str, EKernelType ktype) 00443 { 00444 CKernel* kern=NULL; 00445 00446 if (!norm_str) 00447 norm_str= (char*) "FULL"; 00448 00449 if (ktype==K_COMMULONGSTRING) 00450 kern=new CCommUlongStringKernel(size, use_sign); 00451 else if (ktype==K_COMMWORDSTRING) 00452 kern=new CCommWordStringKernel(size, use_sign); 00453 else if (ktype==K_WEIGHTEDCOMMWORDSTRING) 00454 kern=new CWeightedCommWordStringKernel(size, use_sign); 00455 00456 SG_DEBUG("created WeightedCommWord/CommWord/CommUlongStringKernel (%p) with size %d, use_sign %d norm_str %s.\n", kern, size, use_sign, norm_str); 00457 00458 00459 if (strncmp(norm_str, "NO", 2)==0) 00460 { 00461 kern->set_normalizer(new CIdentityKernelNormalizer()); 00462 } 00463 else if (strncmp(norm_str, "FULL", 4)==0) 00464 { 00465 //nop, as this one is default 00466 } 00467 else 00468 SG_ERROR("Unsupported Normalizer requested, supports only FULL and NO\n"); 00469 00470 return kern; 00471 } 00472 00473 CKernel* CGUIKernel::create_matchwordstring( 00474 int32_t size, int32_t d, bool normalize) 00475 { 00476 CKernel* kern=new CMatchWordStringKernel(size, d); 00477 SG_DEBUG("created MatchWordStringKernel (%p) with size %d and d %d.\n", kern, size, d); 00478 if (!normalize) 00479 kern->set_normalizer(new CIdentityKernelNormalizer()); 00480 00481 return kern; 00482 } 00483 00484 CKernel* CGUIKernel::create_polymatchstring( 00485 int32_t size, int32_t degree, bool inhomogene, bool normalize) 00486 { 00487 CKernel* kern=new CPolyMatchStringKernel(size, degree, inhomogene); 00488 SG_DEBUG("created PolyMatchStringKernel (%p) with size %d, degree %d, inhomogene %d normalize %d.\n", kern, size, degree, inhomogene, normalize); 00489 if (!normalize) 00490 kern->set_normalizer(new CIdentityKernelNormalizer()); 00491 00492 return kern; 00493 } 00494 00495 CKernel* CGUIKernel::create_polymatchwordstring( 00496 int32_t size, int32_t degree, bool inhomogene, bool normalize) 00497 { 00498 CKernel* kern=new CPolyMatchWordStringKernel(size, degree, inhomogene); 00499 SG_DEBUG("created PolyMatchWordStringKernel (%p) with size %d, degree %d, inhomogene %d, normalize %d.\n", kern, size, degree, inhomogene, normalize); 00500 if (!normalize) 00501 kern->set_normalizer(new CIdentityKernelNormalizer()); 00502 00503 return kern; 00504 } 00505 00506 CKernel* CGUIKernel::create_salzbergword(int32_t size) 00507 { 00508 SG_INFO("Getting estimator.\n"); 00509 CPluginEstimate* estimator=ui->ui_pluginestimate->get_estimator(); 00510 if (!estimator) 00511 SG_ERROR("No estimator set.\n"); 00512 00513 CKernel* kern=new CSalzbergWordStringKernel(size, estimator); 00514 if (!kern) 00515 SG_ERROR("Couldn't create SalzbergWordString with size %d.\n", size); 00516 else 00517 SG_DEBUG("created SalzbergWordString (%p) with size %d.\n", kern, size); 00518 00519 /* 00520 // prior stuff 00521 SG_INFO("Getting labels.\n"); 00522 CLabels* train_labels=ui->ui_labels->get_train_labels(); 00523 if (!train_labels) 00524 { 00525 SG_INFO("Assign train labels first!\n"); 00526 return NULL; 00527 } 00528 ((CSalzbergWordStringKernel *) kern)->set_prior_probs_from_labels(train_labels); 00529 */ 00530 00531 return kern; 00532 } 00533 00534 CKernel* CGUIKernel::create_histogramword(int32_t size) 00535 { 00536 SG_INFO("Getting estimator.\n"); 00537 CPluginEstimate* estimator=ui->ui_pluginestimate->get_estimator(); 00538 if (!estimator) 00539 SG_ERROR("No estimator set.\n"); 00540 00541 CKernel* kern=new CHistogramWordStringKernel(size, estimator); 00542 if (!kern) 00543 SG_ERROR("Couldn't create HistogramWordString with size %d.\n", size); 00544 else 00545 SG_DEBUG("created HistogramWordString (%p) with size %d.\n", kern, size); 00546 00547 return kern; 00548 } 00549 00550 CKernel* CGUIKernel::create_linearbyte(int32_t size, float64_t scale) 00551 { 00552 size=0; 00553 CKernel* kern=new CLinearKernel(); 00554 kern->set_normalizer(new CAvgDiagKernelNormalizer(scale)); 00555 SG_DEBUG("created LinearByteKernel (%p) with size %d and scale %f.\n", kern, size, scale); 00556 00557 return kern; 00558 } 00559 00560 CKernel* CGUIKernel::create_linearword(int32_t size, float64_t scale) 00561 { 00562 size=0; 00563 CKernel* kern=new CLinearKernel(); 00564 kern->set_normalizer(new CAvgDiagKernelNormalizer(scale)); 00565 SG_DEBUG("created LinearWordKernel (%p) with size %d and scale %f.\n", kern, size, scale); 00566 00567 return kern; 00568 } 00569 00570 CKernel* CGUIKernel::create_linearstring(int32_t size, float64_t scale) 00571 { 00572 size=0; 00573 CKernel* kern=NULL; 00574 kern=new CLinearStringKernel(); 00575 kern->set_normalizer(new CAvgDiagKernelNormalizer(scale)); 00576 00577 SG_DEBUG("created LinearStringKernel (%p) with size %d and scale %f.\n", kern, size, scale); 00578 00579 return kern; 00580 } 00581 00582 CKernel* CGUIKernel::create_linear(int32_t size, float64_t scale) 00583 { 00584 size=0; 00585 CKernel* kern=new CLinearKernel(); 00586 kern->set_normalizer(new CAvgDiagKernelNormalizer(scale)); 00587 00588 SG_DEBUG("created LinearKernel (%p) with size %d and scale %f.\n", kern, size, scale); 00589 00590 return kern; 00591 } 00592 00593 CKernel* CGUIKernel::create_sparselinear(int32_t size, float64_t scale) 00594 { 00595 size=0; 00596 CKernel* kern=new CLinearKernel(); 00597 kern->set_normalizer(new CAvgDiagKernelNormalizer(scale)); 00598 00599 SG_DEBUG("created LinearKernel (%p) with size %d and scale %f.\n", kern, size, scale); 00600 00601 return kern; 00602 } 00603 00604 CKernel* CGUIKernel::create_tppk(int32_t size, float64_t* km, int32_t rows, int32_t cols) 00605 { 00606 CCustomKernel* k=new CCustomKernel(); 00607 k->set_full_kernel_matrix_from_full(SGMatrix<float64_t>(km, rows, cols)); 00608 00609 CKernel* kern=new CTensorProductPairKernel(size, k); 00610 00611 SG_DEBUG("created TPPK (%p) with size %d and km %p, rows %d, cols %d.\n", kern, size, km, rows, cols); 00612 00613 return kern; 00614 } 00615 00616 CKernel* CGUIKernel::create_distance(int32_t size, float64_t width) 00617 { 00618 CDistance* dist=ui->ui_distance->get_distance(); 00619 if (!dist) 00620 SG_ERROR("No distance set for DistanceKernel.\n"); 00621 00622 CKernel* kern=new CDistanceKernel(size, width, dist); 00623 if (!kern) 00624 SG_ERROR("Couldn't create DistanceKernel with size %d and width %f.\n", size, width); 00625 else 00626 SG_DEBUG("created DistanceKernel (%p) with size %d and width %f.\n", kern, size, width); 00627 00628 return kern; 00629 } 00630 00631 CKernel* CGUIKernel::create_combined( 00632 int32_t size, bool append_subkernel_weights) 00633 { 00634 CKernel* kern=new CCombinedKernel(size, append_subkernel_weights); 00635 if (!kern) 00636 SG_ERROR("Couldn't create CombinedKernel with size %d and append_subkernel_weights %d.\n", size, append_subkernel_weights); 00637 else 00638 SG_DEBUG("created CombinedKernel (%p) with size %d and append_subkernel_weights %d.\n", kern, size, append_subkernel_weights); 00639 00640 return kern; 00641 } 00642 00643 bool CGUIKernel::set_normalization(char* normalization, float64_t c, float64_t r) 00644 { 00645 CKernel* k=kernel; 00646 00647 if (k && k->get_kernel_type()==K_COMBINED) 00648 k=((CCombinedKernel*) kernel)->get_last_kernel(); 00649 00650 if (!k) 00651 SG_ERROR("No kernel available.\n"); 00652 00653 if (strncmp(normalization, "IDENTITY", 8)==0) 00654 { 00655 SG_INFO("Identity Normalization (==NO NORMALIZATION) selected\n"); 00656 return k->set_normalizer(new CIdentityKernelNormalizer()); 00657 } 00658 else if (strncmp(normalization,"AVGDIAG", 7)==0) 00659 { 00660 SG_INFO("Average Kernel Diagonal Normalization selected\n"); 00661 return k->set_normalizer(new CAvgDiagKernelNormalizer(c)); 00662 } 00663 else if (strncmp(normalization,"RIDGE", 5)==0) 00664 { 00665 SG_INFO("Ridge Kernel Normalization selected\n"); 00666 return k->set_normalizer(new CRidgeKernelNormalizer(r, c)); 00667 } 00668 else if (strncmp(normalization,"SQRTDIAG", 8)==0) 00669 { 00670 SG_INFO("Sqrt Diagonal Normalization selected\n"); 00671 return k->set_normalizer(new CSqrtDiagKernelNormalizer()); 00672 } 00673 else if (strncmp(normalization,"FIRSTELEMENT", 12)==0) 00674 { 00675 SG_INFO("First Element Normalization selected\n"); 00676 return k->set_normalizer(new CFirstElementKernelNormalizer()); 00677 } 00678 else if (strncmp(normalization,"VARIANCE", 8)==0) 00679 { 00680 SG_INFO("Variance Normalization selected\n"); 00681 return k->set_normalizer(new CVarianceKernelNormalizer()); 00682 } 00683 else if (strncmp(normalization,"SCATTER", 7)==0) 00684 { 00685 SG_INFO("Scatter Normalization selected\n"); 00686 CLabels* train_labels=ui->ui_labels->get_train_labels(); 00687 ASSERT(train_labels); 00688 return k->set_normalizer(new CScatterKernelNormalizer(c,r, train_labels)); 00689 } 00690 else if (strncmp(normalization,"ZEROMEANCENTER", 13)==0) 00691 { 00692 SG_INFO("Zero Mean Center Normalization selected\n"); 00693 return k->set_normalizer(new CZeroMeanCenterKernelNormalizer()); 00694 } 00695 else 00696 SG_ERROR("Wrong kernel normalizer name.\n"); 00697 00698 SG_UNREF(k); 00699 00700 return false; 00701 } 00702 00703 bool CGUIKernel::set_kernel(CKernel* kern) 00704 { 00705 if (kern) 00706 { 00707 SG_DEBUG("deleting old kernel (%p).\n", kernel); 00708 SG_UNREF(kernel); 00709 SG_REF(kern); 00710 kernel=kern; 00711 SG_DEBUG("set new kernel (%p).\n", kern); 00712 00713 return true; 00714 } 00715 else 00716 return false; 00717 } 00718 00719 bool CGUIKernel::init_kernel_optimization() 00720 { 00721 CSVM* svm=(CSVM*) ui->ui_classifier->get_classifier(); 00722 if (svm) 00723 { 00724 if (kernel->has_property(KP_LINADD)) 00725 { 00726 int32_t num_sv=svm->get_num_support_vectors(); 00727 int32_t* sv_idx=SG_MALLOC(int32_t, num_sv); 00728 float64_t* sv_weight=SG_MALLOC(float64_t, num_sv); 00729 00730 for (int32_t i=0; i<num_sv; i++) 00731 { 00732 sv_idx[i]=svm->get_support_vector(i); 00733 sv_weight[i]=svm->get_alpha(i); 00734 } 00735 00736 bool ret=kernel->init_optimization(num_sv, sv_idx, sv_weight); 00737 00738 SG_FREE(sv_idx); 00739 SG_FREE(sv_weight); 00740 00741 if (!ret) 00742 SG_ERROR("Initialization of kernel optimization failed\n"); 00743 return ret; 00744 } 00745 } 00746 else 00747 SG_ERROR("Create SVM first!\n"); 00748 00749 return true; 00750 } 00751 00752 bool CGUIKernel::delete_kernel_optimization() 00753 { 00754 if (kernel && kernel->has_property(KP_LINADD) && kernel->get_is_initialized()) 00755 kernel->delete_optimization(); 00756 00757 return true; 00758 } 00759 00760 00761 bool CGUIKernel::init_kernel(const char* target) 00762 { 00763 if (!kernel) 00764 SG_ERROR("No kernel available.\n"); 00765 00766 // no need to init custom kernel 00767 if (kernel->get_kernel_type() == K_CUSTOM || !target) 00768 { 00769 initialized=true; 00770 return true; 00771 } 00772 00773 EFeatureClass k_fclass=kernel->get_feature_class(); 00774 EFeatureType k_ftype=kernel->get_feature_type(); 00775 00776 if (!strncmp(target, "TRAIN", 5)) 00777 { 00778 CFeatures* train=ui->ui_features->get_train_features(); 00779 00780 if (train) 00781 { 00782 EFeatureClass fclass=train->get_feature_class(); 00783 EFeatureType ftype=train->get_feature_type(); 00784 if ((k_fclass==fclass || k_fclass==C_ANY || fclass==C_ANY) && 00785 (k_ftype==ftype || k_ftype==F_ANY || ftype==F_ANY)) 00786 00787 { 00788 SG_INFO("Initialising kernel with TRAIN DATA, train: %p\n", train); 00789 kernel->init(train, train); 00790 initialized=true; 00791 } 00792 else 00793 SG_ERROR("Kernel can not process this train feature type: %d %d.\n", fclass, ftype); 00794 } 00795 else 00796 SG_DEBUG("Not initing kernel - no train features assigned.\n"); 00797 } 00798 else if (!strncmp(target, "TEST", 4)) 00799 { 00800 CFeatures* train=ui->ui_features->get_train_features(); 00801 CFeatures* test=ui->ui_features->get_test_features(); 00802 if (train && test) 00803 { 00804 EFeatureClass fclass=test->get_feature_class(); 00805 EFeatureType ftype=test->get_feature_type(); 00806 if ((k_fclass==fclass || k_fclass==C_ANY || fclass==C_ANY) && 00807 (k_ftype==ftype || k_ftype==F_ANY || ftype==F_ANY)) 00808 00809 { 00810 if (!initialized) 00811 { 00812 EFeatureClass tr_fclass=train->get_feature_class(); 00813 EFeatureType tr_ftype=train->get_feature_type(); 00814 if ((k_fclass==tr_fclass || k_fclass==C_ANY || tr_fclass==C_ANY) && 00815 (k_ftype==tr_ftype || k_ftype==F_ANY || tr_ftype==F_ANY)) 00816 { 00817 SG_INFO("Initialising kernel with TRAIN DATA, train: %p\n", train); 00818 kernel->init(train, train); 00819 initialized=true; 00820 } 00821 else 00822 SG_ERROR("Kernel can not process this train feature type: %d %d.\n", fclass, ftype); 00823 } 00824 00825 SG_INFO("Initialising kernel with TEST DATA, train: %p test %p\n", train, test); 00826 // lhs -> always train_features; rhs -> always test_features 00827 kernel->init(train, test); 00828 } 00829 else 00830 SG_ERROR("Kernel can not process this test feature type: %d %d.\n", fclass, ftype); 00831 } 00832 else 00833 SG_DEBUG("Not initing kernel - no train and test features assigned.\n"); 00834 } 00835 else 00836 SG_ERROR("Unknown target %s.\n", target); 00837 00838 return true; 00839 } 00840 00841 bool CGUIKernel::save_kernel(char* filename) 00842 { 00843 if (kernel && initialized) 00844 { 00845 CAsciiFile* file=new CAsciiFile(filename); 00846 try 00847 { 00848 kernel->save(file); 00849 } 00850 catch (...) 00851 { 00852 SG_ERROR("Writing to file %s failed!\n", filename); 00853 } 00854 00855 SG_UNREF(file); 00856 SG_INFO("Successfully written kernel to \"%s\" !\n", filename); 00857 return true; 00858 } 00859 else 00860 SG_ERROR("No kernel set / kernel not initialized!\n"); 00861 00862 return false; 00863 } 00864 00865 bool CGUIKernel::add_kernel(CKernel* kern, float64_t weight) 00866 { 00867 if (!kern) 00868 SG_ERROR("Given kernel to add is invalid.\n"); 00869 00870 if (!kernel) 00871 { 00872 kernel= new CCombinedKernel(20, false); 00873 SG_REF(kernel); 00874 } 00875 00876 if (kernel->get_kernel_type()!=K_COMBINED) 00877 { 00878 CKernel* first_elem=kernel; 00879 kernel= new CCombinedKernel(20, false); 00880 SG_REF(kernel); 00881 ((CCombinedKernel*) kernel)->append_kernel(first_elem); 00882 } 00883 00884 if (!kernel) 00885 SG_ERROR("Combined kernel object could not be created.\n"); 00886 00887 kern->set_combined_kernel_weight(weight); 00888 00889 bool success=((CCombinedKernel*) kernel)->append_kernel(kern); 00890 00891 initialized=true; 00892 if (success) 00893 ((CCombinedKernel*) kernel)->list_kernels(); 00894 else 00895 SG_ERROR("Adding of kernel failed.\n"); 00896 00897 return success; 00898 } 00899 00900 00901 bool CGUIKernel::del_last_kernel() 00902 { 00903 if (!kernel) 00904 SG_ERROR("No kernel available.\n"); 00905 00906 if (kernel->get_kernel_type()!=K_COMBINED) 00907 SG_ERROR("Need a combined kernel for deleting the last kernel in it.\n"); 00908 00909 CKernel* last=((CCombinedKernel*) kernel)->get_last_kernel(); 00910 if (last) 00911 return ((CCombinedKernel*) kernel)->delete_kernel(); 00912 else 00913 SG_ERROR("No kernel available to delete.\n"); 00914 00915 return false; 00916 } 00917 00918 bool CGUIKernel::clean_kernel() 00919 { 00920 SG_UNREF(kernel); 00921 kernel=NULL; 00922 return true; 00923 } 00924 00925 #ifdef USE_SVMLIGHT 00926 bool CGUIKernel::resize_kernel_cache(int32_t size) 00927 { 00928 if (!kernel) 00929 SG_ERROR("No kernel available.\n"); 00930 00931 kernel->resize_kernel_cache(size); 00932 return true; 00933 } 00934 #endif //USE_SVMLIGHT 00935 00936 bool CGUIKernel::set_optimization_type(char* opt_type) 00937 { 00938 EOptimizationType opt=SLOWBUTMEMEFFICIENT; 00939 if (!kernel) 00940 SG_ERROR("No kernel available.\n"); 00941 00942 if (strncmp(opt_type, "FASTBUTMEMHUNGRY", 16)==0) 00943 { 00944 SG_INFO("FAST METHOD selected\n"); 00945 opt=FASTBUTMEMHUNGRY; 00946 kernel->set_optimization_type(opt); 00947 00948 return true; 00949 } 00950 else if (strncmp(opt_type,"SLOWBUTMEMEFFICIENT", 19)==0) 00951 { 00952 SG_INFO("MEMORY EFFICIENT METHOD selected\n"); 00953 opt=SLOWBUTMEMEFFICIENT; 00954 kernel->set_optimization_type(opt); 00955 00956 return true; 00957 } 00958 else 00959 SG_ERROR("Wrong kernel optimization type.\n"); 00960 00961 return false; 00962 } 00963 00964 bool CGUIKernel::precompute_subkernels() 00965 { 00966 if (!kernel) 00967 SG_ERROR("No kernel available.\n"); 00968 00969 if (kernel->get_kernel_type()!=K_COMBINED) 00970 SG_ERROR("Not a combined kernel.\n"); 00971 00972 return ((CCombinedKernel*) kernel)->precompute_subkernels(); 00973 }