Ignore:
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • Orange/classification/logreg.py

    r11398 r11063  
    22from Orange.utils import deprecated_keywords, deprecated_members 
    33from Orange.data import preprocess 
    4 from Orange.data.continuization import DomainContinuizer 
    54import decimal 
    65import math 
     
    921920##  PROBABILITY CALCULATIONS 
    922921 
    923 def lchisqprob(chisq, df): 
     922def lchisqprob(chisq,df): 
    924923    """ 
    925924    Return the (1-tailed) probability value associated with the provided 
     
    927926    """ 
    928927    BIG = 20.0 
    929  
    930928    def ex(x): 
    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 
     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 
    938936    a = 0.5 * chisq 
    939     if df % 2 == 0: 
    940         even = 1 
     937    if df%2 == 0: 
     938        even = 1 
    941939    else: 
    942         even = 0 
     940        even = 0 
    943941    if df > 1: 
    944         y = ex(-a) 
     942        y = ex(-a) 
    945943    if even: 
    946         s = y 
     944        s = y 
    947945    else: 
    948946        s = 2.0 * zprob(-math.sqrt(chisq)) 
     
    955953        if a > BIG: 
    956954            if even: 
    957                 e = 0.0 
     955                e = 0.0 
    958956            else: 
    959                 e = math.log(math.sqrt(math.pi)) 
     957                e = math.log(math.sqrt(math.pi)) 
    960958            c = math.log(a) 
    961959            while (z <= chisq): 
    962                 e = math.log(z) + e 
    963                 s = s + ex(c * z - a - e) 
    964                 z = z + 1.0 
     960                e = math.log(z) + e 
     961                s = s + ex(c*z-a-e) 
     962                z = z + 1.0 
    965963            return s 
    966964        else: 
     
    971969            c = 0.0 
    972970            while (z <= chisq): 
    973                 e = e * (a / float(z)) 
     971                e = e * (a/float(z)) 
    974972                c = c + e 
    975973                z = z + 1.0 
    976             return (c * y + s) 
     974            return (c*y+s) 
    977975    else: 
    978976        return s 
     
    982980    """ 
    983981    Returns the area under the normal curve 'to the left of' the given z value. 
    984     Thus:: 
     982    Thus::  
    985983 
    986984    for z<0, zprob(z) = 1-tail probability 
     
    992990    Z_MAX = 6.0    # maximum meaningful z-value 
    993991    if z == 0.0: 
    994         x = 0.0 
     992    x = 0.0 
    995993    else: 
    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 
     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 
     1014    if z > 0.0: 
     1015    prob = ((x+1.0)*0.5) 
    10061016    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 
    1016     if z > 0.0: 
    1017         prob = ((x + 1.0) * 0.5) 
    1018     else: 
    1019         prob = ((1.0 - x) * 0.5) 
     1017    prob = ((1.0-x)*0.5) 
    10201018    return prob 
    10211019 
     
    10251023""" 
    10261024 
    1027  
     1025from Orange.data import preprocess 
    10281026class LibLinearLogRegLearner(Orange.core.LinearLearner): 
    10291027    """A logistic regression learner from `LIBLINEAR`_. 
    1030  
     1028     
    10311029    Supports L2 regularized learning. 
    1032  
     1030     
    10331031    .. _`LIBLINEAR`: http://www.csie.ntu.edu.tw/~cjlin/liblinear/ 
    1034  
     1032      
    10351033    """ 
    10361034 
     
    10421040 
    10431041    def __init__(self, solver_type=L2R_LR, C=1.0, eps=0.01, normalization=True, 
    1044             bias=-1.0, multinomial_treatment=DomainContinuizer.NValues, 
    1045             **kwargs): 
     1042            bias=-1.0, **kwargs): 
    10461043        """ 
    1047         :param solver_type: One of the following class constants: 
     1044        :param solver_type: One of the following class constants:  
    10481045            ``L2_LR``, ``L2_LR_DUAL``, ``L1R_LR``. 
    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). 
     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). 
    10531049        :type C: float 
    1054  
     1050         
    10551051        :param eps: Stopping criteria (default 0.01) 
    10561052        :type eps: float 
    1057  
     1053         
    10581054        :param normalization: Normalize the input data prior to learning 
    10591055            (default True) 
     
    10621058        :param bias: If positive, use it as a bias (default -1). 
    10631059        :type bias: float 
    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  
     1060         
    10751061        """ 
    10761062        self.solver_type = solver_type 
     
    10791065        self.normalization = normalization 
    10801066        self.bias = bias 
    1081         self.multinomial_treatment = multinomial_treatment 
    10821067 
    10831068        for name, value in kwargs.items(): 
     
    10891074 
    10901075        if data.domain.has_discrete_attributes(False) or self.normalization: 
    1091             dc = DomainContinuizer() 
    1092             dc.multinomial_treatment = self.multinomial_treatment 
     1076            dc = Orange.data.continuization.DomainContinuizer() 
     1077            dc.multinomial_treatment = dc.NValues 
    10931078            dc.class_treatment = dc.Ignore 
    10941079            dc.continuous_treatment = \ 
    10951080                    dc.NormalizeByVariance if self.normalization else dc.Leave 
    1096             c_domain = dc(data) 
     1081            c_domain = dc(data)  
    10971082            data = data.translate(c_domain) 
    10981083        return super(LibLinearLogRegLearner, self).__call__(data, weight_id) 
  • Orange/classification/svm/__init__.py

    r11397 r11377  
    2020 
    2121from Orange.data import preprocess 
    22 from Orange.data.preprocess import DomainContinuizer 
    2322 
    2423from Orange import feature as variable 
     
    806805 
    807806    def __init__(self, solver_type=L2R_L2LOSS_DUAL, C=1.0, eps=0.01, 
    808                  bias=1.0, normalization=True, 
    809                  multinomial_treatment=DomainContinuizer.NValues, **kwargs): 
     807                 bias=1.0, normalization=True, **kwargs): 
    810808        """ 
    811809        :param solver_type: One of the following class constants: 
     
    835833        :type normalization: bool 
    836834 
    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 
     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 
    851839            `normalization` is ``True``. 
    852840 
     
    864852        self.bias = bias 
    865853        self.normalization = normalization 
    866         self.multinomial_treatment = multinomial_treatment 
    867854 
    868855        for name, val in kwargs.items(): 
    869856            setattr(self, name, val) 
    870  
    871857        if self.solver_type not in [self.L2R_L2LOSS_DUAL, self.L2R_L2LOSS, 
    872858                self.L2R_L1LOSS_DUAL, self.L1R_L2LOSS]: 
    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             ) 
     859            warnings.warn("""\ 
     860Deprecated 'solver_type', use 
     861'Orange.classification.logreg.LibLinearLogRegLearner' 
     862to build a logistic regression model using LIBLINEAR. 
     863""", 
     864                DeprecationWarning) 
    879865 
    880866    def __call__(self, data, weight_id=None): 
     
    883869 
    884870        if data.domain.has_discrete_attributes(False) or self.normalization: 
    885             dc = DomainContinuizer() 
    886             dc.multinomial_treatment = self.multinomial_treatment 
     871            dc = Orange.data.continuization.DomainContinuizer() 
     872            dc.multinomial_treatment = dc.NValues 
    887873            dc.class_treatment = dc.Ignore 
    888874            dc.continuous_treatment = \ 
     
    902888 
    903889    def __init__(self, C=1.0, eps=0.01, bias=1.0, 
    904                  normalization=True, 
    905                  multinomial_treatment=DomainContinuizer.NValues, 
    906                  **kwargs): 
     890                 normalization=True, **kwargs): 
    907891        """\ 
    908892        :param C: Regularization parameter (default 1.0) 
     
    920904            (default True) 
    921905        :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` 
    932906 
    933907        """ 
     
    936910        self.bias = bias 
    937911        self.normalization = normalization 
    938         self.multinomial_treatment = multinomial_treatment 
    939912        for name, val in kwargs.items(): 
    940913            setattr(self, name, val) 
     
    947920 
    948921        if data.domain.has_discrete_attributes(False) or self.normalization: 
    949             dc = DomainContinuizer() 
    950             dc.multinomial_treatment = self.multinomial_treatment 
     922            dc = Orange.data.continuization.DomainContinuizer() 
     923            dc.multinomial_treatment = dc.NValues 
    951924            dc.class_treatment = dc.Ignore 
    952925            dc.continuous_treatment = \ 
  • Orange/testing/unit/tests/test_linear.py

    r11397 r11017  
    55from Orange.testing.testing import datasets_driven 
    66from Orange.classification.svm import LinearSVMLearner 
    7 from Orange.data.preprocess import DomainContinuizer 
    87try: 
    98    import unittest2 as unittest 
     
    1211 
    1312import numpy as np 
    14  
    15  
    16 def clone(obj): 
    17     return cPickle.loads(cPickle.dumps(obj)) 
    1813 
    1914 
     
    8176def test_learner_with_bias_on(self, dataset): 
    8277    learner = self.learner 
    83     learner_b = clone(learner) 
     78    learner_b = cPickle.loads(cPickle.dumps(learner)) 
    8479    learner_b.bias = 1 
    8580    try: 
     
    121116 
    122117 
    123 def 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  
    139118@datasets_driven(datasets=testing.CLASSIFICATION_DATASETS) 
    140119class TestLinearSVMLearnerL2R_L2LOSS_DUAL(testing.LearnerTestCase): 
     
    144123    test_learner_with_bias_on = test_learner_with_bias_on 
    145124    test_missing_instances = missing_instances_test 
    146     test_multinomial = multinomial_test 
    147125 
    148126 
     
    154132    test_learner_with_bias_on = test_learner_with_bias_on 
    155133    test_missing_instances = missing_instances_test 
    156     test_multinomial = multinomial_test 
    157134 
    158135 
     
    164141    test_learner_with_bias_on = test_learner_with_bias_on 
    165142    test_missing_instances = missing_instances_test 
    166     test_multinomial = multinomial_test 
    167143 
    168144 
     
    174150    test_learner_with_bias_on = test_learner_with_bias_on 
    175151    test_missing_instances = missing_instances_test 
    176     test_multinomial = multinomial_test 
    177152 
    178153 
     
    184159    test_learner_with_bias_on = test_learner_with_bias_on 
    185160    test_missing_instances = missing_instances_test 
    186     test_multinomial = multinomial_test 
    187161 
    188162 
     
    194168    test_learner_with_bias_on = test_learner_with_bias_on 
    195169    test_missing_instances = missing_instances_test 
    196     test_multinomial = multinomial_test 
    197170 
    198171 
  • Orange/utils/serverfiles.py

    r11396 r10581  
    624624    return found 
    625625 
    626  
    627626def search(sstrings, **kwargs): 
    628627    """Search for files in the local repository where all substrings in a list  
     
    633632    return _search(si, sstrings, **kwargs) 
    634633 
    635  
    636 def 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  
    656634class DownloadProgress(ConsoleProgressBar): 
    657635    redirect = None 
    658636    lock = threading.RLock() 
    659  
     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             
    660643    def __init__(self, filename, size): 
    661644        print "Downloading", filename 
     
    666649 
    667650    def sizeof_fmt(self, num): 
    668         return sizeformat(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 
    669655 
    670656    def getstring(self): 
    671         elapsed = max(time.time() - self.starttime, 0.1) 
    672         speed = int(self.state * self.size / 100.0 / elapsed) 
     657        speed = int(self.state * self.size / 100.0 / (time.time() - self.starttime)) 
    673658        eta = (100 - self.state) * self.size / 100.0 / speed 
    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  
     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         
    679661    def __call__(self, *args, **kwargs): 
    680662        ret = ConsoleProgressBar.__call__(self, *args, **kwargs) 
     
    682664            self.redirect(self.state) 
    683665        return ret 
    684  
     666     
    685667    class RedirectContext(object): 
    686668        def __enter__(self): 
    687669            DownloadProgress.lock.acquire() 
    688670            return DownloadProgress 
    689  
     671         
    690672        def __exit__(self, ex_type, value, tb): 
    691673            DownloadProgress.redirect = None 
    692674            DownloadProgress.lock.release() 
    693675            return False 
    694  
     676         
    695677    @classmethod 
    696678    def setredirect(cls, redirect): 
    697679        cls.redirect = staticmethod(redirect) 
    698680        return cls.RedirectContext() 
    699  
     681     
    700682    @classmethod 
    701683    def __enter__(cls): 
    702684        cls.lock.acquire() 
    703685        return cls 
    704  
     686     
    705687    @classmethod 
    706688    def __exit__(cls, exc_type, exc_value, traceback): 
    707689        cls.lock.release() 
    708690        return False 
    709  
    710691 
    711692def consoleupdate(domains=None, searchstr="essential"): 
  • source/orangeom/network.cpp

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