Changeset 8113:e99d2a29426c in orange


Ignore:
Timestamp:
07/26/11 15:53:00 (3 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
bc294dbdbbdb186e0beb375b736dde675e79e39b
Message:

Exposed the Earth model to python.
Added pickling support.

Location:
source/orange
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • source/orange/earth.cpp

    r8090 r8113  
    29952995    threshold = 0.001; 
    29962996    prune = true; 
    2997     trace = 3; 
     2997    trace = 0.0; 
    29982998    min_span = 0; 
    29992999    fast_k = 20; 
     
    30803080 
    30813081    PEarthClassifier classifier = mlnew TEarthClassifier(examples->domain, best_set, dirs, cuts, betas, num_preds, num_responses, num_terms, max_terms); 
    3082     std::string str = classifier->format_earth(); 
     3082//  std::string str = classifier->format_earth(); 
    30833083 
    30843084    // Free memory 
     
    30933093} 
    30943094 
    3095 TEarthClassifier::TEarthClassifier(PDomain _domain, bool * _best_set, int * _dirs, double * _cuts, double *_betas, int _num_preds, int _num_responses, int _num_terms, int _max_terms) 
     3095TEarthClassifier::TEarthClassifier(PDomain _domain, bool * best_set, int * dirs, double * cuts, double *betas, int _num_preds, int _num_responses, int _num_terms, int _max_terms) 
    30963096{ 
    30973097    domain = _domain; 
    30983098    classVar = domain->classVar; 
    3099     best_set = _best_set; 
    3100     dirs = _dirs; 
    3101     cuts = _cuts; 
    3102     betas = _betas; 
     3099    _best_set = best_set; 
     3100    _dirs = dirs; 
     3101    _cuts = cuts; 
     3102    _betas = betas; 
    31033103    num_preds = _num_preds; 
    31043104    num_responses = _num_responses; 
     
    31063106    max_terms = _max_terms; 
    31073107    computesProbabilities = false; 
     3108    init_members(); 
     3109} 
     3110 
     3111TEarthClassifier::TEarthClassifier() 
     3112{ 
     3113    domain = NULL; 
     3114    classVar = NULL; 
     3115    _best_set = NULL; 
     3116    _dirs = NULL; 
     3117    _cuts = NULL; 
     3118    _betas = NULL; 
     3119    num_preds = 0; 
     3120    num_responses = 0; 
     3121    num_terms = 0; 
     3122    max_terms = 0; 
     3123    computesProbabilities = false; 
    31083124} 
    31093125 
     
    31133129} 
    31143130 
    3115 double round(double r) 
    3116 { 
    3117     return floor(r + 0.5); 
     3131TEarthClassifier::~TEarthClassifier() 
     3132{ 
     3133    if (_best_set) 
     3134        free(_best_set); 
     3135    if (_dirs) 
     3136        free(_dirs); 
     3137    if (_cuts) 
     3138        free(_cuts); 
     3139    if (_betas) 
     3140        free(_betas); 
    31183141} 
    31193142 
     
    31223145    double *x = to_xvector(example); 
    31233146    double y = 0.0; 
    3124     PredictEarth(&y, x, best_set, dirs, cuts, betas, num_preds, num_responses, num_terms, max_terms); 
     3147    PredictEarth(&y, x, _best_set, _dirs, _cuts, _betas, num_preds, num_responses, num_terms, max_terms); 
    31253148    free(x); 
    31263149    if (classVar->varType == TValue::INTVAR) 
    3127         return TValue((int) std::max<float>(0.0, round(y))); 
     3150        return TValue((int) std::max<float>(0.0, floor(y + 0.5))); 
    31283151    else 
    31293152        return TValue((float) y); 
     
    31313154 
    31323155std::string TEarthClassifier::format_earth(){ 
    3133     FormatEarth(best_set, dirs, cuts, betas, num_preds, 1, num_terms, max_terms, 3, 0.0); 
     3156    FormatEarth(_best_set, _dirs, _cuts, _betas, num_preds, 1, num_terms, max_terms, 3, 0.0); 
    31343157    // TODO: FormatEarth to a string. 
    31353158    return ""; 
    3136 } 
    3137  
    3138  
    3139 TEarthClassifier::~TEarthClassifier() 
    3140 { 
    3141     free(best_set); 
    3142     free(dirs); 
    3143     free(cuts); 
    3144     free(betas); 
    31453159} 
    31463160 
     
    31623176} 
    31633177 
     3178PBoolList TEarthClassifier::get_best_set() 
     3179{ 
     3180    PBoolList list = mlnew TBoolList(); 
     3181    for (bool * p=_best_set; p < _best_set + max_terms; p++) 
     3182         list->push_back(*p); 
     3183    return list; 
     3184} 
     3185 
     3186PFloatListList TEarthClassifier::get_dirs() 
     3187{ 
     3188    PFloatListList list = mlnew TFloatListList(); 
     3189    for (int i=0; i<max_terms; i++) 
     3190    { 
     3191        TFloatList * inner_list = mlnew TFloatList(); 
     3192        for(int j=0; j<num_preds; j++) 
     3193            inner_list->push_back(_dirs[i + j*max_terms]); 
     3194        list->push_back(inner_list); 
     3195    } 
     3196    return list; 
     3197} 
     3198 
     3199PFloatListList TEarthClassifier::get_cuts() 
     3200{ 
     3201    PFloatListList list = mlnew TFloatListList(); 
     3202    for (int i=0; i<max_terms; i++) 
     3203    { 
     3204        TFloatList * inner_list = mlnew TFloatList(); 
     3205        for (int j=0; j<num_preds; j++) 
     3206            inner_list->push_back(_cuts[i + j*max_terms]); 
     3207        list->push_back(inner_list); 
     3208    } 
     3209    return list; 
     3210} 
     3211 
     3212PFloatList TEarthClassifier::get_betas() 
     3213{ 
     3214    PFloatList list = mlnew TFloatList(); 
     3215    for (double * p=_betas; p < _betas + max_terms; p++) 
     3216        list->push_back((float)*p); 
     3217    return list; 
     3218} 
     3219 
     3220void TEarthClassifier::init_members() 
     3221{ 
     3222    best_set = get_best_set(); 
     3223    dirs = get_dirs(); 
     3224    cuts = get_cuts(); 
     3225    betas = get_betas(); 
     3226 
     3227} 
     3228 
     3229void TEarthClassifier::save_model(TCharBuffer& buffer) 
     3230{ 
     3231    buffer.writeInt(max_terms); 
     3232    buffer.writeInt(num_terms); 
     3233    buffer.writeInt(num_preds); 
     3234    buffer.writeInt(num_responses); 
     3235    buffer.writeBuf((void *) _best_set, sizeof(bool) * max_terms); 
     3236    buffer.writeBuf((void *) _dirs, sizeof(int) * max_terms * num_preds); 
     3237    buffer.writeBuf((void *) _cuts, sizeof(double) * max_terms * num_preds); 
     3238    buffer.writeBuf((void *) _betas, sizeof(double) * max_terms * num_responses); 
     3239} 
     3240 
     3241void TEarthClassifier::load_model(TCharBuffer& buffer) 
     3242{ 
     3243    if (max_terms) 
     3244        raiseError("Cannot overwrite a model"); 
     3245 
     3246    max_terms = buffer.readInt(); 
     3247    num_terms = buffer.readInt(); 
     3248    num_preds = buffer.readInt(); 
     3249    num_responses = buffer.readInt(); 
     3250 
     3251    _best_set = (bool *) calloc(max_terms, sizeof(bool)); 
     3252    _dirs = (int *) calloc(max_terms * num_preds, sizeof(int)); 
     3253    _cuts = (double *) calloc(max_terms * num_preds, sizeof(double)); 
     3254    _betas = (double *) calloc(max_terms * num_responses, sizeof(double)); 
     3255 
     3256    buffer.readBuf((void *) _best_set, sizeof(bool) * max_terms); 
     3257    buffer.readBuf((void *) _dirs, sizeof(int) * max_terms * num_preds); 
     3258    buffer.readBuf((void *) _cuts, sizeof(double) * max_terms * num_preds); 
     3259    buffer.readBuf((void *) _betas, sizeof(double) * max_terms * num_responses); 
     3260    init_members(); 
     3261} 
     3262 
     3263 
     3264 
  • source/orange/earth.hpp

    r8076 r8113  
    201201}; 
    202202 
     203#include "slist.hpp" 
     204 
    203205class ORANGE_API TEarthClassifier: public TClassifierFD { 
    204206public: 
    205207    __REGISTER_CLASS 
    206     TEarthClassifier() {}; 
     208 
     209    TEarthClassifier(); 
    207210    TEarthClassifier(PDomain domain, bool * best_set, int * dirs, double * cuts, double *betas, int num_preds, int num_responses, int num_terms, int max_terms); 
    208211    TEarthClassifier(const TEarthClassifier & other); 
     212 
    209213    virtual ~TEarthClassifier(); 
    210214 
     
    212216    std::string format_earth(); 
    213217 
    214     int num_preds; //P 
    215     int num_terms; //P 
    216     int max_terms; //P 
    217     int num_responses; //P 
    218  
     218    int num_preds; //P Number of predictor variables 
     219    int num_terms; //P Number of used terms 
     220    int max_terms; //P Maximum number of terms 
     221    int num_responses; //P Number of response variables 
     222 
     223    PBoolList best_set; //P Used terms. 
     224    PFloatListList dirs; //P max_preds x num_preds matrix 
     225    PFloatListList cuts; //P max_preds x num_preds matrix of cuts 
     226    PFloatList betas; //P Term coefficients; 
     227 
     228    void save_model(TCharBuffer& buffer); 
     229    void load_model(TCharBuffer& buffer); 
    219230private: 
    220231 
     232    PBoolList get_best_set(); 
     233    PFloatListList get_dirs(); 
     234    PFloatListList get_cuts(); 
     235    PFloatList get_betas(); 
     236 
     237    void init_members(); 
    221238    double* to_xvector(const TExample&); 
    222239 
    223     bool* best_set; 
    224     int * dirs; 
    225     double * cuts; 
    226     double * betas; 
     240    bool* _best_set; 
     241    int * _dirs; 
     242    double * _cuts; 
     243    double * _betas; 
    227244}; 
    228245 
  • source/orange/lib_learner.cpp

    r8074 r8113  
    15191519} 
    15201520 
     1521PyObject *EarthClassifier__reduce__(PyObject *self) PYARGS(METH_VARARGS, "") 
     1522{ 
     1523    PyTRY 
     1524    CAST_TO(TEarthClassifier, classifier); 
     1525    TCharBuffer buffer(1024); 
     1526    classifier->save_model(buffer); 
     1527    return Py_BuildValue("O(s#)N", getExportedFunction("__pickleLoaderEarthClassifier"), 
     1528                                    buffer.buf, buffer.length(), 
     1529                                    packOrangeDictionary(self)); 
     1530    PyCATCH 
     1531} 
     1532 
     1533PyObject *__pickleLoaderEarthClassifier(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(buffer)") 
     1534{ 
     1535    PyTRY 
     1536    char * cbuf = NULL; 
     1537    int buffer_size = 0; 
     1538    if (!PyArg_ParseTuple(args, "s#:__pickleLoaderEarthClassifier", &cbuf, &buffer_size)) 
     1539        return NULL; 
     1540    TCharBuffer buffer(cbuf); 
     1541    PEarthClassifier classifier = mlnew TEarthClassifier(); 
     1542    classifier->load_model(buffer); 
     1543    return WrapOrange(classifier); 
     1544    PyCATCH 
     1545} 
     1546 
     1547 
    15211548     
    15221549/************* BAYES ************/ 
Note: See TracChangeset for help on using the changeset viewer.