Ignore:
File:
1 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) 
Note: See TracChangeset for help on using the changeset viewer.