Ignore:
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • Orange/classification/logreg.py

    r11063 r11398  
    22from Orange.utils import deprecated_keywords, deprecated_members 
    33from Orange.data import preprocess 
     4from Orange.data.continuization import DomainContinuizer 
    45import decimal 
    56import math 
     
    920921##  PROBABILITY CALCULATIONS 
    921922 
    922 def lchisqprob(chisq,df): 
     923def lchisqprob(chisq, df): 
    923924    """ 
    924925    Return the (1-tailed) probability value associated with the provided 
     
    926927    """ 
    927928    BIG = 20.0 
     929 
    928930    def ex(x): 
    929         BIG = 20.0 
    930         if x < -BIG: 
    931             return 0.0 
    932         else: 
    933             return math.exp(x) 
    934     if chisq <=0 or df < 1: 
    935         return 1.0 
     931        BIG = 20.0 
     932        if x < -BIG: 
     933            return 0.0 
     934        else: 
     935            return math.exp(x) 
     936    if chisq <= 0 or df < 1: 
     937        return 1.0 
    936938    a = 0.5 * chisq 
    937     if df%2 == 0: 
    938         even = 1 
     939    if df % 2 == 0: 
     940        even = 1 
    939941    else: 
    940         even = 0 
     942        even = 0 
    941943    if df > 1: 
    942         y = ex(-a) 
     944        y = ex(-a) 
    943945    if even: 
    944         s = y 
     946        s = y 
    945947    else: 
    946948        s = 2.0 * zprob(-math.sqrt(chisq)) 
     
    953955        if a > BIG: 
    954956            if even: 
    955                 e = 0.0 
     957                e = 0.0 
    956958            else: 
    957                 e = math.log(math.sqrt(math.pi)) 
     959                e = math.log(math.sqrt(math.pi)) 
    958960            c = math.log(a) 
    959961            while (z <= chisq): 
    960                 e = math.log(z) + e 
    961                 s = s + ex(c*z-a-e) 
    962                 z = z + 1.0 
     962                e = math.log(z) + e 
     963                s = s + ex(c * z - a - e) 
     964                z = z + 1.0 
    963965            return s 
    964966        else: 
     
    969971            c = 0.0 
    970972            while (z <= chisq): 
    971                 e = e * (a/float(z)) 
     973                e = e * (a / float(z)) 
    972974                c = c + e 
    973975                z = z + 1.0 
    974             return (c*y+s) 
     976            return (c * y + s) 
    975977    else: 
    976978        return s 
     
    980982    """ 
    981983    Returns the area under the normal curve 'to the left of' the given z value. 
    982     Thus::  
     984    Thus:: 
    983985 
    984986    for z<0, zprob(z) = 1-tail probability 
     
    990992    Z_MAX = 6.0    # maximum meaningful z-value 
    991993    if z == 0.0: 
    992     x = 0.0 
     994        x = 0.0 
    993995    else: 
    994     y = 0.5 * math.fabs(z) 
    995     if y >= (Z_MAX*0.5): 
    996         x = 1.0 
    997     elif (y < 1.0): 
    998         w = y*y 
    999         x = ((((((((0.000124818987 * w 
    1000             -0.001075204047) * w +0.005198775019) * w 
    1001               -0.019198292004) * w +0.059054035642) * w 
    1002             -0.151968751364) * w +0.319152932694) * w 
    1003           -0.531923007300) * w +0.797884560593) * y * 2.0 
    1004     else: 
    1005         y = y - 2.0 
    1006         x = (((((((((((((-0.000045255659 * y 
    1007                  +0.000152529290) * y -0.000019538132) * y 
    1008                -0.000676904986) * y +0.001390604284) * y 
    1009              -0.000794620820) * y -0.002034254874) * y 
    1010                +0.006549791214) * y -0.010557625006) * y 
    1011              +0.011630447319) * y -0.009279453341) * y 
    1012            +0.005353579108) * y -0.002141268741) * y 
    1013          +0.000535310849) * y +0.999936657524 
     996        y = 0.5 * math.fabs(z) 
     997    if y >= (Z_MAX * 0.5): 
     998        x = 1.0 
     999    elif (y < 1.0): 
     1000        w = y * y 
     1001        x = ((((((((0.000124818987 * w 
     1002            - 0.001075204047) * w + 0.005198775019) * w 
     1003              - 0.019198292004) * w + 0.059054035642) * w 
     1004            - 0.151968751364) * w + 0.319152932694) * w 
     1005          - 0.531923007300) * w + 0.797884560593) * y * 2.0 
     1006    else: 
     1007        y = y - 2.0 
     1008        x = (((((((((((((-0.000045255659 * y 
     1009                 + 0.000152529290) * y - 0.000019538132) * y 
     1010               - 0.000676904986) * y + 0.001390604284) * y 
     1011             - 0.000794620820) * y - 0.002034254874) * y 
     1012               + 0.006549791214) * y - 0.010557625006) * y 
     1013             + 0.011630447319) * y - 0.009279453341) * y 
     1014           + 0.005353579108) * y - 0.002141268741) * y 
     1015         + 0.000535310849) * y + 0.999936657524 
    10141016    if z > 0.0: 
    1015     prob = ((x+1.0)*0.5) 
     1017        prob = ((x + 1.0) * 0.5) 
    10161018    else: 
    1017     prob = ((1.0-x)*0.5) 
     1019        prob = ((1.0 - x) * 0.5) 
    10181020    return prob 
    10191021 
     
    10231025""" 
    10241026 
    1025 from Orange.data import preprocess 
     1027 
    10261028class LibLinearLogRegLearner(Orange.core.LinearLearner): 
    10271029    """A logistic regression learner from `LIBLINEAR`_. 
    1028      
     1030 
    10291031    Supports L2 regularized learning. 
    1030      
     1032 
    10311033    .. _`LIBLINEAR`: http://www.csie.ntu.edu.tw/~cjlin/liblinear/ 
    1032       
     1034 
    10331035    """ 
    10341036 
     
    10401042 
    10411043    def __init__(self, solver_type=L2R_LR, C=1.0, eps=0.01, normalization=True, 
    1042             bias=-1.0, **kwargs): 
     1044            bias=-1.0, multinomial_treatment=DomainContinuizer.NValues, 
     1045            **kwargs): 
    10431046        """ 
    1044         :param solver_type: One of the following class constants:  
     1047        :param solver_type: One of the following class constants: 
    10451048            ``L2_LR``, ``L2_LR_DUAL``, ``L1R_LR``. 
    1046          
    1047         :param C: Regularization parameter (default 1.0). Higher values of C mean  
    1048             less regularization (C is a coefficient for the loss function). 
     1049 
     1050        :param C: Regularization parameter (default 1.0). Higher values of 
     1051            C mean less regularization (C is a coefficient for the loss 
     1052            function). 
    10491053        :type C: float 
    1050          
     1054 
    10511055        :param eps: Stopping criteria (default 0.01) 
    10521056        :type eps: float 
    1053          
     1057 
    10541058        :param normalization: Normalize the input data prior to learning 
    10551059            (default True) 
     
    10581062        :param bias: If positive, use it as a bias (default -1). 
    10591063        :type bias: float 
    1060          
     1064 
     1065        :param multinomial_treatment: Defines how to handle multinomial 
     1066            features for learning. It can be one of the 
     1067            :class:`~.DomainContinuizer` `multinomial_treatment` 
     1068            constants (default: `DomainContinuizer.NValues`). 
     1069 
     1070        :type multinomial_treatment: int 
     1071 
     1072        .. versionadded:: 2.6.1 
     1073            Added `multinomial_treatment` 
     1074 
    10611075        """ 
    10621076        self.solver_type = solver_type 
     
    10651079        self.normalization = normalization 
    10661080        self.bias = bias 
     1081        self.multinomial_treatment = multinomial_treatment 
    10671082 
    10681083        for name, value in kwargs.items(): 
     
    10741089 
    10751090        if data.domain.has_discrete_attributes(False) or self.normalization: 
    1076             dc = Orange.data.continuization.DomainContinuizer() 
    1077             dc.multinomial_treatment = dc.NValues 
     1091            dc = DomainContinuizer() 
     1092            dc.multinomial_treatment = self.multinomial_treatment 
    10781093            dc.class_treatment = dc.Ignore 
    10791094            dc.continuous_treatment = \ 
    10801095                    dc.NormalizeByVariance if self.normalization else dc.Leave 
    1081             c_domain = dc(data)  
     1096            c_domain = dc(data) 
    10821097            data = data.translate(c_domain) 
    10831098        return super(LibLinearLogRegLearner, self).__call__(data, weight_id) 
  • Orange/classification/svm/__init__.py

    r11377 r11397  
    2020 
    2121from Orange.data import preprocess 
     22from Orange.data.preprocess import DomainContinuizer 
    2223 
    2324from Orange import feature as variable 
     
    805806 
    806807    def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01, 
    807                  bias=1.0, normalization=True, **kwargs): 
     808                 bias=1.0, normalization=True, 
     809                 multinomial_treatment=DomainContinuizer.NValues, **kwargs): 
    808810        """ 
    809811        :param solver_type: One of the following class constants: 
     
    833835        :type normalization: bool 
    834836 
    835         .. note:: If the training data contains discrete features they are 
    836             replaced by indicator columns one for each value of the feature 
    837             regardless of the value of `normalization`. This is different 
    838             then in :class:`SVMLearner` where this is done only if 
     837        :param multinomial_treatment: Defines how to handle multinomial 
     838            features for learning. It can be one of the 
     839            :class:`~.DomainContinuizer` `multinomial_treatment` 
     840            constants (default: `DomainContinuizer.NValues`). 
     841 
     842        :type multinomial_treatment: int 
     843 
     844        .. versionadded:: 2.6.1 
     845            Added `multinomial_treatment` 
     846 
     847        .. note:: By default if the training data contains discrete features 
     848            they are replaced by indicator columns one for each value of the 
     849            feature regardless of the value of `normalization`. This is 
     850            different then in :class:`SVMLearner` where this is done only if 
    839851            `normalization` is ``True``. 
    840852 
     
    852864        self.bias = bias 
    853865        self.normalization = normalization 
     866        self.multinomial_treatment = multinomial_treatment 
    854867 
    855868        for name, val in kwargs.items(): 
    856869            setattr(self, name, val) 
     870 
    857871        if self.solver_type not in [self.L2R_L2LOSS_DUAL, self.L2R_L2LOSS, 
    858872                self.L2R_L1LOSS_DUAL, self.L1R_L2LOSS]: 
    859             warnings.warn("""\ 
    860 Deprecated 'solver_type', use 
    861 'Orange.classification.logreg.LibLinearLogRegLearner' 
    862 to build a logistic regression model using LIBLINEAR. 
    863 """, 
    864                 DeprecationWarning) 
     873            warnings.warn( 
     874                " Deprecated 'solver_type', use " 
     875                "'Orange.classification.logreg.LibLinearLogRegLearner'" 
     876                "to build a logistic regression models using LIBLINEAR.", 
     877                DeprecationWarning 
     878            ) 
    865879 
    866880    def __call__(self, data, weight_id=None): 
     
    869883 
    870884        if data.domain.has_discrete_attributes(False) or self.normalization: 
    871             dc = Orange.data.continuization.DomainContinuizer() 
    872             dc.multinomial_treatment = dc.NValues 
     885            dc = DomainContinuizer() 
     886            dc.multinomial_treatment = self.multinomial_treatment 
    873887            dc.class_treatment = dc.Ignore 
    874888            dc.continuous_treatment = \ 
     
    888902 
    889903    def __init__(self, C=1.0, eps=0.01, bias=1.0, 
    890                  normalization=True, **kwargs): 
     904                 normalization=True, 
     905                 multinomial_treatment=DomainContinuizer.NValues, 
     906                 **kwargs): 
    891907        """\ 
    892908        :param C: Regularization parameter (default 1.0) 
     
    904920            (default True) 
    905921        :type normalization: bool 
     922 
     923        :param multinomial_treatment: Defines how to handle multinomial 
     924            features for learning. It can be one of the 
     925            :class:`~.DomainContinuizer` `multinomial_treatment` 
     926            constants (default: `DomainContinuizer.NValues`). 
     927 
     928        :type multinomial_treatment: int 
     929 
     930        .. versionadded:: 2.6.1 
     931            Added `multinomial_treatment` 
    906932 
    907933        """ 
     
    910936        self.bias = bias 
    911937        self.normalization = normalization 
     938        self.multinomial_treatment = multinomial_treatment 
    912939        for name, val in kwargs.items(): 
    913940            setattr(self, name, val) 
     
    920947 
    921948        if data.domain.has_discrete_attributes(False) or self.normalization: 
    922             dc = Orange.data.continuization.DomainContinuizer() 
    923             dc.multinomial_treatment = dc.NValues 
     949            dc = DomainContinuizer() 
     950            dc.multinomial_treatment = self.multinomial_treatment 
    924951            dc.class_treatment = dc.Ignore 
    925952            dc.continuous_treatment = \ 
  • Orange/testing/unit/tests/test_linear.py

    r11017 r11397  
    55from Orange.testing.testing import datasets_driven 
    66from Orange.classification.svm import LinearSVMLearner 
     7from Orange.data.preprocess import DomainContinuizer 
    78try: 
    89    import unittest2 as unittest 
     
    1112 
    1213import numpy as np 
     14 
     15 
     16def clone(obj): 
     17    return cPickle.loads(cPickle.dumps(obj)) 
    1318 
    1419 
     
    7681def test_learner_with_bias_on(self, dataset): 
    7782    learner = self.learner 
    78     learner_b = cPickle.loads(cPickle.dumps(learner)) 
     83    learner_b = clone(learner) 
    7984    learner_b.bias = 1 
    8085    try: 
     
    116121 
    117122 
     123def multinomial_test(self): 
     124    data = Orange.data.Table("lenses") 
     125    learner = clone(self.learner) 
     126    learner.multinomial_treatment = DomainContinuizer.NValues 
     127    classifier = learner(data) 
     128    self.assertEqual(len(classifier.domain), 7) 
     129 
     130    learner.multinomial_treatment = DomainContinuizer.FrequentIsBase 
     131    classifier = learner(data) 
     132    self.assertEqual(len(classifier.domain), 6) 
     133 
     134    learner.multinomial_treatment = DomainContinuizer.ReportError 
     135    with self.assertRaises(Orange.core.KernelException): 
     136        classifier = learner(data) 
     137 
     138 
    118139@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    119140class TestLinearSVMLearnerL2R_L2LOSS_DUAL(testing.LearnerTestCase): 
     
    123144    test_learner_with_bias_on = test_learner_with_bias_on 
    124145    test_missing_instances = missing_instances_test 
     146    test_multinomial = multinomial_test 
    125147 
    126148 
     
    132154    test_learner_with_bias_on = test_learner_with_bias_on 
    133155    test_missing_instances = missing_instances_test 
     156    test_multinomial = multinomial_test 
    134157 
    135158 
     
    141164    test_learner_with_bias_on = test_learner_with_bias_on 
    142165    test_missing_instances = missing_instances_test 
     166    test_multinomial = multinomial_test 
    143167 
    144168 
     
    150174    test_learner_with_bias_on = test_learner_with_bias_on 
    151175    test_missing_instances = missing_instances_test 
     176    test_multinomial = multinomial_test 
    152177 
    153178 
     
    159184    test_learner_with_bias_on = test_learner_with_bias_on 
    160185    test_missing_instances = missing_instances_test 
     186    test_multinomial = multinomial_test 
    161187 
    162188 
     
    168194    test_learner_with_bias_on = test_learner_with_bias_on 
    169195    test_missing_instances = missing_instances_test 
     196    test_multinomial = multinomial_test 
    170197 
    171198 
  • Orange/utils/serverfiles.py

    r10581 r11396  
    624624    return found 
    625625 
     626 
    626627def search(sstrings, **kwargs): 
    627628    """Search for files in the local repository where all substrings in a list  
     
    632633    return _search(si, sstrings, **kwargs) 
    633634 
     635 
     636def sizeformat(size): 
     637    """ 
     638    >>> sizeformat(256) 
     639    256 bytes 
     640    >>> sizeformat(1024) 
     641    1.0 KB 
     642    >>> sizeformat(1.5 * 2 ** 20) 
     643    1.5 MB 
     644 
     645    """ 
     646    for unit in ['bytes', 'KB', 'MB', 'GB', 'TB']: 
     647        if size < 1024.0: 
     648            if unit == "bytes": 
     649                return "%1.0f %s" % (size, unit) 
     650            else: 
     651                return "%3.1f %s" % (size, unit) 
     652        size /= 1024.0 
     653    return "%.1f PB" % size 
     654 
     655 
    634656class DownloadProgress(ConsoleProgressBar): 
    635657    redirect = None 
    636658    lock = threading.RLock() 
    637     def sizeof_fmt(num): 
    638         for x in ['bytes','KB','MB','GB','TB']: 
    639             if num < 1024.0: 
    640                 return "%3.1f %s" % (num, x) if x <> 'bytes' else "%1.0f %s" % (num, x) 
    641             num /= 1024.0 
    642              
     659 
    643660    def __init__(self, filename, size): 
    644661        print "Downloading", filename 
     
    649666 
    650667    def sizeof_fmt(self, num): 
    651         for x in ['bytes','KB','MB','GB','TB']: 
    652             if num < 1024.0: 
    653                 return "%3.1f %s" % (num, x) if x <> 'bytes' else "%1.0f %s" % (num, x) 
    654             num /= 1024.0 
     668        return sizeformat(num) 
    655669 
    656670    def getstring(self): 
    657         speed = int(self.state * self.size / 100.0 / (time.time() - self.starttime)) 
     671        elapsed = max(time.time() - self.starttime, 0.1) 
     672        speed = int(self.state * self.size / 100.0 / elapsed) 
    658673        eta = (100 - self.state) * self.size / 100.0 / speed 
    659         return ConsoleProgressBar.getstring(self) + "  %s  %12s/s  %3i:%02i ETA" % (self.sizeof_fmt(self.size), self.sizeof_fmt(speed), eta/60, eta%60) 
    660          
     674        return ConsoleProgressBar.getstring(self) + \ 
     675               "  %s  %12s/s  %3i:%02i ETA" % (self.sizeof_fmt(self.size), 
     676                                               self.sizeof_fmt(speed), 
     677                                               eta / 60, eta % 60) 
     678 
    661679    def __call__(self, *args, **kwargs): 
    662680        ret = ConsoleProgressBar.__call__(self, *args, **kwargs) 
     
    664682            self.redirect(self.state) 
    665683        return ret 
    666      
     684 
    667685    class RedirectContext(object): 
    668686        def __enter__(self): 
    669687            DownloadProgress.lock.acquire() 
    670688            return DownloadProgress 
    671          
     689 
    672690        def __exit__(self, ex_type, value, tb): 
    673691            DownloadProgress.redirect = None 
    674692            DownloadProgress.lock.release() 
    675693            return False 
    676          
     694 
    677695    @classmethod 
    678696    def setredirect(cls, redirect): 
    679697        cls.redirect = staticmethod(redirect) 
    680698        return cls.RedirectContext() 
    681      
     699 
    682700    @classmethod 
    683701    def __enter__(cls): 
    684702        cls.lock.acquire() 
    685703        return cls 
    686      
     704 
    687705    @classmethod 
    688706    def __exit__(cls, exc_type, exc_value, traceback): 
    689707        cls.lock.release() 
    690708        return False 
     709 
    691710 
    692711def consoleupdate(domains=None, searchstr="essential"): 
  • source/orangeom/network.cpp

    r10312 r11395  
    461461#include "orange_api.hpp" 
    462462WRAPPER(GraphAsList); 
     463 
    463464PyObject *Network_new(PyTypeObject *type, PyObject *args, PyObject *kwds) BASED_ON (GraphAsList, "(nVertices, directed[, nEdgeTypes])") 
    464465{ 
     
    488489        { 
    489490            //cout << "2" << endl; 
    490         TGraphAsList *graph = PyOrange_AsGraphAsList(pygraph).getUnwrappedPtr(); 
     491            TGraphAsList *graph = dynamic_cast<TGraphAsList *>(PyOrange_AsOrange(pygraph).getUnwrappedPtr()); 
    491492            TNetwork *network = mlnew TNetwork(graph); 
    492493             
Note: See TracChangeset for help on using the changeset viewer.