Changeset 3679:4118e2c121bf in orange


Ignore:
Timestamp:
05/21/07 16:45:54 (7 years ago)
Author:
blaz <blaz.zupan@…>
Branch:
default
Convert:
4b95d891290e4139593afc8375d371e50bd7398a
Message:

some coding corrections

File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/orngRegression.py

    r3675 r3679  
    66from string import join 
    77 
     8######################################################################## 
     9# Linear Regression 
     10 
     11class LinearRegressionLearner(object): 
     12    def __new__(self, data=None, name='linear regression', **kwds): 
     13        learner = object.__new__(self, **kwds) 
     14        if data: 
     15            learner.__init__(name) # force init 
     16            return learner(data) 
     17        else: 
     18            return learner  # invokes the __init__ 
     19 
     20    def __init__(self, name='linear regression', beta0 = True): 
     21        self.name = name 
     22        self.beta0 = beta0 
     23 
     24    def __call__(self, data, weight=None): 
     25        # missing values handling (impute missing) 
     26        imputer = orange.ImputerConstructor_model() 
     27        imputer.learnerContinuous = orange.MajorityLearner() 
     28        imputer.learnerDiscrete = orange.BayesLearner() 
     29        imputer = imputer(data) 
     30        data = imputer(data) 
     31  
     32        # continuization (replaces discrete with continuous attributes) 
     33        continuizer = orange.DomainContinuizer() 
     34        continuizer.multinomialTreatment = continuizer.FrequentIsBase 
     35        continuizer.zeroBased = True 
     36        domain0 = continuizer(data) 
     37        data = data.translate(domain0) 
     38  
     39        #   convertion to numpy 
     40        A, y, w = data.toNumpy()        # weights ?? 
     41        n, m = numpy.shape(A) 
     42      
     43        if self.beta0 == True: 
     44             X = numpy.insert(A,0,1,axis=1) # adds a column of ones 
     45        else: 
     46             X = A 
     47              
     48        beta, resid, rank, s = numpy.linalg.lstsq(X,y)  # should also check for rank 
     49         
     50        yEstimated = dot(X,beta)  # estimation 
     51  
     52        # some desriptive statistisc 
     53        muY, sigmaY = numpy.mean(y), numpy.std(y) 
     54        muX, covX = numpy.mean(A, axis = 0), numpy.cov(A, rowvar = 0) 
     55  
     56        # model statistics 
     57        SST, SSR = numpy.sum((y - muY) ** 2), numpy.sum((yEstimated - muY) ** 2) 
     58        SSE, RSquare = SST-SSR, SSR/SST 
     59        R = numpy.sqrt(RSquare) # coefficient of determination 
     60        RAdjusted = 1 - (1 - RSquare) * (n - 1) / (n - m - 1) 
     61        F = (SSR / m) / (SST - SSR / (n - m - 1)) # F statistisc 
     62        df = m - 1 
     63  
     64        sigmaSquare = SSE / (n-m-1) 
     65 
     66        # standard error of estimated coefficients 
     67        errCoeff = sqrt(sigmaSquare * inv(dot(X.T,X)).diagonal()) 
     68  
     69        # t statistisc, significance 
     70        t = beta / errCoeff 
     71        significance = [statc.betai(df*0.5,0.5,df/(df+tt*tt)) for tt in t] 
     72  
     73        #   standardized coefficients 
     74        if self.beta0 == True:    
     75             stdCoeff = (sqrt(covX.diagonal()) / sigmaY)  * beta[1:] 
     76        else: 
     77             stdCoeff = (sqrt(covX.diagonal()) / sigmaY)  * beta 
     78  
     79        model = {'descriptives': { 'meanX' : muX, 'covX' : covX, 'meanY' : muY, 'sigmaY' : sigmaY}, 
     80                 'model' : {'estCoeff' : beta, 'stdErrorEstimation': errCoeff}, 
     81                 'model summary': {'TotalVar' : SST, 'ExplVar' : SSE, 'ResVar' : SSR, 'R' : R, 'RAdjusted' : RAdjusted, 
     82                                   'F' : F, 't' : t, 'sig': significance}} 
     83  
     84        return LinearRegression(statistics = model, domain = data.domain, name = self.name, beta0 = self.beta0) 
     85 
     86class LinearRegression: 
     87    def __init__(self, **kwds): 
     88        self.__dict__ = kwds 
     89        self.beta = self.statistics['model']['estCoeff'] 
     90 
     91    def __call__(self, example): 
     92        ex = orange.Example(self.domain, example) 
     93        ex = numpy.array(ex.native()) 
     94 
     95        if self.beta0: 
     96            yhat = self.beta[0] + dot(self.beta[1:], ex[:-1]) 
     97        else: 
     98            yhat = dot(self.beta, ex[:-1]) 
     99          
     100        return yhat 
     101 
     102def printLinearRegression(lr): 
     103    """pretty-prints linear regression model""" 
     104    beta = lr.beta 
     105    err = lr.statistics['model']['stdErrorEstimation'] 
     106    t = lr.statistics['model summary']['t'] 
     107    sig = lr.statistics['model summary']['sig']  
     108    beta0 = lr.beta0 
     109     
     110    labels = ('Variable', 'Coeff Est', 'Std Error', 't-value', 'p') 
     111    print join(['%10s' % l for l in labels], ' ') 
     112 
     113    fmt = "%10s " + join(["%10.3f"]*4, " ") 
     114    if beta0 == True: 
     115        print fmt % ('Constant', beta[0], err[0], t[0], sig[0]) 
     116        for i in range(len(lr.domain.attributes)-1): 
     117            print fmt % (lr.domain.attributes[i].name, beta[i+1], err[i+1], t[i+1], sig[i+1]) 
     118    else: 
     119        for i in range(len(lr.domain.attributes)-1): 
     120            print fmt % (lr.domain.attributes[i].name, beta[i], err[i], t[i], sig[i])        
     121 
     122######################################################################## 
     123# Partial Least-Squares Regression (PLS) 
     124 
    8125# Function is used in PLSRegression 
    9126def standardize(matrix): 
     
    17134    return vector / numpy.linalg.norm(vector) 
    18135 
    19  
    20 def LinearRegression(examples=None, weightID=0, **kwds): 
    21     l=apply(LinearRegressionLearner, (), kwds) 
    22     if examples: 
    23         l=l(examples) 
    24     return l 
    25  
    26 class LinearRegressionLearner: 
    27      
    28     def __init__(self, beta0 = True): 
    29         self.beta0 = beta0 
    30      
    31     def __call__(self, data): 
    32        #   missing values 
    33        # 
    34        #   imputation 
    35        #   for dicrete atributes uses BayesLearner 
    36        #   and MajorityLearner for continuous 
    37        imputer = orange.ImputerConstructor_model() 
    38        imputer.learnerContinuous = orange.MajorityLearner() 
    39        imputer.learnerDiscrete = orange.BayesLearner() 
    40        imputer = imputer(data) 
    41        data = imputer(data) 
    42  
    43        #   binarization 
    44        continuizer = orange.DomainContinuizer() 
    45        continuizer.multinomialTreatment = continuizer.FrequentIsBase 
    46        continuizer.zeroBased = True 
    47        domain0 = continuizer(data) 
    48        self.data = data.translate(domain0) 
    49  
    50        #   convertion to numpy 
    51        A, y, w = self.data.toNumpy()        # weights ?? 
    52        n, m = numpy.shape(A) 
    53      
    54        if self.beta0 == True: 
    55             X = numpy.insert(A,0,1,axis=1) # adds a column of ones 
    56              
    57        else: 
    58             X = A 
    59              
    60        beta, resid, rank, s = numpy.linalg.lstsq(X,y)  #ne uposteva (ne)polnosti ranga--- mozna singularnost 
    61         
    62        yEstimated = dot(X,beta)  # estimation 
    63  
    64        #   some desriptive statistisc 
    65        muY, sigmaY = numpy.mean(y), numpy.std(y) 
    66        muX, covX = numpy.mean(A, axis = 0), numpy.cov(A, rowvar = 0) 
    67  
    68        #   some statistics 
    69        SST, SSR = numpy.sum((y - muY) ** 2), numpy.sum((yEstimated - muY) ** 2) 
    70        SSE, RSquare = SST-SSR, SSR/SST 
    71        R = numpy.sqrt(RSquare) # coefficient of determination 
    72        RAdjusted = 1 - (1 - RSquare) * (n - 1) / (n - m - 1) 
    73        F = (SSR / m) / (SST - SSR / (n - m - 1)) # F statistisc 
    74        df = m - 1 
    75  
    76        sigmaSquare = SSE / (n-m-1) 
    77        #   standard error of estimated coefficients 
    78        errCoeff = sqrt(sigmaSquare * inv(dot(X.T,X)).diagonal()) 
    79  
    80        #   t statistisc, significance,... 
    81        t = beta / errCoeff 
    82        Significance = [statc.betai(df*0.5,0.5,df/(df+tt*tt)) for tt in t] 
    83  
    84        #   standardized coefficients 
    85        if self.beta0 == True:    
    86             stdCoeff = (sqrt(covX.diagonal()) / sigmaY)  * beta[1:] 
    87        else: 
    88             stdCoeff = (sqrt(covX.diagonal()) / sigmaY)  * beta 
    89  
    90        statistics ={'descriptives': { 'meanX' : muX, 'covX' : covX, 'meanY' : muY, 'sigmaY' : sigmaY}, 
    91                     'model' : {'estCoeff' : beta, 'stdErrorEstimation': errCoeff}, 
    92                     'model summary': {'TotalVar' : SST, 'ExplVar' : SSE, 'ResVar' : SSR, 'R' : R, 'RAdjusted' : RAdjusted, 
    93                                       'F' : F, 't' : t, 'sig': Significance} 
    94                     } 
    95  
    96        return LinearRegressionClass(self.data, statistics, self.beta0) 
    97  
    98  
    99 class LinearRegressionClass: 
    100    def __init__(self, data, statistics, beta0): 
    101        self.data = data 
    102        self.statistics = statistics 
    103        self.beta = statistics['model']['estCoeff'] 
    104        self.beta0 = beta0 
    105  
    106    def __call__(self, example): 
    107        cexample = orange.Example(self.data.domain, example) 
    108        cexample = numpy.array(cexample.native()) 
    109        if self.beta0 == True: 
    110            value = self.beta[0] + dot(self.beta[1:],cexample[:-1]) 
    111        else: 
    112            value = dot(self.beta,cexample[:-1]) 
    113          
    114        return value 
    115  
    116    def prnt(self): 
    117        """prints some basic statistics of regression model""" 
    118        beta = self.beta 
    119        data = self.data 
    120        err = self.statistics['model']['stdErrorEstimation'] 
    121        t = self.statistics['model summary']['t'] 
    122        sig = self.statistics['model summary']['sig']  
    123        beta0 = self.beta0 
    124  
    125        labels = ('Variable', 'Coeff Est', 'Std Error', 't-value', 'p') 
    126        print join(['%10s' % l for l in labels], ' ') 
    127  
    128        fmt = "%10s " + join(["%10.3f"]*4, " ") 
    129        if beta0 == True: 
    130             print fmt % ('Constant', beta[0], err[0], t[0], sig[0]) 
    131             for i in range(len(data[0])-1): 
    132                 print fmt % (data.domain.attributes[i].name, beta[i+1], err[i+1], t[i+1], sig[i+1]) 
    133        else: 
    134             for i in range(len(data[0])-1): 
    135                 print fmt % (data.domain.attributes[i].name, beta[i], err[i], t[i], sig[i])        
    136  
    137  
    138 # 
    139 # 
    140 #       PLS Regression 
    141 # 
    142 # 
    143  
    144  
    145 def PLSRegressionLearner(data = None, Ncomp = None, listY = None, listX = None, weightID=0, **kwds): 
    146     ''' Forms PLS regression model from data (example table) 
    147         using Ncomp components. Names of independent 
    148         variables are stored in list listX and names of response 
    149         variables are stored in list listY. 
    150     ''' 
    151     l = apply(PLSRegressionLearnerClass, (), kwds) 
    152     if data: 
    153         l = l(data, Ncomp, listY, listX) 
    154     return l 
    155  
    156  
    157 class PLSRegressionLearnerClass: 
    158      
    159     def __call__(self, data, Ncomp, listY, listX = None): 
    160          
    161         if listX == None: 
    162             listX = [] 
    163             for i in data.domain.variables: 
    164                 if listY.count(i.name) == 0: 
    165                     listX.append(i) 
    166  
    167         dataX = data.select(listX) 
    168         dataY = data.select(listY) 
     136class PLSRegressionLearner(object): 
     137    """PLSRegressionLearner(data, y, x=None, nc=None)""" 
     138    def __new__(self, data=None, name='PLS regression', **kwds): 
     139        learner = object.__new__(self, **kwds) 
     140        if data: 
     141            learner.__init__(name) # force init 
     142            return learner(data) 
     143        else: 
     144            return learner  # invokes the __init__ 
     145 
     146    def __init__(self, name='PLS regression', nc = None): 
     147        self.name = name 
     148        self.nc = nc 
     149 
     150    def __call__(self, data, y, x=None, nc=None, weight=None): 
     151        if x == None: 
     152            x = [v for v in data.domain.variables if v not in y] 
     153 
     154        dataX = data.select(x) 
     155        dataY = data.select(y) 
     156        print y, dataY 
    169157         
    170158        # transformation to numpy arrays 
     
    221209        Y = Y*numpy.std(Y, axis = 0)+ YMean 
    222210        BPls = dot(dot(numpy.linalg.pinv(P.T),B),C.T)     
    223         return PLSRegression(data, BPls, YMean, YStd, XMean, XStd) 
     211        return PLSRegression(domain=data.domain, BPls=BPls, YMean=YMean, YStd=YStd, XMean=XMean, XStd=XStd, name=self.name) 
    224212 
    225213class PLSRegression: 
    226      
    227    def __init__(self, data, BPls, YMean, YStd, XMean, XStd): 
    228        self.data = data 
    229        self.BPls = BPls 
    230        self.YMean = YMean 
    231        self.YStd = YStd 
    232        self.XMean = XMean 
    233        self.XStd = XStd 
    234  
    235    def __call__(self, example): 
    236        example = numpy.array(example.native()) 
    237        example = (example - self.XMean) / self.XStd 
    238        estimator = dot(example, self.BPls) * self.YStd + self.YMean         
    239        return estimator 
    240  
    241      
    242  
    243 d = orange.ExampleTable('C://Delo//Python//Distance Learning//04-curatedF05.tab') 
    244 ind = d.domain.index('smiles')  
    245 nd = orange.Domain(d.domain[0:ind-1] + d.domain[ind+1:], 0) 
    246 data = orange.ExampleTable(nd, d) 
    247  
    248 selY = ['growthC', 'growthE', 'dev', 'sporesC'] 
    249  
    250 selX = [] 
    251 for i in data.domain.variables: 
    252     if selY.count(i.name) == 0: 
    253         selX.append(i) 
    254          
    255 dataX = data.select(selX) 
    256 dataY = data.select(selY) 
    257  
    258 model = PLSRegressionLearner(data, 3, selY, selX) 
    259          
    260 X0 = dataX.toNumpy()[0] 
    261 Y0 = dataY.toNumpy()[0] 
    262  
    263 regressor = PLSRegression(model.data, model.BPls, model.YMean, model.YStd, model.XMean, model.XStd) 
    264 est = regressor(dataX[1]) 
    265 print 'Original values:', dataY[1] 
    266 print 'Estimated values:', est  
    267 print '\n' 
    268  
    269     
    270  
    271 if __name__ == "__main__": 
    272    data = orange.ExampleTable("C://ds//housing.tab") 
    273    lr = LinearRegression(data) 
    274    lr.prnt() 
    275     
    276   
     214    def __init__(self, **kwds): 
     215        self.__dict__ = kwds 
     216 
     217    def __call__(self, example): 
     218       ex = orange.Example(self.domain, example) 
     219       ex = numpy.array(ex.native()) 
     220       ex = (ex - self.XMean) / self.XStd 
     221       yhat = dot(ex, self.BPls) * self.YStd + self.YMean         
     222       return yhat 
Note: See TracChangeset for help on using the changeset viewer.