Changeset 11664:4bb73da41192 in orange


Ignore:
Timestamp:
08/22/13 20:14:17 (8 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Children:
11665:102abd2f5a1e, 11669:c15ff688672b
Message:

Updated the included LIBSVM to version 3.17.

Location:
source/orange
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • source/orange/libsvm/COPYRIGHT

    r8978 r11664  
    11 
    2 Copyright (c) 2000-2011 Chih-Chung Chang and Chih-Jen Lin 
     2Copyright (c) 2000-2013 Chih-Chung Chang and Chih-Jen Lin 
    33All rights reserved. 
    44 
  • source/orange/libsvm/svm.cpp

    r8978 r11664  
    66#include <string.h> 
    77#include <stdarg.h> 
     8#include <limits.h> 
     9#include <locale.h> 
    810#include "svm.h" 
    911int libsvm_version = LIBSVM_VERSION; 
     
    475477 
    476478    if(2*nr_free < active_size) 
    477         info("\nWarning: using -h 0 may be faster\n"); 
     479        info("\nWARNING: using -h 0 may be faster\n"); 
    478480 
    479481    if (nr_free*l > 2*active_size*(l-active_size)) 
     
    557559 
    558560    int iter = 0; 
     561    int max_iter = max(10000000, l>INT_MAX/100 ? INT_MAX : 100*l); 
    559562    int counter = min(l,1000)+1; 
    560  
    561     while(1) 
     563     
     564    while(iter < max_iter) 
    562565    { 
    563566        // show progress and do shrinking 
     
    724727            } 
    725728        } 
     729    } 
     730 
     731    if(iter >= max_iter) 
     732    { 
     733        if(active_size < l) 
     734        { 
     735            // reconstruct the whole gradient to calculate objective value 
     736            reconstruct_gradient(); 
     737            active_size = l; 
     738            info("*"); 
     739        } 
     740        fprintf(stderr,"\nWARNING: reaching max number of iterations\n"); 
    726741    } 
    727742 
     
    9921007// additional constraint: e^T \alpha = constant 
    9931008// 
    994 class Solver_NU : public Solver 
     1009class Solver_NU: public Solver 
    9951010{ 
    9961011public: 
     
    20342049    } 
    20352050 
     2051    // 
     2052    // Labels are ordered by their first occurrence in the training set.  
     2053    // However, for two-class sets with -1/+1 labels and -1 appears first,  
     2054    // we swap labels to ensure that internally the binary SVM has positive data corresponding to the +1 instances. 
     2055    // 
     2056    if (nr_class == 2 && label[0] == -1 && label[1] == 1) 
     2057    { 
     2058        swap(label[0],label[1]); 
     2059        swap(count[0],count[1]); 
     2060        for(i=0;i<l;i++) 
     2061        { 
     2062            if(data_label[i] == 0) 
     2063                data_label[i] = 1; 
     2064            else 
     2065                data_label[i] = 0; 
     2066        } 
     2067    } 
     2068 
    20362069    int *start = Malloc(int,nr_class); 
    20372070    start[0] = 0; 
     
    20932126        model->SV = Malloc(svm_node *,nSV); 
    20942127        model->sv_coef[0] = Malloc(double,nSV); 
     2128        model->sv_indices = Malloc(int,nSV); 
    20952129        int j = 0; 
    20962130        for(i=0;i<prob->l;i++) 
     
    20992133                model->SV[j] = prob->x[i]; 
    21002134                model->sv_coef[0][j] = f.alpha[i]; 
     2135                model->sv_indices[j] = i+1; 
    21012136                ++j; 
    21022137            }        
     
    21152150 
    21162151        // group training data of the same class 
    2117         svm_group_classes(prob,&nr_class,&label,&start,&count,perm);         
     2152        svm_group_classes(prob,&nr_class,&label,&start,&count,perm); 
     2153        if(nr_class == 1)  
     2154            info("WARNING: training data in only one class. See README for details.\n"); 
     2155         
    21182156        svm_node **x = Malloc(svm_node *,l); 
    21192157        int i; 
     
    21332171                    break; 
    21342172            if(j == nr_class) 
    2135                 fprintf(stderr,"warning: class label %d specified in weight is not found\n", param->weight_label[i]); 
     2173                fprintf(stderr,"WARNING: class label %d specified in weight is not found\n", param->weight_label[i]); 
    21362174            else 
    21372175                weighted_C[j] *= param->weight[i]; 
     
    22372275        model->l = total_sv; 
    22382276        model->SV = Malloc(svm_node *,total_sv); 
     2277        model->sv_indices = Malloc(int,total_sv); 
    22392278        p = 0; 
    22402279        for(i=0;i<l;i++) 
    2241             if(nonzero[i]) model->SV[p++] = x[i]; 
     2280            if(nonzero[i]) 
     2281            { 
     2282                model->SV[p] = x[i]; 
     2283                model->sv_indices[p++] = perm[i] + 1; 
     2284            } 
    22422285 
    22432286        int *nz_start = Malloc(int,nr_class); 
     
    22972340{ 
    22982341    int i; 
    2299     int *fold_start = Malloc(int,nr_fold+1); 
     2342    int *fold_start; 
    23002343    int l = prob->l; 
    23012344    int *perm = Malloc(int,l); 
    23022345    int nr_class; 
    2303  
     2346    if (nr_fold > l) 
     2347    { 
     2348        nr_fold = l; 
     2349        fprintf(stderr,"WARNING: # folds > # data. Will use # folds = # data instead (i.e., leave-one-out cross validation)\n"); 
     2350    } 
     2351    fold_start = Malloc(int,nr_fold+1); 
    23042352    // stratified cv may not give leave-one-out rate 
    23052353    // Each class to l folds -> some folds may have zero elements 
     
    24272475} 
    24282476 
     2477void svm_get_sv_indices(const svm_model *model, int* indices) 
     2478{ 
     2479    if (model->sv_indices != NULL) 
     2480        for(int i=0;i<model->l;i++) 
     2481            indices[i] = model->sv_indices[i]; 
     2482} 
     2483 
     2484int svm_get_nr_sv(const svm_model *model) 
     2485{ 
     2486    return model->l; 
     2487} 
     2488 
    24292489double svm_get_svr_probability(const svm_model *model) 
    24302490{ 
     
    24412501double svm_predict_values(const svm_model *model, const svm_node *x, double* dec_values) 
    24422502{ 
     2503    int i; 
    24432504    if(model->param.svm_type == ONE_CLASS || 
    24442505       model->param.svm_type == EPSILON_SVR || 
     
    24472508        double *sv_coef = model->sv_coef[0]; 
    24482509        double sum = 0; 
    2449         for(int i=0;i<model->l;i++) 
     2510        for(i=0;i<model->l;i++) 
    24502511            sum += sv_coef[i] * Kernel::k_function(x,model->SV[i],model->param); 
    24512512        sum -= model->rho[0]; 
     
    24592520    else 
    24602521    { 
    2461         int i; 
    24622522        int nr_class = model->nr_class; 
    24632523        int l = model->l; 
     
    25842644    if(fp==NULL) return -1; 
    25852645 
     2646    char *old_locale = strdup(setlocale(LC_ALL, NULL)); 
     2647    setlocale(LC_ALL, "C"); 
     2648 
    25862649    const svm_parameter& param = model->param; 
    25872650 
     
    26622725        fprintf(fp, "\n"); 
    26632726    } 
     2727 
     2728    setlocale(LC_ALL, old_locale); 
     2729    free(old_locale); 
     2730 
    26642731    if (ferror(fp) != 0 || fclose(fp) != 0) return -1; 
    26652732    else return 0; 
     
    26912758    FILE *fp = fopen(model_file_name,"rb"); 
    26922759    if(fp==NULL) return NULL; 
    2693      
     2760 
     2761    char *old_locale = strdup(setlocale(LC_ALL, NULL)); 
     2762    setlocale(LC_ALL, "C"); 
     2763 
    26942764    // read parameters 
    26952765 
     
    26992769    model->probA = NULL; 
    27002770    model->probB = NULL; 
     2771    model->sv_indices = NULL; 
    27012772    model->label = NULL; 
    27022773    model->nSV = NULL; 
     
    27222793            { 
    27232794                fprintf(stderr,"unknown svm type.\n"); 
     2795                 
     2796                setlocale(LC_ALL, old_locale); 
     2797                free(old_locale); 
    27242798                free(model->rho); 
    27252799                free(model->label); 
     
    27442818            { 
    27452819                fprintf(stderr,"unknown kernel function.\n"); 
     2820                 
     2821                setlocale(LC_ALL, old_locale); 
     2822                free(old_locale); 
    27462823                free(model->rho); 
    27472824                free(model->label); 
     
    28082885        { 
    28092886            fprintf(stderr,"unknown text in model file: [%s]\n",cmd); 
     2887             
     2888            setlocale(LC_ALL, old_locale); 
     2889            free(old_locale); 
    28102890            free(model->rho); 
    28112891            free(model->label); 
     
    28802960    free(line); 
    28812961 
     2962    setlocale(LC_ALL, old_locale); 
     2963    free(old_locale); 
     2964 
    28822965    if (ferror(fp) != 0 || fclose(fp) != 0) 
    28832966        return NULL; 
     
    29142997    free(model_ptr->probB); 
    29152998    model_ptr->probB= NULL; 
     2999 
     3000    free(model_ptr->sv_indices); 
     3001    model_ptr->sv_indices = NULL; 
    29163002 
    29173003    free(model_ptr->nSV); 
  • source/orange/libsvm/svm.h

    r8978 r11664  
    22#define _LIBSVM_H 
    33 
    4 #define LIBSVM_VERSION 310 
     4#define LIBSVM_VERSION 317 
    55 
    66#ifdef __cplusplus 
     
    6060    double *probA;      /* pariwise probability information */ 
    6161    double *probB; 
     62    int *sv_indices;        /* sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to indicate SVs in the training set */ 
    6263 
    6364    /* for classification only */ 
     
    8081int svm_get_nr_class(const struct svm_model *model); 
    8182void svm_get_labels(const struct svm_model *model, int *label); 
     83void svm_get_sv_indices(const struct svm_model *model, int *sv_indices); 
     84int svm_get_nr_sv(const struct svm_model *model); 
    8285double svm_get_svr_probability(const struct svm_model *model); 
    8386 
  • source/orange/libsvm_interface.cpp

    r11650 r11664  
    152152    model->label = NULL; 
    153153    model->nSV = NULL; 
     154 
     155#if LIBSVM_VERSION >= 313 
     156    // libsvm seems to ensure ordered numbers for versioning (3.0 was 300, 
     157    // 3.1 was 310,  3.11 was 311, there was no 3.2, ...) 
     158    model->sv_indices = NULL; 
     159#endif 
    154160 
    155161    char cmd[81]; 
Note: See TracChangeset for help on using the changeset viewer.