Changeset 3662:28b8d996df34 in orange


Ignore:
Timestamp:
05/17/07 12:11:40 (7 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
f6276e79efc572c59e15375104264d50a14f481f
Message:

Added SVMLearnerSparse

Location:
source/orange
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • source/orange/lib_learner.cpp

    r3635 r3662  
    10381038#include "svm.hpp" 
    10391039C_CALL(SVMLearner, Learner, "([examples] -/-> Classifier)") 
     1040C_CALL(SVMLearnerSparse, SVMLearner, "([examples] -/-> Classifier)") 
    10401041C_NAMED(SVMClassifier, Classifier," ") 
    10411042//N O _PICKLE(SVMClassifier) 
     
    10971098    } 
    10981099    if(svm->kernelFunc) 
    1099         return Py_BuildValue("O(OOOOsO)N", getExportedFunction("__pickleLoaderSVMClassifier"), 
     1100        return Py_BuildValue("O(OOOOsbO)N", getExportedFunction("__pickleLoaderSVMClassifier"), 
    11001101                                    self->ob_type, 
    11011102                                    WrapOrange(svm->classVar), 
     
    11031104                                    WrapOrange(svm->supportVectors), 
    11041105                                    buf.c_str(), 
     1106                                    (char)svm->supportsSparse(), 
    11051107                                    WrapOrange(svm->kernelFunc), 
    11061108                                    packOrangeDictionary(self)); 
    11071109    else 
    1108         return Py_BuildValue("O(OOOOs)N", getExportedFunction("__pickleLoaderSVMClassifier"), 
     1110        return Py_BuildValue("O(OOOOsb)N", getExportedFunction("__pickleLoaderSVMClassifier"), 
    11091111                                    self->ob_type, 
    11101112                                    WrapOrange(svm->classVar), 
     
    11121114                                    WrapOrange(svm->supportVectors), 
    11131115                                    buf.c_str(), 
     1116                                    (char)svm->supportsSparse(), 
    11141117                                    packOrangeDictionary(self)); 
    11151118  PyCATCH 
     
    11251128    PKernelFunc kernel; 
    11261129    char *pbuf; 
    1127     if (!PyArg_ParseTuple(args, "OO&O&O&s|O&:__pickleLoaderSVMClassifier", &type, cc_Variable, &var, 
    1128         cc_ExampleTable, &examples, cc_ExampleTable, &supportVectors, &pbuf, cc_KernelFunc, &kernel)) 
     1130    char sparse; 
     1131    if (!PyArg_ParseTuple(args, "OO&O&O&sb|O&:__pickleLoaderSVMClassifier", &type, cc_Variable, &var, 
     1132        cc_ExampleTable, &examples, cc_ExampleTable, &supportVectors, &pbuf, &sparse, cc_KernelFunc, &kernel)) 
    11291133        return NULL; 
    11301134    //TCharBuffer buf(pbuf); 
     
    11361140        raiseError("Error building LibSVM model"); 
    11371141    model->param.learner=NULL; 
    1138     PSVMClassifier svm=mlnew TSVMClassifier(var, examples, model, NULL); 
     1142    PSVMClassifier svm=mlnew TSVMClassifier(var, examples, model, NULL, sparse); 
    11391143    svm->kernelFunc=kernel; 
    11401144    svm->supportVectors=supportVectors; 
  • source/orange/svm.cpp

    r3637 r3662  
    34493449     
    34503450svm_node* example_to_svm(const TExample &ex, svm_node* node, float last=0.0, int type=0){ 
    3451     if(type==0) 
    3452         for(int i=0;i<ex.domain->attributes->size();i++){ 
     3451    if(type==0){ 
     3452        int index=1; 
     3453        for(TExample::iterator i=ex.begin(); i!=ex.end(); i++) 
     3454            if(i->isRegular() && (*i)!=ex.getClass()){ 
     3455                if(i->varType==TValue::FLOATVAR) 
     3456                    node->value=float(*i); 
     3457                else 
     3458                    node->value=int(*i); 
     3459                node->index=index++; 
     3460                if(node->value==numeric_limits<float>::signaling_NaN() ||  
     3461                    node->value==numeric_limits<int>::max()) 
     3462                    node--; 
     3463                node++; 
     3464            } 
     3465    } 
     3466 
     3467        /*for(int i=0;i<ex.domain->attributes->size();i++){ 
    34533468            if(ex[i].isRegular()){ 
    34543469                if(ex[i].varType==TValue::FLOATVAR) 
     
    34623477                node++; 
    34633478            } 
    3464         } 
     3479        }*/ 
    34653480    if(type == 1){ /*one dummy attr so we can pickle the classifier and keep the SV index in the training table*/ 
    34663481        node->index=1; 
     
    34683483        node++; 
    34693484    } 
     3485    //cout<<(node-1)->index<<endl<<(node-2)->index<<endl; 
    34703486    node->index=-1; 
    34713487    node->value=last; 
     
    34733489    return node; 
    34743490} 
    3475 /* 
    3476 svm_node* svm_to_example(TExample & ex, svm_node *node){ 
    3477     while(node->index!=-1){ 
    3478         if(ex[node->index].varType==TValue::FLOATVAR) 
    3479             ex[node->index-1]=TValue(node->value); 
    3480         else 
    3481             ex[node->index-1]=TValue(int(node->value)); 
    3482         node++; 
    3483     } 
     3491 
     3492class SVM_NodeSort{ 
     3493public: 
     3494    bool operator() (svm_node &lhs, svm_node &rhs){ 
     3495        return lhs.index < rhs.index; 
     3496    } 
     3497}; 
     3498 
     3499svm_node* example_to_svm_sparse(const TExample &ex, svm_node* node, float last=0.0){ 
     3500    svm_node *first=node; 
     3501    int j=1; 
     3502    for(TMetaValues::const_iterator i=ex.meta.begin(); i!=ex.meta.end();i++,j++){ 
     3503        if(i->second.isRegular()){ 
     3504            if(i->second.varType==TValue::FLOATVAR) 
     3505                node->value=float(i->second); 
     3506            else 
     3507                node->value=int(i->second); 
     3508            node->index=-i->first; 
     3509            if(node->value==numeric_limits<float>::signaling_NaN() ||  
     3510                node->value==numeric_limits<int>::max()) 
     3511                node--; 
     3512            node++; 
     3513        } 
     3514    } 
     3515    sort(first, node, SVM_NodeSort()); 
     3516    //cout<<first->index<<endl<<(first+1)->index<<endl; 
     3517    node->index=-1; 
     3518    node->value=last; 
     3519    node++; 
    34843520    return node; 
    3485 }*/ 
     3521} 
     3522 
     3523int getNumOfElements(const TExample &ex, bool meta=false){ 
     3524    if(!meta) 
     3525        return std::max(ex.domain->attributes->size()+1, 2); 
     3526    else{ 
     3527        int count=1; //we need one to indicate the end of a sequence 
     3528        for(TMetaValues::const_iterator i=ex.meta.begin(); i!=ex.meta.end();i++) 
     3529            if(i->second.isRegular()) 
     3530                count++; 
     3531        return std::max(count,2); 
     3532    } 
     3533} 
     3534 
     3535int getNumOfElements(PExampleGenerator &examples, bool meta=false){ 
     3536    if(!meta) 
     3537        return getNumOfElements(*(examples->begin()), meta)*examples->numberOfExamples(); 
     3538    else{ 
     3539        int count=0; 
     3540        for(TExampleGenerator::iterator ex(examples->begin()); ex!=examples->end(); ++ex){ 
     3541            count+=getNumOfElements(*ex, meta); 
     3542        } 
     3543        return count; 
     3544    } 
     3545} 
    34863546 
    34873547TSVMLearner::TSVMLearner(){ 
     3548    sparse=false;   //if this learners supports sparse datasets (set to true in TSMVLearnerSparse subclass) 
    34883549    svm_type = C_SVC; 
    34893550    kernel_type = RBF; 
     
    35023563    //weight = NULL; 
    35033564}; 
     3565 
     3566TSVMLearnerSparse::TSVMLearnerSparse(){ 
     3567    sparse=true; 
     3568} 
    35043569 
    35053570PClassifier TSVMLearner::operator ()(PExampleGenerator examples, const int&){ 
     
    35293594     
    35303595    tempExamples=examples; 
    3531     int exlen=examples->domain->attributes->size(); 
     3596    //int exlen=examples->domain->attributes->size(); 
    35323597    int classVarType; 
    35333598    if(examples->domain->classVar) 
     
    35473612        param.probability=1; 
    35483613 
     3614    int numElements=getNumOfElements(examples, sparse); 
    35493615    prob.l=examples->numberOfExamples(); 
    35503616    prob.y=Malloc(double,prob.l); 
    35513617    prob.x=Malloc(svm_node*, prob.l); 
    3552     x_space=Malloc(svm_node, 2*prob.l*(exlen+1)); 
     3618    x_space=Malloc(svm_node, numElements); //2*prob.l*(exlen+1)); 
    35533619    int k=0; 
    35543620    svm_node *node=x_space; 
    35553621    PEITERATE(iter, examples){ 
    35563622        prob.x[k]=node; 
    3557         node=example_to_svm(*iter, node, k, (param.kernel_type==CUSTOM)? 1:0); 
     3623        if(sparse) 
     3624            node=example_to_svm_sparse(*iter, node, k); 
     3625        else 
     3626            node=example_to_svm(*iter, node, k, (param.kernel_type==CUSTOM)? 1:0); 
    35583627        switch(classVarType){ 
    35593628            case TValue::FLOATVAR:{ 
     
    35683637 
    35693638    if(param.gamma==0) 
    3570         param.gamma=1.0f/exlen; 
     3639        param.gamma=1.0f/(float(numElements)/float(prob.l)-1); //exlen; 
    35713640 
    35723641    const char* error=svm_check_parameter(&prob,&param); 
     
    35943663    tempExamples=NULL; 
    35953664    return PSVMClassifier(mlnew TSVMClassifier((param.svm_type==ONE_CLASS)?  \ 
    3596         mlnew TFloatVariable("one class") : examples->domain->classVar, examples, model, x_space)); 
    3597 } 
    3598  
    3599 TSVMClassifier::TSVMClassifier(PVariable var, PExampleTable _examples, svm_model* _model=NULL, svm_node* _x_space=NULL):TClassifier(var){ 
     3665        mlnew TFloatVariable("one class") : examples->domain->classVar, examples, model, x_space, sparse)); 
     3666} 
     3667 
     3668TSVMClassifier::TSVMClassifier(PVariable var, PExampleTable _examples, svm_model* _model=NULL, svm_node* _x_space=NULL, bool sparse=false):TClassifier(var){ 
    36003669    model=_model; 
    36013670    x_space=_x_space; 
    36023671    examples=_examples; 
     3672    this->sparse=sparse; 
    36033673    model->param.classifier=this; 
    3604     if (model->param.learner) // if the model constructed at unpickling  
     3674    if (model->param.learner) // if the model not constructed at unpickling  
    36053675        kernelFunc=model->param.learner->kernelFunc; 
    36063676    model->param.learner=NULL; 
     
    36523722        //return  TDistribution::create(example.domain->classVar); 
    36533723    currentExample=&example; 
    3654     int exlen=example.domain->attributes->size(); 
     3724    int exlen=getNumOfElements(example, sparse); 
    36553725    int svm_type=svm_get_svm_type(model); 
    36563726    int nr_class=svm_get_nr_class(model); 
     
    36593729    int *labels=(int *) malloc(nr_class*sizeof(int)); 
    36603730    double *prob_estimates=NULL; 
    3661     svm_node *x=Malloc(svm_node, (exlen+1>2)? exlen+1 : 2); 
     3731    svm_node *x=Malloc(svm_node, exlen); 
    36623732    svm_get_labels(model,labels); 
    36633733    prob_estimates = (double *) malloc(nr_class*sizeof(double)); 
    3664     example_to_svm(example, x, -1.0, (model->param.kernel_type==CUSTOM)? 1:0); 
     3734    if(sparse) 
     3735        example_to_svm_sparse(example, x, -1.0); 
     3736    else 
     3737        example_to_svm(example, x, -1.0, (model->param.kernel_type==CUSTOM)? 1:0); 
    36653738    svm_predict_probability(model,x,prob_estimates); 
    36663739    currentExample=NULL; 
     
    36793752        raiseError("No Model"); 
    36803753    currentExample=&example; 
    3681     int exlen=example.domain->attributes->size(); 
     3754    int exlen=getNumOfElements(example, sparse); //example.domain->attributes->size(); 
    36823755    int svm_type=svm_get_svm_type(model); 
    36833756    int nr_class=svm_get_nr_class(model); 
    3684     svm_node *x=Malloc(svm_node, (exlen+1>2)? exlen+1 : 2); 
    3685     example_to_svm(example, x, -1.0, (model->param.kernel_type==CUSTOM)? 1:0); 
     3757    svm_node *x=Malloc(svm_node, exlen); 
     3758    if(sparse) 
     3759        example_to_svm_sparse(example, x, -1.0); 
     3760    else 
     3761        example_to_svm(example, x, -1.0, (model->param.kernel_type==CUSTOM)? 1:0); 
    36863762    double v; 
    36873763    if(model->param.probability){ 
     
    36933769    currentExample=NULL; 
    36943770    free(x); 
    3695     TValue value; 
    36963771    if(svm_type==NU_SVR || svm_type==EPSILON_SVR || svm_type==ONE_CLASS) 
    36973772        return TValue(v); 
     
    37053780    //printf("enter getDecisionValues"); 
    37063781    currentExample=&example; 
    3707     int exlen=example.domain->attributes->size(); 
     3782    int exlen=getNumOfElements(example, sparse); 
    37083783    int svm_type=svm_get_svm_type(model); 
    37093784    int nr_class=svm_get_nr_class(model); 
    3710     svm_node *x=Malloc(svm_node, (exlen+1>2)? exlen+1 : 2); 
    3711     example_to_svm(example, x, -1.0, (model->param.kernel_type==CUSTOM)? 1:0); 
     3785    svm_node *x=Malloc(svm_node, exlen); 
     3786    if(sparse) 
     3787        example_to_svm_sparse(example, x,  -1.0); 
     3788    else 
     3789        example_to_svm(example, x, -1.0, (model->param.kernel_type==CUSTOM)? 1:0); 
    37123790    int nDecValues=nr_class*(nr_class-1)/2; 
    37133791    double *dec= (double*) malloc(sizeof(double)*nDecValues); 
  • source/orange/svm.hpp

    r3605 r3662  
    196196 
    197197    PClassifier operator()(PExampleGenerator, const int & = 0); 
    198 }; 
    199  
     198protected: 
     199    bool sparse; 
     200}; 
     201 
     202class ORANGE_API TSVMLearnerSparse : public TSVMLearner{ 
     203public: 
     204    TSVMLearnerSparse(); 
     205}; 
    200206 
    201207 
     
    204210    __REGISTER_CLASS 
    205211        TSVMClassifier(){}; 
    206     TSVMClassifier(PVariable, PExampleTable, svm_model*, svm_node*); 
     212    TSVMClassifier(PVariable, PExampleTable, svm_model*, svm_node*, bool); 
    207213    ~TSVMClassifier(); 
    208214 
     
    223229    svm_model* getModel(){return model;}; 
    224230 
     231    bool supportsSparse(){return sparse;} 
     232 
    225233private: 
    226234    svm_model *model; 
    227235    svm_node *x_space; 
     236    bool sparse; 
    228237}; 
    229238 
Note: See TracChangeset for help on using the changeset viewer.