Changeset 3531:026914bc603e in orange


Ignore:
Timestamp:
04/13/07 12:22:56 (7 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
8d15a4816396bf73576f950d4faf7c691d77f9f9
Message:

updated to libSVM 2.83

File:
1 edited

Legend:

Unmodified
Added
Removed
  • source/orange/svm.cpp

    r3451 r3531  
    3737#endif 
    3838 
    39 /* CHANGES TO LIBSVM-2.81 
    40  *-#include "svm.h" to #include"svm.hpp" 
     39/* CHANGES TO LIBSVM-2.83 
     40 *-#include "svm.h" to #include"svm.ppp" 
    4141 *-commented the swap function definition due to conflict with std::swap 
    4242 *-added #ifdef around min max definitions 
     
    5757#include <string.h> 
    5858#include <stdarg.h> 
    59 #include <errno.h> 
    6059#include "svm.ppp" 
    6160typedef float Qfloat; 
    6261typedef signed char schar; 
    63 #if _MSC_VER!=0 && _MSC_VER<1300 
    6462#ifndef min 
    6563template <class T> inline T min(T x,T y) { return (x<y)?x:y; } 
     
    6967#endif 
    7068//template <class T> inline void swap(T& x, T& y) { T t=x; x=y; y=t; } 
    71 #endif 
    7269template <class S, class T> inline void clone(T*& dst, S* src, int n) 
    7370{ 
    7471    dst = new T[n]; 
    7572    memcpy((void *)dst,(void *)src,sizeof(T)*n); 
     73} 
     74inline double powi(double base, int times) 
     75{ 
     76        double tmp = base, ret = 1.0; 
     77 
     78        for(int t=times; t>0; t/=2) 
     79    { 
     80                if(t%2==1) ret*=tmp; 
     81                tmp = tmp * tmp; 
     82        } 
     83        return ret; 
    7684} 
    7785#define INF HUGE_VAL 
     
    260268    // svm_parameter 
    261269    const int kernel_type; 
    262     const double degree; 
     270    const int degree; 
    263271    const double gamma; 
    264272    const double coef0; 
     
    272280    double kernel_poly(int i, int j) const 
    273281    { 
    274         return pow(gamma*dot(x[i],x[j])+coef0,degree); 
     282        return powi(gamma*dot(x[i],x[j])+coef0,degree); 
    275283    } 
    276284    double kernel_rbf(int i, int j) const 
     
    281289    { 
    282290        return tanh(gamma*dot(x[i],x[j])+coef0); 
     291    } 
     292    double kernel_precomputed(int i, int j) const 
     293    { 
     294        return x[i][(int)(x[j][0].value)].value; 
    283295    } 
    284296    double  kernel_custom(int i, int j) const 
     
    308320            kernel_function = &Kernel::kernel_sigmoid; 
    309321            break; 
     322        case PRECOMPUTED: 
     323            kernel_function = &Kernel::kernel_precomputed; 
     324            break; 
    310325        case CUSTOM: 
    311326            kernel_function = &Kernel::kernel_custom; 
     
    360375            return dot(x,y); 
    361376        case POLY: 
    362             return pow(param.gamma*dot(x,y)+param.coef0,param.degree); 
     377            return powi(param.gamma*dot(x,y)+param.coef0,param.degree); 
    363378        case RBF: 
    364379        { 
     
    404419        case SIGMOID: 
    405420            return tanh(param.gamma*dot(x,y)+param.coef0); 
     421        case PRECOMPUTED:  //x: test (validation), y: SV 
     422            return x[(int)(y->value)].value; 
    406423        case CUSTOM: 
    407424        { 
    408             while(y->index!=-1) 
     425            while(y->index!=-1) // the value in the last svm_node is the index of the training example 
    409426                ++y; 
    410427            while(x->index!=-1) 
     
    20732090            svm_destroy_model(submodel); 
    20742091            svm_destroy_param(&subparam); 
    2075             free(subprob.x); 
    2076             free(subprob.y); 
    2077         } 
     2092        } 
     2093        free(subprob.x); 
     2094        free(subprob.y); 
    20782095    }        
    20792096    sigmoid_train(prob->l,dec_values,prob->y,probA,probB); 
     
    25882605 
    25892606        int p=0; 
    2590         int pos=0; 
    25912607        for(i=0;i<nr_class;i++) 
    25922608            for(int j=i+1;j<nr_class;j++) 
     
    26052621                for(k=0;k<cj;k++) 
    26062622                    sum += coef2[sj+k] * kvalue[sj+k]; 
    2607                 sum -= model->rho[p++]; 
    2608                 dec_values[pos++] = sum; 
     2623                sum -= model->rho[p]; 
     2624                dec_values[p] = sum; 
     2625                p++; 
    26092626            } 
    26102627 
     
    27042721const char *kernel_type_table[]= 
    27052722{ 
    2706     "linear","polynomial","rbf","sigmoid",NULL 
     2723    "linear","polynomial","rbf","sigmoid","precomputed",NULL 
    27072724}; 
    27082725 
     
    27182735 
    27192736    if(param.kernel_type == POLY) 
    2720         fprintf(fp,"degree %g\n", param.degree); 
     2737        fprintf(fp,"degree %d\n", param.degree); 
    27212738 
    27222739    if(param.kernel_type == POLY || param.kernel_type == RBF || param.kernel_type == SIGMOID) 
     
    27792796 
    27802797        const svm_node *p = SV[i]; 
    2781         while(p->index != -1) 
    2782         { 
    2783             fprintf(fp,"%d:%.8g ",p->index,p->value); 
    2784             p++; 
    2785         } 
     2798 
     2799        if(param.kernel_type == PRECOMPUTED) 
     2800            fprintf(fp,"0:%d ",(int)(p->value)); 
     2801        else 
     2802            while(p->index != -1) 
     2803            { 
     2804                fprintf(fp,"%d:%.8g ",p->index,p->value); 
     2805                p++; 
     2806            } 
    27862807        fprintf(fp, "\n"); 
    27872808    } 
    2788  
    2789     fclose(fp); 
    2790     return 0; 
     2809    if (ferror(fp) != 0 || fclose(fp) != 0) return -1; 
     2810    else return 0; 
    27912811} 
    27922812 
     
    28562876        } 
    28572877        else if(strcmp(cmd,"degree")==0) 
    2858             fscanf(fp,"%lf",&param.degree); 
     2878            fscanf(fp,"%d",&param.degree); 
    28592879        else if(strcmp(cmd,"gamma")==0) 
    28602880            fscanf(fp,"%lf",&param.gamma); 
     
    29112931        else 
    29122932        { 
    2913             fprintf(stderr,"unknown text in model file\n"); 
     2933            fprintf(stderr,"unknown text in model file: [%s]\n",cmd); 
    29142934            free(model->rho); 
    29152935            free(model->label); 
     
    29742994        x_space[j++].index = -1; 
    29752995    } 
    2976  
    2977     fclose(fp); 
     2996    if (ferror(fp) != 0 || fclose(fp) != 0) return NULL; 
    29782997 
    29792998    model->free_sv = 1; // XXX 
     
    30153034        return "unknown svm type"; 
    30163035     
    3017     // kernel_type 
     3036    // kernel_type, degree 
    30183037     
    30193038    int kernel_type = param->kernel_type; 
     
    30223041       kernel_type != RBF && 
    30233042       kernel_type != SIGMOID && 
     3043       kernel_type != PRECOMPUTED && 
    30243044       kernel_type != CUSTOM) 
    30253045        return "unknown kernel type"; 
     3046 
     3047    if(param->degree < 0) 
     3048        return "degree of polynomial kernel < 0"; 
    30263049 
    30273050    // cache_size,eps,C,nu,p,shrinking 
     
    33003323    for(i=0;i<nr_class;i++) 
    33013324        nSV->at(i)=model->nSV[i]; 
    3302     //printf("nSV"); 
    33033325 
    33043326    coef=mlnew TFloatListList(nr_class-1); 
Note: See TracChangeset for help on using the changeset viewer.