Changeset 8974:cd2399c8fb5f in orange


Ignore:
Timestamp:
09/15/11 16:06:40 (3 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
3201364ab5d13f8a3d62a76018a5837248a935df
Message:

Changed SVM and Linear Classifier saving/loading routines to avoid using a temporary file (by using iostream library).
Fixes #943.

Location:
source/orange
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • source/orange/lib_learner.cpp

    r8735 r8974  
    12671267    CAST_TO(TLinearClassifier, classifier); 
    12681268    string buff; 
    1269     linear_save_model_alt(buff, classifier->getModel()); 
     1269    if (linear_save_model_alt(buff, classifier->getModel()) != 0) 
     1270        raiseError("Could not save the model"); 
    12701271    return Py_BuildValue("O(OOOs)N", getExportedFunction("__pickleLoaderLinearClassifier"), 
    12711272                                    self->ob_type, 
     
    12881289    string buff(pBuff); 
    12891290    model *model = linear_load_model_alt(buff); 
     1291    if (!model) 
     1292        raiseError("Could not load the model"); 
    12901293    return WrapNewOrange(mlnew TLinearClassifier(var, examples, model), (PyTypeObject*)&PyOrLinearClassifier_Type); 
    12911294  PyCATCH 
  • source/orange/linear.cpp

    r7822 r8974  
    25982598*/ 
    25992599 
     2600#include <iostream> 
     2601#include <sstream> 
     2602 
    26002603int linear_save_model_alt(string &buffer, struct model *model_) 
     2604{ 
     2605    std::ostringstream strstream; 
     2606    int ret = linear_save_model_alt(strstream, model_); 
     2607    buffer = strstream.rdbuf()->str(); 
     2608    return ret; 
     2609} 
     2610 
     2611int linear_save_model_alt(ostream &stream, struct model *model_) 
    26012612{ 
    26022613    int i; 
     
    26092620    else 
    26102621        n=nr_feature; 
    2611     FILE *fp = tmpfile(); 
    2612     if(fp==NULL) return -1; 
    26132622 
    26142623    int nr_classifier; 
     
    26182627        nr_classifier=model_->nr_class; 
    26192628 
    2620     fprintf(fp, "solver_type %s\n", solver_type_table[param.solver_type]); 
    2621     fprintf(fp, "nr_class %d\n", model_->nr_class); 
    2622     fprintf(fp, "label"); 
     2629    stream.precision(17); 
     2630 
     2631    stream << "solver_type " << solver_type_table[param.solver_type] << endl; 
     2632    stream << "nr_class " << model_->nr_class << endl; 
     2633    stream << "label"; 
    26232634    for(i=0; i<model_->nr_class; i++) 
    2624         fprintf(fp, " %d", model_->label[i]); 
    2625     fprintf(fp, "\n"); 
    2626  
    2627     fprintf(fp, "nr_feature %d\n", nr_feature); 
    2628  
    2629     fprintf(fp, "bias %.16g\n", model_->bias); 
    2630  
    2631     fprintf(fp, "w\n"); 
     2635        stream << " " << model_->label[i]; 
     2636    stream << endl; 
     2637 
     2638    stream << "nr_feature " << nr_feature << endl; 
     2639 
     2640    stream << "bias " << model_->bias << endl; 
     2641 
     2642    stream << "w" << endl; 
    26322643    for(i=0; i<n; i++) 
    26332644    { 
    26342645        int j; 
    26352646        for(j=0; j<nr_classifier; j++) 
    2636             fprintf(fp, "%.16g ", model_->w[i*nr_classifier+j]); 
    2637         fprintf(fp, "\n"); 
    2638     } 
    2639  
    2640     fseek(fp, SEEK_SET, 0); 
    2641     char str[512]; 
    2642     while(fgets(str, 512, fp)){ 
    2643         buffer+=str; 
    2644     } 
    2645  
    2646     if (ferror(fp) != 0 || fclose(fp) != 0) return -1; 
    2647     else return 0; 
     2647            stream << model_->w[i*nr_classifier+j] << " "; 
     2648        stream << endl; 
     2649    } 
     2650 
     2651    if (stream.good()) 
     2652        return 0; 
     2653    else 
     2654        return -1; 
    26482655} 
    26492656 
    26502657struct model *linear_load_model_alt(string &buffer) 
    26512658{ 
    2652     FILE *fp = tmpfile(); 
    2653     if(fp==NULL) return NULL; 
    2654  
    2655     fprintf(fp, buffer.c_str()); 
    2656     fseek(fp, SEEK_SET, 0); 
    2657  
     2659    std::istringstream str_stream(buffer); 
     2660    return linear_load_model_alt(str_stream); 
     2661} 
     2662 
     2663struct model *linear_load_model_alt(istream &stream) 
     2664{ 
    26582665    int i; 
    26592666    int nr_feature; 
     
    26672674 
    26682675    char cmd[81]; 
    2669     while(1) 
    2670     { 
    2671         fscanf(fp,"%80s",cmd); 
    2672         if(strcmp(cmd,"solver_type")==0) 
    2673         { 
    2674             fscanf(fp,"%80s",cmd); 
     2676    stream.width(80); 
     2677    while(stream.good()) 
     2678    { 
     2679        stream >> cmd; 
     2680        if(strcmp(cmd, "solver_type")==0) 
     2681        { 
     2682            stream >> cmd; 
    26752683            int i; 
    26762684            for(i=0;solver_type_table[i];i++) 
     
    26922700        else if(strcmp(cmd,"nr_class")==0) 
    26932701        { 
    2694             fscanf(fp,"%d",&nr_class); 
     2702            stream >> nr_class; 
    26952703            model_->nr_class=nr_class; 
    26962704        } 
    26972705        else if(strcmp(cmd,"nr_feature")==0) 
    26982706        { 
    2699             fscanf(fp,"%d",&nr_feature); 
     2707            stream >> nr_feature; 
    27002708            model_->nr_feature=nr_feature; 
    27012709        } 
    27022710        else if(strcmp(cmd,"bias")==0) 
    27032711        { 
    2704             fscanf(fp,"%lf",&bias); 
     2712            stream >> bias; 
    27052713            model_->bias=bias; 
    27062714        } 
     
    27142722            model_->label = Malloc(int,nr_class); 
    27152723            for(int i=0;i<nr_class;i++) 
    2716                 fscanf(fp,"%d",&model_->label[i]); 
     2724                stream >> model_->label[i]; 
    27172725        } 
    27182726        else 
    27192727        { 
    27202728            fprintf(stderr,"unknown text in model file: [%s]\n",cmd); 
     2729            free(model_->label); 
    27212730            free(model_); 
    27222731            return NULL; 
     
    27412750        int j; 
    27422751        for(j=0; j<nr_classifier; j++) 
    2743             fscanf(fp, "%lf ", &model_->w[i*nr_classifier+j]); 
    2744         fscanf(fp, "\n"); 
    2745     } 
    2746     if (ferror(fp) != 0 || fclose(fp) != 0) return NULL; 
    2747  
    2748     return model_; 
     2752            stream >> model_->w[i*nr_classifier+j]; 
     2753    } 
     2754    if (stream.fail()) 
     2755        return NULL; 
     2756    else 
     2757        return model_; 
    27492758} 
    27502759 
  • source/orange/linear.hpp

    r7822 r8974  
    161161#include "examples.hpp" 
    162162 
     163#include <iostream> 
    163164int linear_save_model_alt(string &, model *); 
     165int linear_save_model_alt(ostream &, model *); 
    164166model *linear_load_model_alt(string &); 
     167model *linear_load_model_alt(istream &); 
    165168 
    166169WRAPPER(ExampleTable) 
  • source/orange/svm.cpp

    r8735 r8974  
    29542954    if (ferror(fp) != 0 || fclose(fp) != 0) 
    29552955        return NULL; 
    2956      
     2956         
    29572957    model->free_sv = 1; // XXX 
    29582958    return model; 
     
    31433143Save load functions for use with orange pickling. 
    31443144They are a copy of the standard libSVM save-load functions 
    3145 except that they read/write from/to a temp file that is deleted 
    3146 at the end with fclose 
     3145except that they read/write from/to std::iostream objects. 
    31473146*/ 
    31483147#include "slist.hpp" 
    3149 int svm_save_model_alt(string& buffer, const svm_model *model){ 
    3150     FILE *fp = tmpfile(); 
    3151  
    3152     if(fp==NULL) 
    3153     { 
    3154         perror("tmpfile"); 
    3155         return -1; 
    3156     } 
    3157  
     3148 
     3149#include <iostream> 
     3150#include <sstream> 
     3151 
     3152int svm_save_model_alt(std::string& buffer, const svm_model *model){ 
     3153    std::ostringstream strstream; 
     3154    int ret = svm_save_model_alt(strstream, model); 
     3155    buffer = strstream.rdbuf()->str(); 
     3156    return ret; 
     3157} 
     3158 
     3159int svm_save_model_alt(std::ostream& stream, const svm_model *model){ 
    31583160    const svm_parameter& param = model->param; 
    3159  
    3160     fprintf(fp,"svm_type %s\n", svm_type_table[param.svm_type]); 
    3161     fprintf(fp,"kernel_type %s\n", kernel_type_table[param.kernel_type]); 
     3161    stream.precision(17); 
     3162 
     3163    stream << "svm_type " << svm_type_table[param.svm_type] << endl; 
     3164    stream << "kernel_type " << kernel_type_table[param.kernel_type] << endl; 
    31623165 
    31633166    if(param.kernel_type == POLY) 
    3164         fprintf(fp,"degree %d\n", param.degree); 
     3167        stream << "degree " << param.degree << endl; 
    31653168 
    31663169    if(param.kernel_type == POLY || param.kernel_type == RBF || param.kernel_type == SIGMOID) 
    3167         fprintf(fp,"gamma %g\n", param.gamma); 
     3170        stream << "gamma " << param.gamma << endl; 
    31683171 
    31693172    if(param.kernel_type == POLY || param.kernel_type == SIGMOID) 
    3170         fprintf(fp,"coef0 %g\n", param.coef0); 
     3173        stream << "coef0 " << param.coef0 << endl; 
    31713174 
    31723175    int nr_class = model->nr_class; 
    31733176    int l = model->l; 
    3174     fprintf(fp, "nr_class %d\n", nr_class); 
    3175     fprintf(fp, "total_sv %d\n",l); 
    3176  
    3177     { 
    3178         fprintf(fp, "rho"); 
     3177    stream << "nr_class " << nr_class << endl; 
     3178    stream << "total_sv " << l << endl; 
     3179    { 
     3180        stream << "rho"; 
    31793181        for(int i=0;i<nr_class*(nr_class-1)/2;i++) 
    3180             fprintf(fp," %g",model->rho[i]); 
    3181         fprintf(fp, "\n"); 
     3182            stream << " " << model->rho[i]; 
     3183        stream << endl; 
    31823184    } 
    31833185 
    31843186    if(model->label) 
    31853187    { 
    3186         fprintf(fp, "label"); 
     3188        stream << "label"; 
    31873189        for(int i=0;i<nr_class;i++) 
    3188             fprintf(fp," %d",model->label[i]); 
    3189         fprintf(fp, "\n"); 
     3190            stream << " " << model->label[i]; 
     3191        stream << endl; 
    31903192    } 
    31913193 
    31923194    if(model->probA) // regression has probA only 
    31933195    { 
    3194         fprintf(fp, "probA"); 
     3196        stream << "probA"; 
    31953197        for(int i=0;i<nr_class*(nr_class-1)/2;i++) 
    3196             fprintf(fp," %g",model->probA[i]); 
    3197         fprintf(fp, "\n"); 
     3198            stream << " " << model->probA[i]; 
     3199        stream << endl; 
    31983200    } 
    31993201    if(model->probB) 
    32003202    { 
    3201         fprintf(fp, "probB"); 
     3203        stream << "probB"; 
    32023204        for(int i=0;i<nr_class*(nr_class-1)/2;i++) 
    3203             fprintf(fp," %g",model->probB[i]); 
    3204         fprintf(fp, "\n"); 
     3205            stream << " " << model->probB[i]; 
     3206        stream << endl; 
    32053207    } 
    32063208 
    32073209    if(model->nSV) 
    32083210    { 
    3209         fprintf(fp, "nr_sv"); 
     3211        stream << "nr_sv"; 
    32103212        for(int i=0;i<nr_class;i++) 
    3211             fprintf(fp," %d",model->nSV[i]); 
    3212         fprintf(fp, "\n"); 
    3213     } 
    3214  
    3215     fprintf(fp, "SV\n"); 
     3213            stream << " " << model->nSV[i]; 
     3214        stream << endl; 
     3215    } 
     3216 
     3217    stream << "SV" << endl; 
    32163218    const double * const *sv_coef = model->sv_coef; 
    32173219    const svm_node * const *SV = model->SV; 
     
    32203222    { 
    32213223        for(int j=0;j<nr_class-1;j++) 
    3222             fprintf(fp, "%.16g ",sv_coef[j][i]); 
     3224            stream << sv_coef[j][i] << " "; 
    32233225 
    32243226        const svm_node *p = SV[i]; 
    32253227 
    32263228        if(param.kernel_type == PRECOMPUTED) 
    3227             fprintf(fp,"0:%d ",(int)(p->value)); 
     3229            stream << (int)(p->value) << " "; 
    32283230        else 
    32293231            while(p->index != -1) 
    32303232            { 
    3231                 fprintf(fp,"%d:%.8g ",p->index,p->value); 
     3233                stream << (int)(p->index) << ":" << p->value << " "; 
    32323234                p++; 
    32333235            } 
    3234         fprintf(fp, "\n"); 
    3235     } 
    3236  
    3237     fseek(fp, SEEK_SET, 0); 
    3238  
    3239     char str[512]; 
    3240     while(fgets(str, 512, fp)){ 
    3241         buffer+=str; 
    3242     } 
    3243  
    3244     if (ferror(fp) != 0){ 
    3245         perror("fgets"); 
    3246         fclose(fp); 
    3247         return -1; 
    3248     } 
    3249     fclose(fp); 
    3250     return 0; 
    3251 } 
    3252  
    3253 svm_model *svm_load_model_alt(string& buffer) 
    3254 { 
    3255     FILE *fp = tmpfile(); 
    3256     if(fp==NULL) return NULL; 
    3257  
    3258     fprintf(fp, buffer.c_str()); 
    3259     fseek(fp, SEEK_SET, 0); 
    3260  
    3261     // read parameters 
    3262  
     3236        stream << endl; 
     3237    } 
     3238 
     3239    if (!stream.fail()) 
     3240        return 0; 
     3241    else 
     3242        return 1; 
     3243} 
     3244 
     3245 
     3246svm_model *svm_load_model_alt(std::string& stream) 
     3247{ 
     3248    std::istringstream strstream(stream); 
     3249    return svm_load_model_alt(strstream); 
     3250} 
     3251 
     3252#include <algorithm> 
     3253 
     3254svm_model *svm_load_model_alt(std::istream& stream) 
     3255{ 
    32633256    svm_model *model = Malloc(svm_model,1); 
    32643257    svm_parameter& param = model->param; 
     
    32703263 
    32713264    char cmd[81]; 
    3272     while(1) 
    3273     { 
    3274         fscanf(fp,"%80s",cmd); 
    3275  
    3276         if(strcmp(cmd,"svm_type")==0) 
    3277         { 
    3278             fscanf(fp,"%80s",cmd); 
     3265    stream.width(80); 
     3266    while (stream.good()) 
     3267    { 
     3268        stream >> cmd; 
     3269 
     3270        if(strcmp(cmd, "svm_type") == 0) 
     3271        { 
     3272            stream >> cmd; 
    32793273            int i; 
    3280             for(i=0;svm_type_table[i];i++) 
    3281             { 
    3282                 if(strcmp(svm_type_table[i],cmd)==0) 
     3274            for(i=0; svm_type_table[i]; i++) 
     3275            { 
     3276                if(strcmp(cmd, svm_type_table[i]) == 0) 
    32833277                { 
    32843278                    param.svm_type=i; 
     
    32883282            if(svm_type_table[i] == NULL) 
    32893283            { 
    3290                 fprintf(stderr,"unknown svm type.\n"); 
     3284                fprintf(stderr, "unknown svm type.\n"); 
    32913285                free(model->rho); 
    32923286                free(model->label); 
     
    32963290            } 
    32973291        } 
    3298         else if(strcmp(cmd,"kernel_type")==0) 
    3299         { 
    3300             fscanf(fp,"%80s",cmd); 
     3292        else if(strcmp(cmd, "kernel_type") == 0) 
     3293        { 
     3294            stream >> cmd; 
    33013295            int i; 
    33023296            for(i=0;kernel_type_table[i];i++) 
    33033297            { 
    3304                 if(strcmp(kernel_type_table[i],cmd)==0) 
     3298                if(strcmp(kernel_type_table[i], cmd)==0) 
    33053299                { 
    33063300                    param.kernel_type=i; 
     
    33193313        } 
    33203314        else if(strcmp(cmd,"degree")==0) 
    3321             fscanf(fp,"%d",&param.degree); 
     3315            stream >> param.degree; 
    33223316        else if(strcmp(cmd,"gamma")==0) 
    3323             fscanf(fp,"%lf",&param.gamma); 
     3317            stream >> param.gamma; 
    33243318        else if(strcmp(cmd,"coef0")==0) 
    3325             fscanf(fp,"%lf",&param.coef0); 
     3319            stream >> param.coef0; 
    33263320        else if(strcmp(cmd,"nr_class")==0) 
    3327             fscanf(fp,"%d",&model->nr_class); 
     3321            stream >> model->nr_class; 
    33283322        else if(strcmp(cmd,"total_sv")==0) 
    3329             fscanf(fp,"%d",&model->l); 
     3323            stream >> model->l; 
    33303324        else if(strcmp(cmd,"rho")==0) 
    33313325        { 
     
    33333327            model->rho = Malloc(double,n); 
    33343328            for(int i=0;i<n;i++) 
    3335                 fscanf(fp,"%lf",&model->rho[i]); 
     3329                stream >> model->rho[i]; 
    33363330        } 
    33373331        else if(strcmp(cmd,"label")==0) 
     
    33403334            model->label = Malloc(int,n); 
    33413335            for(int i=0;i<n;i++) 
    3342                 fscanf(fp,"%d",&model->label[i]); 
     3336                stream >> model->label[i]; 
    33433337        } 
    33443338        else if(strcmp(cmd,"probA")==0) 
     
    33473341            model->probA = Malloc(double,n); 
    33483342            for(int i=0;i<n;i++) 
    3349                 fscanf(fp,"%lf",&model->probA[i]); 
     3343                stream >> model->probA[i]; 
    33503344        } 
    33513345        else if(strcmp(cmd,"probB")==0) 
     
    33543348            model->probB = Malloc(double,n); 
    33553349            for(int i=0;i<n;i++) 
    3356                 fscanf(fp,"%lf",&model->probB[i]); 
     3350                stream >> model->probB[i]; 
    33573351        } 
    33583352        else if(strcmp(cmd,"nr_sv")==0) 
     
    33613355            model->nSV = Malloc(int,n); 
    33623356            for(int i=0;i<n;i++) 
    3363                 fscanf(fp,"%d",&model->nSV[i]); 
     3357                stream >> model->nSV[i]; 
    33643358        } 
    33653359        else if(strcmp(cmd,"SV")==0) 
     
    33673361            while(1) 
    33683362            { 
    3369                 int c = getc(fp); 
    3370                 if(c==EOF || c=='\n') break; 
     3363                int c = stream.get(); 
     3364                if(stream.eof() || c=='\n') break; 
    33713365            } 
    33723366            break; 
     
    33823376        } 
    33833377    } 
     3378    if (stream.fail()){ 
     3379        free(model->rho); 
     3380        free(model->label); 
     3381        free(model->nSV); 
     3382        free(model); 
     3383        return NULL; 
     3384 
     3385    } 
    33843386 
    33853387    // read sv_coef and SV 
    33863388 
    33873389    int elements = 0; 
    3388     long pos = ftell(fp); 
    3389  
    3390     max_line_len = 1024; 
    3391     line = Malloc(char,max_line_len); 
     3390    long pos = stream.tellg(); 
     3391 
    33923392    char *p,*endptr,*idx,*val; 
    3393  
    3394     while(readline(fp)!=NULL) 
    3395     { 
    3396         p = strtok(line,":"); 
    3397         while(1) 
    3398         { 
    3399             p = strtok(NULL,":"); 
    3400             if(p == NULL) 
    3401                 break; 
    3402             ++elements; 
    3403         } 
    3404     } 
     3393    string str_line; 
     3394    while (!stream.eof() && !stream.fail()) 
     3395    { 
     3396        getline(stream, str_line); 
     3397        elements += std::count(str_line.begin(), str_line.end(), ':'); 
     3398    } 
     3399 
    34053400    elements += model->l; 
    34063401 
    3407     fseek(fp,pos,SEEK_SET); 
     3402    stream.clear(); 
     3403    stream.seekg(pos, ios::beg); 
    34083404 
    34093405    int m = model->nr_class - 1; 
     
    34183414 
    34193415    int j=0; 
     3416    char *line; 
    34203417    for(i=0;i<l;i++) 
    34213418    { 
    3422         readline(fp); 
     3419        getline(stream, str_line); 
     3420        if (str_line.size() == 0) 
     3421            continue; 
     3422 
     3423        line = (char *) Malloc(char, str_line.size() + 1); 
     3424        // Copy the line for strtok. 
     3425        strcpy(line, str_line.c_str()); 
     3426 
    34233427        model->SV[i] = &x_space[j]; 
    34243428 
     
    34443448        } 
    34453449        x_space[j++].index = -1; 
    3446     } 
    3447     free(line); 
    3448  
    3449     if (ferror(fp) != 0){ 
    3450         perror("SVM Model loading failed"); 
    3451         fclose(fp); 
     3450        free(line); 
     3451    } 
     3452 
     3453    if (stream.fail()) 
    34523454        return NULL; 
    3453     } 
    3454  
    3455     fclose(fp); 
    34563455 
    34573456    model->free_sv = 1; // XXX 
  • source/orange/svm.hpp

    r7160 r8974  
    170170#include "slist.hpp" 
    171171 
     172#include <iostream> 
    172173svm_model *svm_load_model_alt(string& buffer); 
     174svm_model *svm_load_model_alt(istream& stream); 
    173175int svm_save_model_alt(string& buffer, const svm_model *model); 
     176int svm_save_model_alt(ostream& stream, const svm_model *model); 
    174177 
    175178WRAPPER(ExampleGenerator) 
Note: See TracChangeset for help on using the changeset viewer.