Changeset 9244:a72343977108 in orange


Ignore:
Timestamp:
11/22/11 18:13:27 (2 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
af059c27407113ec26acdd757f44f878b671f974
Message:

CamelCase parameters/variables to underscore.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/regression/lasso.py

    r8824 r9244  
    6565from Orange.regression import base 
    6666 
     67from Orange.misc import deprecated_members, deprecated_keywords 
     68 
    6769def center(X): 
    6870    """Centers the data, i.e. subtracts the column means. 
     
    115117 
    116118    def __init__(self, name='lasso regression', t=1, tol=0.001, \ 
    117                  nBoot=100, nPerm=100, imputer=None, continuizer=None): 
     119                 n_boot=100, n_perm=100, imputer=None, continuizer=None): 
    118120        """ 
    119121        :param name: name of the linear model, default 'lasso regression' 
     
    126128            default=0.001 
    127129        :type tol: float 
    128         :param nBoot: number of bootstrap samples used for non-parametric 
     130        :param n_boot: number of bootstrap samples used for non-parametric 
    129131            estimation of standard errors 
    130         :type nBoot: int 
    131         :param nPerm: number of permuations used for non-parametric 
     132        :type n_boot: int 
     133        :param n_perm: number of permuations used for non-parametric 
    132134            estimation of p-values 
    133         :type nPerm: int 
     135        :type n_perm: int 
    134136        """ 
    135137 
     
    137139        self.t = t 
    138140        self.tol = tol 
    139         self.nBoot = nBoot 
    140         self.nPerm = nPerm 
     141        self.n_boot = n_boot 
     142        self.n_perm = n_perm 
    141143        self.set_imputer(imputer=imputer) 
    142144        self.set_continuizer(continuizer=continuizer) 
     
    162164        X, y, w = table.to_numpy() 
    163165        n, m = numpy.shape(X) 
    164         X, muX = center(X) 
     166        X, mu_x = center(X) 
    165167        y, coef0 = center(y) 
    166168 
     
    170172        objective = lambda beta: numpy.linalg.norm(y - numpy.dot(X, beta)) 
    171173        # initial guess for the regression parameters 
    172         betaInit = numpy.random.random(m) 
     174        beta_init = numpy.random.random(m) 
    173175        # constraints for the regression coefficients 
    174176        cnstr = lambda beta: self.t - sum(numpy.abs(beta)) 
    175177        # optimal solution 
    176         coefficients = scipy.optimize.fmin_cobyla(objective, betaInit,\ 
     178        coefficients = scipy.optimize.fmin_cobyla(objective, beta_init,\ 
    177179                                                       cnstr) 
    178180 
     
    183185        # bootstrap estimator of standard error of the coefficient estimators 
    184186        # assumption: fixed t 
    185         if self.nBoot > 0: 
    186             coeffB = [] # bootstrapped coefficients 
    187             for i in range(self.nBoot): 
    188                 tmpTable = get_bootstrap_sample(table) 
    189                 l = LassoRegressionLearner(t=self.t, nBoot=0, nPerm=0) 
    190                 c = l(tmpTable) 
    191                 coeffB.append(c.coefficients) 
    192             stdErrorsFixedT = numpy.std(coeffB, axis=0) 
     187        if self.n_boot > 0: 
     188            coeff_b = [] # bootstrapped coefficients 
     189            for i in range(self.n_boot): 
     190                tmp_table = get_bootstrap_sample(table) 
     191                l = LassoRegressionLearner(t=self.t, n_boot=0, n_perm=0) 
     192                c = l(tmp_table) 
     193                coeff_b.append(c.coefficients) 
     194            std_errors_fixed_t = numpy.std(coeff_b, axis=0) 
    193195        else: 
    194             stdErrorsFixedT = [float("nan")] * m 
     196            std_errors_fixed_t = [float("nan")] * m 
    195197 
    196198        # permutation test to obtain the significance of the regression 
    197199        #coefficients 
    198         if self.nPerm > 0: 
    199             coeffP = [] 
    200             for i in range(self.nPerm): 
    201                 tmpTable = permute_responses(table) 
    202                 l = LassoRegressionLearner(t=self.t, nBoot=0, nPerm=0) 
    203                 c = l(tmpTable) 
    204                 coeffP.append(c.coefficients) 
    205             pVals = \ 
    206                    numpy.sum(abs(numpy.array(coeffP))>\ 
     200        if self.n_perm > 0: 
     201            coeff_p = [] 
     202            for i in range(self.n_perm): 
     203                tmp_table = permute_responses(table) 
     204                l = LassoRegressionLearner(t=self.t, n_boot=0, n_perm=0) 
     205                c = l(tmp_table) 
     206                coeff_p.append(c.coefficients) 
     207            p_vals = \ 
     208                   numpy.sum(abs(numpy.array(coeff_p))>\ 
    207209                             abs(numpy.array(coefficients)), \ 
    208                              axis=0)/float(self.nPerm) 
     210                             axis=0)/float(self.n_perm) 
    209211        else: 
    210             pVals = [float("nan")] * m 
     212            p_vals = [float("nan")] * m 
    211213 
    212214        # dictionary of regression coefficients with standard errors 
    213215        # and p-values 
    214         dictModel = {} 
     216        dict_model = {} 
    215217        for i, var in enumerate(domain.attributes): 
    216             dictModel[var.name] = (coefficients[i], stdErrorsFixedT[i], pVals[i])             
     218            dict_model[var.name] = (coefficients[i], std_errors_fixed_t[i], p_vals[i])             
    217219        
    218220        return LassoRegression(domain=domain, class_var=domain.class_var, 
    219221                               coef0=coef0, coefficients=coefficients, 
    220                                stdErrorsFixedT=stdErrorsFixedT, 
    221                                pVals=pVals, 
    222                                dictModel= dictModel, 
    223                                muX=muX) 
    224  
     222                               std_errors_fixed_t=std_errors_fixed_t, 
     223                               p_vals=p_vals, 
     224                               dict_model= dict_model, 
     225                               mu_x=mu_x) 
     226 
     227deprecated_members({"nBoot": "n_boot", 
     228                    "nPerm": "n_perm"},  
     229                   wrap_methods=["__init__"], 
     230                   in_place=True)(LassoRegressionLearner) 
    225231 
    226232class LassoRegression(Orange.classification.Classifier): 
     
    236242        list of regression coefficients.  
    237243 
    238     .. attribute:: stdErrorsFixedT 
     244    .. attribute:: std_errors_fixed_t 
    239245 
    240246        list of standard errors of the coefficient estimator for the fixed 
     
    242248        bootstrapping method. 
    243249 
    244     .. attribute:: pVals 
     250    .. attribute:: p_vals 
    245251 
    246252        list of p-values for the null hypothesis that the regression 
    247253        coefficients equal 0 based on non-parametric permutation test 
    248254 
    249     .. attribute:: dictModel 
     255    .. attribute:: dict_model 
    250256 
    251257        dictionary of statistical properties of the model. 
     
    253259        Values - tuples (coefficient, standard error, p-value)  
    254260 
    255     .. attribute:: muX 
     261    .. attribute:: mu_x 
    256262 
    257263        the sample mean of the all independent variables     
     
    259265    """  
    260266    def __init__(self, domain=None, class_var=None, coef0=None, 
    261                  coefficients=None, stdErrorsFixedT=None, pVals=None, 
    262                  dictModel=None, muX=None): 
     267                 coefficients=None, std_errors_fixed_t=None, p_vals=None, 
     268                 dict_model=None, mu_x=None): 
    263269        self.domain = domain 
    264270        self.class_var = class_var 
    265271        self.coef0 = coef0 
    266272        self.coefficients = coefficients 
    267         self.stdErrorsFixedT = stdErrorsFixedT 
    268         self.pVals = pVals 
    269         self.dictModel = dictModel 
    270         self.muX = muX 
    271  
    272     def __call__(self, instance,\ 
    273                  resultType=Orange.classification.Classifier.GetValue): 
     273        self.std_errors_fixed_t = std_errors_fixed_t 
     274        self.p_vals = p_vals 
     275        self.dict_model = dict_model 
     276        self.mu_x = mu_x 
     277 
     278    @deprecated_keywords({"resultType": "result_type"}) 
     279    def __call__(self, instance, result_type=Orange.core.GetValue): 
    274280        """ 
    275281        :param instance: data instance for which the value of the response 
     
    281287            def miss_2_0(x): return x if x != "?" else 0 
    282288            ins = map(miss_2_0, ins) 
    283             ins = numpy.array(ins)[:-1] - self.muX 
     289            ins = numpy.array(ins)[:-1] - self.mu_x 
    284290        else: 
    285             ins = numpy.array(ins.native())[:-1] - self.muX 
    286  
    287         yHat = numpy.dot(self.coefficients, ins) + self.coef0  
    288         yHat = self.class_var(yHat) 
     291            ins = numpy.array(ins.native())[:-1] - self.mu_x 
     292 
     293        y_hat = numpy.dot(self.coefficients, ins) + self.coef0  
     294        y_hat = self.class_var(y_hat) 
    289295        dist = Orange.statistics.distribution.Continuous(self.class_var) 
    290         dist[yHat] = 1.0 
    291         if resultType == Orange.classification.Classifier.GetValue: 
    292             return yHat 
    293         if resultType == Orange.classification.Classifier.GetProbabilities: 
     296        dist[y_hat] = 1.0 
     297        if result_type == Orange.core.GetValue: 
     298            return y_hat 
     299        if result_type == Orange.core.GetProbabilities: 
    294300            return dist 
    295         return (yHat, dist)     
    296  
    297  
    298  
    299 def print_lasso_regression_model(lr, skipZero=True): 
     301        return (y_hat, dist)     
     302 
     303deprecated_members({"muX": "mu_x", 
     304                    "stdErrorsFixedT": "std_errors_fixed_t", 
     305                    "pVals": "p_vals", 
     306                    "dictModel": "dict_model"}, 
     307                   wrap_methods=["__init__"], 
     308                   in_place=True)(LassoRegression) 
     309 
     310 
     311@deprecated_keywords({"skipZero": "skip_zero"}) 
     312def print_lasso_regression_model(lr, skip_zero=True): 
    300313    """Pretty-prints Lasso regression model, 
    301314    i.e. estimated regression coefficients with standard errors 
     
    305318    :param lr: a Lasso regression model object. 
    306319    :type lr: :class:`LassoRegression` 
    307     :param skipZero: if True variables with estimated coefficient equal to 0 
     320    :param skip_zero: if True variables with estimated coefficient equal to 0 
    308321        are omitted 
    309     :type skipZero: boolean 
     322    :type skip_zero: boolean 
    310323    """ 
    311324     
     
    325338        else: return " " 
    326339 
    327     stars =  get_star(m.pVals[0]) 
     340    stars =  get_star(m.p_vals[0]) 
    328341    print fmt1 % ('Intercept', m.coef0) 
    329342    skipped = [] 
    330343    for i in range(len(m.domain.attributes)): 
    331         if m.coefficients[i] == 0. and skipZero: 
     344        if m.coefficients[i] == 0. and skip_zero: 
    332345            skipped.append(m.domain.attributes[i].name) 
    333346            continue             
    334         stars = get_star(m.pVals[i]) 
     347        stars = get_star(m.p_vals[i]) 
    335348        print fmt % (m.domain.attributes[i].name, \ 
    336                      m.coefficients[i], m.stdErrorsFixedT[i], \ 
    337                      m.pVals[i], stars) 
     349                     m.coefficients[i], m.std_errors_fixed_t[i], \ 
     350                     m.p_vals[i], stars) 
    338351    print "Signif. codes:  0 *** 0.001 ** 0.01 * 0.05 . 0.1 empty 1" 
    339352    print "\n" 
    340     if skipZero: 
     353    if skip_zero: 
    341354        k = len(skipped) 
    342355        if k == 0: 
Note: See TracChangeset for help on using the changeset viewer.