Changeset 9242:50db60f037bf in orange


Ignore:
Timestamp:
11/22/11 15:58:01 (2 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
ced9f01ddf9cc6c0ce7772b3f851b6f256909310
Message:

CamelCase parameters/variables to underscore.
Fixed compare_models function.

File:
1 edited

Legend:

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

    r8824 r9242  
    6161 
    6262 
     63from Orange.misc import deprecated_members, deprecated_keywords 
     64 
    6365class LinearRegressionLearner(base.BaseRegressionLearner): 
    6466 
     
    7274 
    7375    def __init__(self, name='linear regression', intercept=True, \ 
    74                  computeStats=True, ridgeLambda=None,\ 
     76                 compute_stats=True, ridge_lambda=None,\ 
    7577                 imputer=None, continuizer=None, \ 
    76                  useVars=None, stepwise=False, addSig=0.05, 
    77                  removeSig=0.2, **kwds): 
     78                 use_vars=None, stepwise=False, add_sig=0.05, 
     79                 remove_sig=0.2, **kwds): 
    7880        """ 
    7981        :param name: name of the linear model, default 'linear regression' 
     
    8284            in the model 
    8385        :type intercept: boolean 
    84         :param computeStats: if True, statistical properties of 
     86        :param compute_stats: if True, statistical properties of 
    8587            the estimators (standard error, t-scores, significances) 
    8688            and statistical properties of the model 
    8789            (sum of squares, R2, adjusted R2) are computed 
    88         :type computeStats: boolean 
    89         :param ridgeLambda: if not None, the lambda parameter 
     90        :type compute_stats: boolean 
     91        :param ridge_lambda: if not None, the lambda parameter 
    9092            in ridge regression 
    91         :type ridgeLambda: integer or None 
    92         :param useVars: the list of independent varaiables included in 
     93        :type ridge_lambda: integer or None 
     94        :param use_vars: the list of independent varaiables included in 
    9395            regression model. If None (default) all variables are used 
    94         :type useVars: list of Orange.data.variable or None 
     96        :type use_vars: list of Orange.data.variable or None 
    9597        :param stepwise: if True, _`stepwise regression`: 
    9698            http://en.wikipedia.org/wiki/Stepwise_regression 
    9799            based on F-test is performed. The significance parameters are 
    98             addSig and removeSig 
     100            add_sig and remove_sig 
    99101        :type stepwise: boolean 
    100         :param addSig: lower bound of significance for which the variable 
     102        :param add_sig: lower bound of significance for which the variable 
    101103            is included in regression model 
    102104            default value = 0.05 
    103         :type addSig: float 
    104         :param removeSig: upper bound of significance for which 
     105        :type add_sig: float 
     106        :param remove_sig: upper bound of significance for which 
    105107            the variable is excluded from the regression model 
    106108            default value = 0.2 
    107         :type removeSig: float 
     109        :type remove_sig: float 
    108110        """ 
    109111        self.name = name 
    110112        self.intercept = intercept 
    111         self.computeStats = computeStats 
    112         self.ridgeLambda = ridgeLambda 
     113        self.compute_stats = compute_stats 
     114        self.ridge_lambda = ridge_lambda 
    113115        self.set_imputer(imputer=imputer) 
    114116        self.set_continuizer(continuizer=continuizer) 
    115117        self.stepwise = stepwise 
    116         self.addSig = addSig 
    117         self.removeSig = removeSig 
    118         self.useVars = useVars 
     118        self.add_sig = add_sig 
     119        self.remove_sig = remove_sig 
     120        self.use_vars = use_vars 
    119121        self.__dict__.update(kwds) 
    120122         
     
    129131            which stores weights for instances 
    130132        """        
    131         if not self.useVars is None: 
    132             newDomain = Orange.data.Domain(self.useVars, 
     133        if not self.use_vars is None: 
     134            new_domain = Orange.data.Domain(self.use_vars, 
    133135                                            table.domain.class_var) 
    134             newDomain.addmetas(table.domain.getmetas()) 
    135             table = Orange.data.Table(newDomain, table) 
     136            new_domain.addmetas(table.domain.getmetas()) 
     137            table = Orange.data.Table(new_domain, table) 
    136138 
    137139        # dicrete values are continuized         
     
    142144 
    143145        if self.stepwise: 
    144             useVars = stepwise(table, weight, addSig=self.addSig, 
    145                                       removeSig=self.removeSig) 
    146             newDomain = Orange.data.Domain(useVars, table.domain.class_var) 
    147             newDomain.addmetas(table.domain.getmetas()) 
    148             table = Orange.data.Table(newDomain, table) 
     146            use_vars = stepwise(table, weight, add_sig=self.add_sig, 
     147                                      remove_sig=self.remove_sig) 
     148            new_domain = Orange.data.Domain(use_vars, table.domain.class_var) 
     149            new_domain.addmetas(table.domain.getmetas()) 
     150            table = Orange.data.Table(new_domain, table) 
    149151 
    150152        # convertion to numpy 
     
    174176                W[i, i] = float(ins[weight]) 
    175177 
    176         computeStats = self.computeStats 
     178        compute_stats = self.compute_stats 
    177179        # adds some robustness by computing the pseudo inverse; 
    178180        # normal inverse could fail due to singularity of the X.T * W * X 
    179         if self.ridgeLambda is None: 
    180             cov = pinv(dot(dot(X.T, W), X))         
     181        if self.ridge_lambda is None: 
     182            cov = pinv(dot(dot(X.T, W), X)) 
    181183        else: 
    182             cov = pinv(dot(dot(X.T, W), X) - self.ridgeLambda*numpy.eye(m+1)) 
    183             computeStats = False # TO DO: find inferential properties of the estimators 
     184            cov = pinv(dot(dot(X.T, W), X) - self.ridge_lambda*numpy.eye(m+1)) 
     185            compute_stats = False # TO DO: find inferential properties of the estimators 
    184186        D = dot(dot(cov, X.T), W) 
    185187        coefficients = dot(D, y) 
    186188 
    187         muY, sigmaY = numpy.mean(y), numpy.std(y) 
     189        mu_y, sigma_y = numpy.mean(y), numpy.std(y) 
    188190        if A is not None: 
    189             covX = numpy.cov(X, rowvar=0) 
     191            cov_x = numpy.cov(X, rowvar=0) 
    190192 
    191193            # standardized coefficients 
    192             stdCoefficients = (sqrt(covX.diagonal()) / sigmaY) \ 
    193                                * coefficients 
    194  
    195         if computeStats is False: 
     194            std_coefficients = (sqrt(cov_x.diagonal()) / sigma_y) \ 
     195                                * coefficients 
     196        else: 
     197            std_coefficients = None 
     198 
     199        if compute_stats is False: 
    196200            return LinearRegression(domain.class_var, domain, coefficients=coefficients, 
    197                                     std_coefficients=stdCoefficients, intercept=self.intercept) 
     201                                    std_coefficients=std_coefficients, intercept=self.intercept) 
    198202             
    199203 
    200204        fitted = dot(X, coefficients) 
    201         residuals = [ins.get_class()-fitted[i] \ 
     205        residuals = [ins.get_class() - fitted[i] \ 
    202206                     for i, ins in enumerate(table)] 
    203207 
    204208        # model summary         
    205209        # total sum of squares (total variance) 
    206         sst = numpy.sum((y - muY) ** 2) 
     210        sst = numpy.sum((y - mu_y) ** 2) 
    207211        # sum of squares due to regression (explained variance) 
    208         ssr = numpy.sum((fitted - muY)**2) 
     212        ssr = numpy.sum((fitted - mu_y)**2) 
    209213        # error sum of squares (unexplaied variance) 
    210214        sse = sst - ssr 
     
    214218        F = (ssr/m)/(sst-ssr/(n-m-1)) 
    215219        df = n-2  
    216         sigmaSquare = sse/(n-m-1) 
     220        sigma_square = sse/(n-m-1) 
    217221        # standard error of the regression estimator, t-scores and p-values 
    218         stdError = sqrt(sigmaSquare*pinv(dot(X.T, X)).diagonal()) 
    219         tScores = coefficients/stdError 
    220         pVals = [scipy.stats.betai(df*0.5,0.5,df/(df + t*t)) \ 
    221                  for t in tScores] 
     222        std_error = sqrt(sigma_square*pinv(dot(X.T, X)).diagonal()) 
     223        t_scores = coefficients/std_error 
     224        p_vals = [scipy.stats.betai(df*0.5,0.5,df/(df + t*t)) \ 
     225                  for t in t_scores] 
    222226 
    223227        # dictionary of regression coefficients with standard errors 
    224228        # and p-values 
    225         dictModel = {} 
     229        dict_model = {} 
    226230        if self.intercept: 
    227             dictModel["Intercept"] = (coefficients[0],\ 
    228                                       stdError[0], \ 
    229                                       tScores[0], \ 
    230                                       pVals[0]) 
     231            dict_model["Intercept"] = (coefficients[0],\ 
     232                                      std_error[0], \ 
     233                                      t_scores[0], \ 
     234                                      p_vals[0]) 
    231235        for i, var in enumerate(domain.attributes): 
    232236            j = i + 1 if self.intercept else i 
    233             dictModel[var.name] = (coefficients[j], \ 
    234                                    stdError[j],\ 
    235                                    tScores[j],\ 
    236                                    pVals[j]) 
     237            dict_model[var.name] = (coefficients[j], \ 
     238                                   std_error[j],\ 
     239                                   t_scores[j],\ 
     240                                   p_vals[j]) 
    237241         
    238242        return LinearRegression(domain.class_var, domain, coefficients, F, 
    239                  std_error=stdError, t_scores=tScores, p_vals=pVals, dict_model=dictModel, 
    240                  fitted=fitted, residuals=residuals, m=m, n=n, mu_y=muY, 
     243                 std_error=std_error, t_scores=t_scores, p_vals=p_vals, dict_model=dict_model, 
     244                 fitted=fitted, residuals=residuals, m=m, n=n, mu_y=mu_y, 
    241245                 r2=r2, r2adj=r2adj, sst=sst, sse=sse, ssr=ssr, 
    242                  std_coefficients=stdCoefficients, intercept=self.intercept) 
    243  
     246                 std_coefficients=std_coefficients, intercept=self.intercept) 
     247 
     248deprecated_members({"ridgeLambda": "ridge_lambda", 
     249                    "computeStats": "compute_stats", 
     250                    "useVars": "use_vars", 
     251                    "addSig": "add_sig", 
     252                    "removeSig": "remove_sig", 
     253                    } 
     254                   , ["__init__"], 
     255                   in_place=True)(LinearRegressionLearner) 
    244256 
    245257class LinearRegression(Orange.classification.Classifier): 
     
    367379        if self.intercept: 
    368380            if len(self.coefficients) > 1: 
    369                 yHat = self.coefficients[0] + \ 
     381                y_hat = self.coefficients[0] + \ 
    370382                       dot(self.coefficients[1:], ins[:-1]) 
    371383            else: 
    372384                if len(ins) == 1: 
    373385                    print ins 
    374                     yHat = self.mu_y 
     386                    y_hat = self.mu_y 
    375387                else: 
    376                     yHat = dot(self.coefficients, ins[:-1]) 
     388                    y_hat = dot(self.coefficients, ins[:-1]) 
    377389        else: 
    378             yHat = dot(self.coefficients, ins[:-1]) 
    379 #        yHat = Orange.data.Value(yHat) 
    380         yHat = self.class_var(yHat) 
     390            y_hat = dot(self.coefficients, ins[:-1]) 
     391#        y_hat = Orange.data.Value(y_hat) 
     392        y_hat = self.class_var(y_hat) 
    381393        dist = Orange.statistics.distribution.Continuous(self.class_var) 
    382         dist[yHat] = 1.0 
     394        dist[y_hat] = 1.0 
    383395        if resultType == Orange.classification.Classifier.GetValue: 
    384             return yHat 
     396            return y_hat 
    385397        if resultType == Orange.classification.Classifier.GetProbabilities: 
    386398            return dist 
    387         return (yHat, dist) 
     399        return (y_hat, dist) 
    388400 
    389401 
     
    442454    if c1 == None or c2 == None: 
    443455        return 1.0 
    444     p1, p2, n = c1.model.m, c2.model.m, c1.model.n 
    445     RSS1, RSS2 = c1.model.sse, c2.model.sse 
     456    p1, p2, n = c1.m, c2.m, c1.n 
     457    RSS1, RSS2 = c1.sse, c2.sse 
    446458    if RSS1 <= RSS2 or p2 <= p1 or n <= p2 or RSS2 <= 0: 
    447459        return 1.0 
     
    450462 
    451463 
    452 def stepwise(table, weight, addSig=0.05, removeSig=0.2): 
     464@deprecated_keywords({"addSig": "add_sig", "removeSig": "remove_sig"}) 
     465def stepwise(table, weight, add_sig=0.05, remove_sig=0.2): 
    453466    """ Performs _`stepwise linear regression`: 
    454467    http://en.wikipedia.org/wiki/Stepwise_regression 
     
    462475    :type weight: None or list of Orange.data.variable.Continuous 
    463476        which stores the weights 
    464     :param addSig: lower bound of significance for which the variable 
     477    :param add_sig: lower bound of significance for which the variable 
    465478        is included in regression model 
    466479        default value = 0.05 
    467     :type addSig: float 
    468     :param removeSig: upper bound of significance for which the variable 
     480    :type add_sig: float 
     481    :param remove_sig: upper bound of significance for which the variable 
    469482        is excluded from the regression model 
    470483        default value = 0.2 
    471     :type removeSig: float 
     484    :type remove_sig: float 
    472485    """ 
    473486 
    474487     
    475     incVars = [] 
    476     notIncVars = table.domain.attributes 
    477  
    478     changedModel = True 
    479     while changedModel: 
    480         changedModel = False 
     488    inc_vars = [] 
     489    not_inc_vars = table.domain.attributes 
     490 
     491    changed_model = True 
     492    while changed_model: 
     493        changed_model = False 
    481494        # remove all unsignificant conditions (learn several models, 
    482495        # where each time one variable is removed and check significance) 
    483         c0 = LinearRegressionLearner(table, useVars=incVars) 
    484         reducedModel = [] # reduced model 
    485         for ati in range(len(incVars)): 
     496        c0 = LinearRegressionLearner(table, use_vars=inc_vars) 
     497        reduced_model = [] # reduced model 
     498        for ati in range(len(inc_vars)): 
    486499            try: 
    487                 reducedModel.append(LinearRegressionLearner(table, weight, 
    488                         useVars=incVars[:ati] + incVars[(ati + 1):])) 
     500                reduced_model.append(LinearRegressionLearner(table, weight, 
     501                        use_vars=inc_vars[:ati] + inc_vars[(ati + 1):])) 
    489502            except: 
    490                 reducedModel.append(None) 
     503                reduced_model.append(None) 
    491504         
    492         sigs = [compare_models(r, c0) for r in reducedModel] 
    493         if sigs and max(sigs) > removeSig: 
     505        sigs = [compare_models(r, c0) for r in reduced_model] 
     506        if sigs and max(sigs) > remove_sig: 
    494507            # remove that variable, start again 
    495             critVar = incVars[sigs.index(max(sigs))] 
    496             notIncVars.append(critVar) 
    497             incVars.remove(critVar) 
    498             changedModel = True 
     508            crit_var = inc_vars[sigs.index(max(sigs))] 
     509            not_inc_vars.append(crit_var) 
     510            inc_vars.remove(crit_var) 
     511            changed_model = True 
    499512            continue 
    500513 
    501514        # add all significant conditions (go through all attributes in 
    502         # notIncVars, is there one that significantly improves the model? 
    503         extendedModel = [] 
    504         for ati in range(len(notIncVars)): 
     515        # not_inc_vars, is there one that significantly improves the model? 
     516        extended_model = [] 
     517        for ati in range(len(not_inc_vars)): 
    505518            try: 
    506                 extendedModel.append(LinearRegressionLearner(table, 
    507                         weight, useVars=incVars + [notIncVars[ati]])) 
     519                extended_model.append(LinearRegressionLearner(table, 
     520                        weight, use_vars=inc_vars + [not_inc_vars[ati]])) 
    508521            except: 
    509                 extendedModel.append(None) 
     522                extended_model.append(None) 
    510523              
    511         sigs = [compare_models(c0, r) for r in extendedModel] 
    512         if sigs and min(sigs) < addSig: 
    513             bestVar = notIncVars[sigs.index(min(sigs))] 
    514             incVars.append(bestVar) 
    515             notIncVars.remove(bestVar) 
    516             changedModel = True 
    517     return incVars 
     524        sigs = [compare_models(c0, r) for r in extended_model] 
     525        if sigs and min(sigs) < add_sig: 
     526            best_var = not_inc_vars[sigs.index(min(sigs))] 
     527            inc_vars.append(best_var) 
     528            not_inc_vars.remove(best_var) 
     529            changed_model = True 
     530    return inc_vars 
    518531 
    519532 
Note: See TracChangeset for help on using the changeset viewer.