Changeset 8824:8b8dcd6e830e in orange


Ignore:
Timestamp:
08/29/11 13:20:17 (3 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
26530c83227a7f36bad9c660674425d145b3f2fa
Message:

Moved learned model parameters to the corresponding Regression instance.
Some bug fixes.

Location:
orange/Orange/regression
Files:
3 edited

Legend:

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

    r8788 r8824  
    6767        """ 
    6868        if table.has_missing_values(): 
    69             self.imputer = self.imputer(table) 
    70             table = self.imputer(table) 
     69            imputer = self.imputer(table) 
     70            table = imputer(table) 
    7171        return table 
    7272 
  • orange/Orange/regression/lasso.py

    r8790 r8824  
    111111    before fitting the regression parameters 
    112112 
    113     .. attribute:: coeff0 
    114  
    115         intercept (sample mean of the response variable)     
    116  
    117     .. attribute:: coefficients 
    118  
    119         list of regression coefficients.  
    120  
    121     .. attribute:: stdErrorsFixedT 
    122  
    123         list of standard errors of the coefficient estimator for the fixed 
    124         tuning parameter t. The standard errors are estimated using 
    125         bootstrapping method. 
    126  
    127     .. attribute:: pVals 
    128  
    129         list of p-values for the null hypothesis that the regression 
    130         coefficients equal 0 based on non-parametric permutation test 
    131  
    132     .. attribute:: dictModel 
    133  
    134         dictionary of statistical properties of the model. 
    135         Keys - names of the independent variables 
    136         Values - tuples (coefficient, standard error, p-value)  
    137  
    138     .. attribute:: muX 
    139  
    140         the sample mean of the all independent variables     
    141  
    142  
    143113    """ 
    144114     
    145115 
    146116    def __init__(self, name='lasso regression', t=1, tol=0.001, \ 
    147                  imputer=None, continuizer=None): 
     117                 nBoot=100, nPerm=100, imputer=None, continuizer=None): 
    148118        """ 
    149119        :param name: name of the linear model, default 'lasso regression' 
     
    156126            default=0.001 
    157127        :type tol: float 
     128        :param nBoot: number of bootstrap samples used for non-parametric 
     129            estimation of standard errors 
     130        :type nBoot: int 
     131        :param nPerm: number of permuations used for non-parametric 
     132            estimation of p-values 
     133        :type nPerm: int 
    158134        """ 
    159135 
     
    161137        self.t = t 
    162138        self.tol = tol 
     139        self.nBoot = nBoot 
     140        self.nPerm = nPerm 
    163141        self.set_imputer(imputer=imputer) 
    164142        self.set_continuizer(continuizer=continuizer) 
    165143         
    166144         
    167     def __call__(self, table, weight=None, nBoot=100, nPerm=100): 
     145    def __call__(self, table, weight=None): 
    168146        """ 
    169147        :param table: data instances. 
     
    174152        :type weight: None or list of Orange.data.variable.Continuous 
    175153            which stores weights for instances 
    176         :param nBoot: number of bootstrap samples used for non-parametric 
    177             estimation of standard errors 
    178         :type nBoot: int 
    179         :param nPerm: number of permuations used for non-parametric 
    180             estimation of p-values 
    181         :type nPerm: int 
    182154         
    183155        """   
     
    187159        table = self.impute_table(table) 
    188160 
    189         self.domain = table.domain 
     161        domain = table.domain 
    190162        X, y, w = table.to_numpy() 
    191163        n, m = numpy.shape(X) 
    192         X, self.muX = center(X) 
    193         y, self.coef0 = center(y) 
     164        X, muX = center(X) 
     165        y, coef0 = center(y) 
    194166 
    195167        import scipy.optimize 
    196168 
    197169        # objective function to be minimized 
    198         objective = lambda beta: numpy.linalg.norm(y-numpy.dot(X,beta)) 
     170        objective = lambda beta: numpy.linalg.norm(y - numpy.dot(X, beta)) 
    199171        # initial guess for the regression parameters 
    200172        betaInit = numpy.random.random(m) 
     
    202174        cnstr = lambda beta: self.t - sum(numpy.abs(beta)) 
    203175        # optimal solution 
    204         self.coefficients = scipy.optimize.fmin_cobyla(objective, betaInit,\ 
     176        coefficients = scipy.optimize.fmin_cobyla(objective, betaInit,\ 
    205177                                                       cnstr) 
    206178 
    207179        # set small coefficients to 0 
    208180        def set_2_0(c): return c if abs(c) > self.tol else 0 
    209         self.coefficients = map(set_2_0, self.coefficients) 
     181        coefficients = map(set_2_0, coefficients) 
    210182 
    211183        # bootstrap estimator of standard error of the coefficient estimators 
    212184        # assumption: fixed t 
    213         if nBoot > 0: 
     185        if self.nBoot > 0: 
    214186            coeffB = [] # bootstrapped coefficients 
    215             for i in range(nBoot): 
     187            for i in range(self.nBoot): 
    216188                tmpTable = get_bootstrap_sample(table) 
    217                 l = LassoRegressionLearner(t=self.t) 
    218                 c = l(tmpTable, nBoot=0, nPerm=0) 
    219                 coeffB.append(l.coefficients) 
    220             self.stdErrorsFixedT = numpy.std(coeffB, axis=0) 
     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) 
    221193        else: 
    222             self.stdErrorsFixedT = [float("nan")] * m 
     194            stdErrorsFixedT = [float("nan")] * m 
    223195 
    224196        # permutation test to obtain the significance of the regression 
    225197        #coefficients 
    226         if nPerm > 0: 
     198        if self.nPerm > 0: 
    227199            coeffP = [] 
    228             for i in range(nPerm): 
     200            for i in range(self.nPerm): 
    229201                tmpTable = permute_responses(table) 
    230                 l = LassoRegressionLearner(t=self.t) 
    231                 c = l(tmpTable, nBoot=0, nPerm=0) 
    232                 coeffP.append(l.coefficients) 
    233             self.pVals = \ 
    234                        numpy.sum(abs(numpy.array(coeffP))>\ 
    235                                  abs(numpy.array(self.coefficients)), \ 
    236                                  axis=0)/float(nPerm) 
     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))>\ 
     207                             abs(numpy.array(coefficients)), \ 
     208                             axis=0)/float(self.nPerm) 
    237209        else: 
    238             self.pVals = [float("nan")] * m 
     210            pVals = [float("nan")] * m 
    239211 
    240212        # dictionary of regression coefficients with standard errors 
    241213        # and p-values 
    242         self.dictModel = {} 
    243         for i, var in enumerate(self.domain.attributes): 
    244             self.dictModel[var.name] = (self.coefficients[i], self.stdErrorsFixedT[i], self.pVals[i])             
     214        dictModel = {} 
     215        for i, var in enumerate(domain.attributes): 
     216            dictModel[var.name] = (coefficients[i], stdErrorsFixedT[i], pVals[i])             
    245217        
    246         return LassoRegression(self) 
     218        return LassoRegression(domain=domain, class_var=domain.class_var, 
     219                               coef0=coef0, coefficients=coefficients, 
     220                               stdErrorsFixedT=stdErrorsFixedT, 
     221                               pVals=pVals, 
     222                               dictModel= dictModel, 
     223                               muX=muX) 
    247224 
    248225 
     
    251228    based on the values of independent variables. 
    252229 
    253     .. attribute:: model 
    254      
    255         fitted lasso regression model    
     230    .. attribute:: coef0 
     231 
     232        intercept (sample mean of the response variable)     
     233 
     234    .. attribute:: coefficients 
     235 
     236        list of regression coefficients.  
     237 
     238    .. attribute:: stdErrorsFixedT 
     239 
     240        list of standard errors of the coefficient estimator for the fixed 
     241        tuning parameter t. The standard errors are estimated using 
     242        bootstrapping method. 
     243 
     244    .. attribute:: pVals 
     245 
     246        list of p-values for the null hypothesis that the regression 
     247        coefficients equal 0 based on non-parametric permutation test 
     248 
     249    .. attribute:: dictModel 
     250 
     251        dictionary of statistical properties of the model. 
     252        Keys - names of the independent variables 
     253        Values - tuples (coefficient, standard error, p-value)  
     254 
     255    .. attribute:: muX 
     256 
     257        the sample mean of the all independent variables     
    256258 
    257259    """  
    258     def __init__(self, model): 
    259         """ 
    260         :param model: fitted lasso regression model 
    261         :type model: :class:`LassoRegressionLearner` 
    262         """ 
    263         self.model = model 
     260    def __init__(self, domain=None, class_var=None, coef0=None, 
     261                 coefficients=None, stdErrorsFixedT=None, pVals=None, 
     262                 dictModel=None, muX=None): 
     263        self.domain = domain 
     264        self.class_var = class_var 
     265        self.coef0 = coef0 
     266        self.coefficients = coefficients 
     267        self.stdErrorsFixedT = stdErrorsFixedT 
     268        self.pVals = pVals 
     269        self.dictModel = dictModel 
     270        self.muX = muX 
    264271 
    265272    def __call__(self, instance,\ 
     
    270277        :type instance:  
    271278        """   
    272         ins = Orange.data.Instance(self.model.domain, instance) 
     279        ins = Orange.data.Instance(self.domain, instance) 
    273280        if "?" in ins: # missing value -> corresponding coefficient omitted 
    274281            def miss_2_0(x): return x if x != "?" else 0 
    275282            ins = map(miss_2_0, ins) 
    276             ins = numpy.array(ins)[:-1]-self.model.muX 
     283            ins = numpy.array(ins)[:-1] - self.muX 
    277284        else: 
    278             ins = numpy.array(ins.native())[:-1]-self.model.muX 
    279  
    280         yHat = numpy.dot(self.model.coefficients, ins) + self.model.coef0  
    281         yHat = Orange.data.Value(yHat) 
    282           
     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) 
     289        dist = Orange.statistics.distribution.Continuous(self.class_var) 
     290        dist[yHat] = 1.0 
    283291        if resultType == Orange.classification.Classifier.GetValue: 
    284292            return yHat 
    285293        if resultType == Orange.classification.Classifier.GetProbabilities: 
    286             return Orange.statistics.distribution.Continuous({1.0: yHat}) 
    287         return (yHat, Orange.statistics.distribution.Continuous({1.0: yHat}))     
     294            return dist 
     295        return (yHat, dist)     
    288296 
    289297 
     
    303311     
    304312    from string import join 
    305     m = lr.model     
     313    m = lr 
    306314    labels = ('Variable', 'Coeff Est', 'Std Error', 'p') 
    307315    print join(['%10s' % l for l in labels], ' ') 
  • orange/Orange/regression/linear.py

    r8789 r8824  
    6767    :class:`Orange.regression.base.BaseRegressionLearner` 
    6868    which is used for preprocessing the data (continuization and imputation) 
    69     before fitting the regression parameters 
    70  
    71     .. attribute:: F 
    72      
    73         F-statistics of the model. 
    74  
    75     .. attribute:: coefficients 
    76  
    77         list of regression coefficients. If the intercept is included 
    78         the first item corresponds to the estimated intercept 
    79  
    80     .. attribute:: stdError 
    81  
    82         list of standard errors of the coefficient estimator.     
    83  
    84     .. attribute:: tScores 
    85  
    86         list of t-scores for the estimated regression coefficients     
    87  
    88     .. attribute:: pVals 
    89  
    90         list of p-values for the null hypothesis that the regression 
    91         coefficients equal 0 based on t-scores and two sided 
    92         alternative hypothesis     
    93  
    94     .. attribute:: dictModel 
    95  
    96         dictionary of statistical properties of the model. 
    97         Keys - names of the independent variables (or "Intercept") 
    98         Values - tuples (coefficient, standard error, 
    99         t-value, p-value) 
    100  
    101     .. attribute:: fitted 
    102  
    103         estimated values of the dependent variable for all instances 
    104         from the table 
    105  
    106     .. attribute:: residuals 
    107  
    108         differences between estimated and actual values of the 
    109         dependent variable for all instances from the table 
    110  
    111     .. attribute:: m 
    112  
    113         number of independent variables     
    114  
    115     .. attribute:: n 
    116  
    117         number of instances     
    118  
    119     .. attribute:: muY 
    120  
    121         the sample mean of the dependent variable     
    122  
    123     .. attribute:: r2 
    124  
    125         _`coefficient of determination`: 
    126         http://en.wikipedia.org/wiki/Coefficient_of_determination 
    127  
    128     .. attribute:: r2adj 
    129  
    130         adjusted coefficient of determination 
    131  
    132     .. attribute:: sst, sse, ssr 
    133  
    134         total sum of squares, explained sum of squares and 
    135         residual sum of squares respectively 
    136  
    137     .. attribute:: stdCoefficients 
    138  
    139         standardized regression coefficients 
    140  
     69    before fitting the regression parameters. 
    14170 
    14271    """     
     
    233162        else: 
    234163             X = A 
    235  
    236         self.domain, self.m, self.n = table.domain, m, n 
    237  
     164              
     165        domain = table.domain 
     166         
    238167        if numpy.std(y) < 10e-6: # almost constant variable 
    239168            return Orange.regression.mean.MeanLearner(table) 
     
    245174                W[i, i] = float(ins[weight]) 
    246175 
     176        computeStats = self.computeStats 
    247177        # adds some robustness by computing the pseudo inverse; 
    248178        # normal inverse could fail due to singularity of the X.T * W * X 
     
    251181        else: 
    252182            cov = pinv(dot(dot(X.T, W), X) - self.ridgeLambda*numpy.eye(m+1)) 
    253             self.computeStats = False # TO DO: find inferential properties of the estimators 
     183            computeStats = False # TO DO: find inferential properties of the estimators 
    254184        D = dot(dot(cov, X.T), W) 
    255         self.coefficients = dot(D, y) 
    256  
    257         self.muY, sigmaY = numpy.mean(y), numpy.std(y) 
     185        coefficients = dot(D, y) 
     186 
     187        muY, sigmaY = numpy.mean(y), numpy.std(y) 
    258188        if A is not None: 
    259189            covX = numpy.cov(X, rowvar=0) 
    260190 
    261191            # standardized coefficients 
    262             self.stdCoefficients = (sqrt(covX.diagonal()) / sigmaY) \ 
    263                                    * self.coefficients 
    264  
    265         if self.computeStats is False: 
    266             return LinearRegression(self) 
    267  
    268         self.fitted = dot(X, self.coefficients) 
    269         self.residuals = [ins.get_class()-self.fitted[i] \ 
    270                           for i, ins in enumerate(table)] 
     192            stdCoefficients = (sqrt(covX.diagonal()) / sigmaY) \ 
     193                               * coefficients 
     194 
     195        if computeStats is False: 
     196            return LinearRegression(domain.class_var, domain, coefficients=coefficients, 
     197                                    std_coefficients=stdCoefficients, intercept=self.intercept) 
     198             
     199 
     200        fitted = dot(X, coefficients) 
     201        residuals = [ins.get_class()-fitted[i] \ 
     202                     for i, ins in enumerate(table)] 
    271203 
    272204        # model summary         
    273205        # total sum of squares (total variance) 
    274         self.sst = numpy.sum((y - self.muY) ** 2) 
     206        sst = numpy.sum((y - muY) ** 2) 
    275207        # sum of squares due to regression (explained variance) 
    276         self.ssr = numpy.sum((self.fitted - self.muY)**2) 
    277         # eror sum of squares (unexplaied variance) 
    278         self.sse = self.sst - self.ssr 
     208        ssr = numpy.sum((fitted - muY)**2) 
     209        # error sum of squares (unexplaied variance) 
     210        sse = sst - ssr 
    279211        # coefficient of determination 
    280         self.r2 = self.ssr / self.sst 
    281         self.r2adj = 1-(1-self.r2)*(n-1)/(n-m-1) 
    282         self.F = (self.ssr/m)/(self.sst-self.ssr/(n-m-1)) 
     212        r2 = ssr / sst 
     213        r2adj = 1-(1-r2)*(n-1)/(n-m-1) 
     214        F = (ssr/m)/(sst-ssr/(n-m-1)) 
    283215        df = n-2  
    284         sigmaSquare = self.sse/(n-m-1) 
     216        sigmaSquare = sse/(n-m-1) 
    285217        # standard error of the regression estimator, t-scores and p-values 
    286         self.stdError = sqrt(sigmaSquare*pinv(dot(X.T, X)).diagonal()) 
    287         self.tScores = self.coefficients/self.stdError 
    288         self.pVals=[scipy.stats.betai(df*0.5,0.5,df/(df + t*t)) \ 
    289                     for t in self.tScores] 
     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] 
    290222 
    291223        # dictionary of regression coefficients with standard errors 
    292224        # and p-values 
    293         self.dictModel = {} 
     225        dictModel = {} 
    294226        if self.intercept: 
    295             self.dictModel["Intercept"] = (self.coefficients[0],\ 
    296                                            self.stdError[0], \ 
    297                                            self.tScores[0], \ 
    298                                            self.pVals[0]) 
    299         for i, var in enumerate(self.domain.attributes): 
    300             j = i+1 if self.intercept else i 
    301             self.dictModel[var.name] = (self.coefficients[j], \ 
    302                                         self.stdError[j],\ 
    303                                         self.tScores[j],\ 
    304                                         self.pVals[j]) 
     227            dictModel["Intercept"] = (coefficients[0],\ 
     228                                      stdError[0], \ 
     229                                      tScores[0], \ 
     230                                      pVals[0]) 
     231        for i, var in enumerate(domain.attributes): 
     232            j = i + 1 if self.intercept else i 
     233            dictModel[var.name] = (coefficients[j], \ 
     234                                   stdError[j],\ 
     235                                   tScores[j],\ 
     236                                   pVals[j]) 
    305237         
    306         return LinearRegression(self) 
     238        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, 
     241                 r2=r2, r2adj=r2adj, sst=sst, sse=sse, ssr=ssr, 
     242                 std_coefficients=stdCoefficients, intercept=self.intercept) 
    307243 
    308244 
     
    312248    based on the values of independent variables. 
    313249 
    314     .. attribute:: model 
     250    .. attribute:: F 
    315251     
    316         fitted linear regression model    
     252        F-statistics of the model. 
     253 
     254    .. attribute:: coefficients 
     255 
     256        list of regression coefficients. If the intercept is included 
     257        the first item corresponds to the estimated intercept 
     258 
     259    .. attribute:: std_error 
     260 
     261        list of standard errors of the coefficient estimator.     
     262 
     263    .. attribute:: t_scores 
     264 
     265        list of t-scores for the estimated regression coefficients     
     266 
     267    .. attribute:: p_vals 
     268 
     269        list of p-values for the null hypothesis that the regression 
     270        coefficients equal 0 based on t-scores and two sided 
     271        alternative hypothesis     
     272 
     273    .. attribute:: dict_model 
     274 
     275        dictionary of statistical properties of the model. 
     276        Keys - names of the independent variables (or "Intercept") 
     277        Values - tuples (coefficient, standard error, 
     278        t-value, p-value) 
     279 
     280    .. attribute:: fitted 
     281 
     282        estimated values of the dependent variable for all instances 
     283        from the training table 
     284 
     285    .. attribute:: residuals 
     286 
     287        differences between estimated and actual values of the 
     288        dependent variable for all instances from the training table 
     289 
     290    .. attribute:: m 
     291 
     292        number of independent variables     
     293 
     294    .. attribute:: n 
     295 
     296        number of instances     
     297 
     298    .. attribute:: mu_y 
     299 
     300        the sample mean of the dependent variable     
     301 
     302    .. attribute:: r2 
     303 
     304        _`coefficient of determination`: 
     305        http://en.wikipedia.org/wiki/Coefficient_of_determination 
     306 
     307    .. attribute:: r2adj 
     308 
     309        adjusted coefficient of determination 
     310 
     311    .. attribute:: sst, sse, ssr 
     312 
     313        total sum of squares, explained sum of squares and 
     314        residual sum of squares respectively 
     315 
     316    .. attribute:: std_coefficients 
     317 
     318        standardized regression coefficients 
    317319 
    318320    """    
     
    320322 
    321323     
    322     def __init__(self, model): 
     324    def __init__(self, class_var=None, domain=None, coefficients=None, F=None, 
     325                 std_error=None, t_scores=None, p_vals=None, dict_model=None, 
     326                 fitted=None, residuals=None, m = None, n=None, mu_y=None, 
     327                 r2=None, r2adj=None, sst=None, sse=None, ssr=None, 
     328                 std_coefficients=None, intercept=None): 
    323329        """ 
    324330        :param model: fitted linear regression model 
    325331        :type model: :class:`LinearRegressionLearner` 
    326332        """ 
    327         self.model = model 
     333        self.class_var = class_var 
     334        self.domain = domain 
     335        self.coefficients = coefficients 
     336        self.F = F 
     337        self.std_error = std_error 
     338        self.t_scores = t_scores 
     339        self.p_vals = p_vals 
     340        self.dict_model = dict_model 
     341        self.fitted = fitted 
     342        self.residuals = residuals 
     343        self.m = m 
     344        self.n = n 
     345        self.mu_y = mu_y 
     346        self.r2 = r2 
     347        self.r2adj = r2adj 
     348        self.sst = sst 
     349        self.sse = sse 
     350        self.ssr = ssr 
     351        self.std_coefficients = std_coefficients 
     352        self.intercept = intercept 
    328353 
    329354    def __call__(self, instance, \ 
     
    334359        :type instance:  
    335360        """         
    336         ins = Orange.data.Instance(self.model.domain, instance) 
     361        ins = Orange.data.Instance(self.domain, instance) 
    337362        ins = numpy.array(ins.native()) 
    338363        if "?" in ins: # missing value -> corresponding coefficient omitted 
     
    340365            ins = map(miss_2_0, ins) 
    341366 
    342         if self.model.intercept: 
    343             if len(self.model.coefficients) > 1: 
    344                 yHat = self.model.coefficients[0] + \ 
    345                        dot(self.model.coefficients[1:], ins[:-1]) 
     367        if self.intercept: 
     368            if len(self.coefficients) > 1: 
     369                yHat = self.coefficients[0] + \ 
     370                       dot(self.coefficients[1:], ins[:-1]) 
    346371            else: 
    347372                if len(ins) == 1: 
    348373                    print ins 
    349                     yHat = self.model.muY 
     374                    yHat = self.mu_y 
    350375                else: 
    351                     yHat = dot(self.model.coefficients, ins[:-1]) 
     376                    yHat = dot(self.coefficients, ins[:-1]) 
    352377        else: 
    353             yHat = dot(self.model.coefficients, ins[:-1]) 
    354         yHat = Orange.data.Value(yHat) 
    355           
     378            yHat = dot(self.coefficients, ins[:-1]) 
     379#        yHat = Orange.data.Value(yHat) 
     380        yHat = self.class_var(yHat) 
     381        dist = Orange.statistics.distribution.Continuous(self.class_var) 
     382        dist[yHat] = 1.0 
    356383        if resultType == Orange.classification.Classifier.GetValue: 
    357384            return yHat 
    358385        if resultType == Orange.classification.Classifier.GetProbabilities: 
    359             return Orange.statistics.distribution.Continuous({1.0: yHat}) 
    360         return (yHat, Orange.statistics.distribution.Continuous({1.0: yHat})) 
     386            return dist 
     387        return (yHat, dist) 
    361388 
    362389 
     
    371398    """ 
    372399    from string import join 
    373     m = lr.model     
     400    m = lr    
    374401    labels = ('Variable', 'Coeff Est', 'Std Error', 't-value', 'p') 
    375402    print join(['%10s' % l for l in labels], ' ') 
    376403 
    377404    fmt = "%10s " + join(["%10.3f"]*4, " ") + " %5s" 
    378  
     405    if not lr.p_vals: 
     406        raise ValueError("Model does not contain model statistics.") 
    379407    def get_star(p): 
    380408        if p < 0.001: return  "*"*3 
     
    385413     
    386414    if m.intercept == True: 
    387         stars =  get_star(m.pVals[0]) 
     415        stars =  get_star(m.p_vals[0]) 
    388416        print fmt % ('Intercept', m.coefficients[0], \ 
    389                      m.stdError[0], m.tScores[0], m.pVals[0], stars) 
     417                     m.std_error[0], m.t_scores[0], m.p_vals[0], stars) 
    390418        for i in range(len(m.domain.attributes)): 
    391             stars = get_star(m.pVals[i+1]) 
     419            stars = get_star(m.p_vals[i+1]) 
    392420            print fmt % (m.domain.attributes[i].name,\ 
    393                          m.coefficients[i+1], m.stdError[i+1],\ 
    394                          m.tScores[i+1], m.pVals[i+1], stars) 
     421                         m.coefficients[i+1], m.std_error[i+1],\ 
     422                         m.t_scores[i+1], m.p_vals[i+1], stars) 
    395423    else: 
    396424        for i in range(len(m.domain.attributes)): 
    397             stars = get_star(m.pVals[i]) 
     425            stars = get_star(m.p_vals[i]) 
    398426            print fmt % (m.domain.attributes[i].name,\ 
    399                          m.coefficients[i], m.stdError[i],\ 
    400                          m.tScores[i], m.pVals[i], stars) 
     427                         m.coefficients[i], m.std_error[i],\ 
     428                         m.t_scores[i], m.p_vals[i], stars) 
    401429    print "Signif. codes:  0 *** 0.001 ** 0.01 * 0.05 . 0.1 empty 1" 
    402430 
Note: See TracChangeset for help on using the changeset viewer.