00001
00002
00003
00004
00005
00006
00007
00008
00009
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
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
00521
00522
00523
00524
00525
00526
00527
00528
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
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
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 }