Changeset 3698:875ef5cb5ded in orange


Ignore:
Timestamp:
05/27/07 18:50:53 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
e601224f63c321cacfa095efcceed8917092eea7
Message:

* empty log message *

Location:
orange
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • orange/orngLinProj.py

    r3651 r3698  
    1515LAW_KNN = 3 
    1616LAW_LINEAR_PLUS = 4 
     17 
     18DR_PCA = 0 
     19DR_SPCA = 1 
     20DR_PLS = 2 
     21 
     22def normalize(x): 
     23    return x / numpy.linalg.norm(x) 
     24 
     25def center(matrix): 
     26    '''centers all variables, i.e. subtracts averages in colomns 
     27    and divides them by their standard deviations''' 
     28    n,m = numpy.shape(matrix)    
     29    return (matrix - numpy.multiply(matrix.mean(axis = 0), numpy.ones((n,m))))/numpy.std(matrix, axis = 0) 
     30 
    1731 
    1832class FreeViz: 
     
    338352##            self.energyLabel.repaint() 
    339353 
    340     def findSPCAProjection(self, attrIndices = None, setGraphAnchors = 1, percentDataUsed = 100, SPCA = 1): 
    341         try: 
    342             ai = self.graph.attributeNameIndex 
    343             if not attrIndices: 
    344                 attributes = self.getShownAttributeList() 
    345                 attrIndices = [ai[label] for label in attributes] 
    346  
    347             validData = self.graph.getValidList(attrIndices) 
    348             self.graph.normalizeExamples = 0 
    349  
    350             selectedData = numpy.compress(validData, numpy.take(self.graph.noJitteringScaledData, attrIndices, axis = 0), axis = 1) 
    351             classData = numpy.compress(validData, self.graph.noJitteringScaledData[ai[self.graph.rawdata.domain.classVar.name]]) 
    352  
    353             if percentDataUsed != 100: 
    354                 indices = orange.MakeRandomIndices2(self.graph.rawdata, 1.0-(float(percentDataUsed)/100.0)) 
    355                 selectedData = numpy.compress(indices, selectedData, axis = 1) 
    356                 classData = numpy.compress(indices, classData) 
    357  
    358             selectedData = numpy.transpose(selectedData) 
    359  
    360             s = numpy.sum(selectedData, axis=0)/float(len(selectedData)) 
    361             selectedData -= s       # substract average value to get zero mean 
    362  
    363             # define the Laplacian matrix 
    364             L = numpy.zeros((len(selectedData), len(selectedData))) 
    365             for i in range(len(selectedData)): 
    366                 for j in range(i+1, len(selectedData)): 
    367                     L[i,j] = -int(classData[i] != classData[j]) 
    368                     L[j,i] = -int(classData[i] != classData[j]) 
    369  
    370             s = numpy.sum(L, axis=0)      # doesn't matter which axis since the matrix L is symmetrical 
    371             for i in range(len(selectedData)): 
    372                 L[i,i] = -s[i] 
    373  
    374             if self.useGeneralizedEigenvectors: 
    375                 covarMatrix = numpy.dot(numpy.transpose(selectedData), selectedData) 
    376                 matrix = inv(covarMatrix) 
    377                 matrix = numpy.dot(matrix, numpy.transpose(selectedData)) 
    378             else: 
    379                 matrix = numpy.transpose(selectedData) 
    380  
    381             # compute selectedDataT * L * selectedData 
    382             if SPCA: 
    383                 matrix = numpy.dot(matrix, L) 
    384  
    385             matrix = numpy.dot(matrix, selectedData) 
    386  
    387             vals, vectors = eig(matrix) 
    388             firstInd  = list(vals).index(max(vals))     # save the index of the largest eigenvector 
    389             vals[firstInd] = -1 
    390             secondInd = list(vals).index(max(vals));    # save the index of the second largest eigenvector 
    391  
    392             xAnchors = vectors[:, firstInd] 
    393             yAnchors = vectors[:, secondInd] 
    394  
    395             lengthArr = xAnchors**2 + yAnchors**2 
    396             m = math.sqrt(max(lengthArr)) 
    397             xAnchors /= m 
    398             yAnchors /= m 
    399             names = self.graph.attributeNames 
    400             attributes = [names[attrIndices[i]] for i in range(len(attrIndices))] 
    401  
    402             if setGraphAnchors: 
    403                 self.graph.setAnchors(list(xAnchors), list(yAnchors), attributes) 
    404             return list(xAnchors), list(yAnchors), (attributes, attrIndices) 
    405         except: 
    406             #print "unable to compute the inverse of a singular matrix." 
    407 ##            import sys 
    408 ##            type, val, traceback = sys.exc_info() 
    409 ##            sys.excepthook(type, val, traceback) 
    410  
    411             names = self.graph.attributeNames 
    412             attributes = [names[attrIndices[i]] for i in range(len(attrIndices))] 
    413             anchors = self.graph.createAnchors(len(attributes), attributes) 
    414             if setGraphAnchors: self.graph.anchorData = self.graph.createAnchors(len(attributes), attributes) 
    415             return [anchors[i][0] for i in range(len(attributes))], [anchors[i][1] for i in range(len(attributes))], (attributes, attrIndices) 
    416  
     354     
    417355    # ############################################################### 
    418356    # S2N HEURISTIC FUNCTIONS 
     
    543481        return 1 
    544482 
    545  
     483    # find interesting linear projection using PCA, SPCA, or PLS 
     484    def findProjection(self, method, attrIndices = None, setAnchors = 0, percentDataUsed = 100): 
     485        ai = self.graph.attributeNameIndex 
     486        if attrIndices == None: 
     487            attributes = self.getShownAttributeList() 
     488            attrIndices = [ai[label] for label in attributes] 
     489 
     490        validData = self.graph.getValidList(attrIndices) 
     491        dataMatrix = numpy.compress(validData, numpy.take(self.graph.noJitteringScaledData, attrIndices, axis = 0), axis = 1) 
     492        hasClass = self.graph.rawdata.domain.classVar != None 
     493        if hasClass: 
     494            classArray = numpy.compress(validData, self.graph.noJitteringScaledData[ai[self.graph.rawdata.domain.classVar.name]]) 
     495 
     496        if percentDataUsed != 100: 
     497            indices = orange.MakeRandomIndices2(self.graph.rawdata, 1.0-(float(percentDataUsed)/100.0)) 
     498            dataMatrix = numpy.compress(indices, dataMatrix, axis = 1) 
     499            if hasClass: 
     500                classArray = numpy.compress(indices, classArray) 
     501             
     502        #if sum(validData) <= len(attrIndices): 
     503        #    self.setStatusBarText("More attributes than examples. Singular matrix. Exiting...") 
     504        #    return 
     505 
     506        vectors = None 
     507        if method == DR_PCA: 
     508            vectors = FreeViz.findSPCAProjection(self, dataMatrix, classArray, SPCA = 0) 
     509        elif method == DR_SPCA and hasClass: 
     510            vectors = FreeViz.findSPCAProjection(self, dataMatrix, classArray, SPCA = 1) 
     511        elif method == DR_PLS and hasClass: 
     512            dataMatrix = dataMatrix.transpose() 
     513            classMatrix = numpy.transpose(numpy.matrix(classArray)) 
     514            vectors = FreeViz.findPLSProjection(self, dataMatrix, classMatrix, 2) 
     515            vectors = vectors.T 
     516 
     517        if vectors == None: 
     518            return None 
     519 
     520        xAnchors = vectors[0] 
     521        yAnchors = vectors[1] 
     522 
     523        m = math.sqrt(max(xAnchors**2 + yAnchors**2)) 
     524        xAnchors /= m 
     525        yAnchors /= m 
     526        names = self.graph.attributeNames 
     527        attributes = [names[attrIndices[i]] for i in range(len(attrIndices))] 
     528 
     529        if setAnchors: 
     530            self.graph.setAnchors(list(xAnchors), list(yAnchors), attributes) 
     531            self.graph.updateData() 
     532            self.graph.repaint() 
     533        return xAnchors, yAnchors, (attributes, attrIndices) 
     534 
     535 
     536 
     537    def findPLSProjection(self, X,Y,Ncomp): 
     538        '''Predict Y from X using first Ncomp principal components''' 
     539 
     540        # data dimensions 
     541        n, mx = numpy.shape(X) 
     542        my = numpy.shape(Y)[1] 
     543 
     544        # Z-scores of original matrices 
     545        YMean = Y.mean() 
     546        X,Y = center(X), center(Y) 
     547 
     548        P = numpy.empty((mx,Ncomp)) 
     549        W = numpy.empty((mx,Ncomp)) 
     550        C = numpy.empty((my,Ncomp)) 
     551        T = numpy.empty((n,Ncomp)) 
     552        U = numpy.empty((n,Ncomp)) 
     553        B = numpy.zeros((Ncomp,Ncomp)) 
     554 
     555        E,F = X,Y 
     556         
     557        # main algorithm 
     558        for i in range(Ncomp): 
     559 
     560            u = numpy.random.random_sample((n,1)) 
     561            w = normalize(numpy.dot(E.T,u)) 
     562            t = normalize(numpy.dot(E,w)) 
     563 
     564            dif = t     
     565            # iterations for loading vector t 
     566            while numpy.linalg.norm(dif) > 10e-16: 
     567                c = normalize(numpy.dot(F.T,t)) 
     568                u = numpy.dot(F,c) 
     569                w = normalize(numpy.dot(E.T,u)) 
     570                t0 = normalize(numpy.dot(E,w)) 
     571                dif = t - t0 
     572                t = t0 
     573 
     574            T[:,i] = t.T 
     575            U[:,i] = u.T 
     576            C[:,i] = c.T 
     577            W[:,i] = w.T 
     578         
     579            b = numpy.dot(t.T,u)[0,0] 
     580            B[i][i] = b 
     581            p = numpy.dot(E.T,t) 
     582            P[:,i] = p.T 
     583            E = E - numpy.dot(t,p.T) 
     584            xx = b * numpy.dot(t,c.T) 
     585            F = F - xx 
     586 
     587        # esimated Y 
     588        #YE = numpy.dot(numpy.dot(T,B),C.T)*numpy.std(Y, axis = 0) + YMean 
     589        #Y = Y*numpy.std(Y, axis = 0)+ YMean 
     590        #BPls = numpy.dot(numpy.dot(numpy.linalg.pinv(P.T),B),C.T) 
     591                    
     592        return W 
     593 
     594    def findSPCAProjection(self, dataMatrix, classArray, SPCA = 1): 
     595        try: 
     596            dataMatrix = numpy.transpose(dataMatrix) 
     597 
     598            s = numpy.sum(dataMatrix, axis=0)/float(len(dataMatrix)) 
     599            dataMatrix -= s       # substract average value to get zero mean 
     600 
     601            # define the Laplacian matrix 
     602            L = numpy.zeros((len(dataMatrix), len(dataMatrix))) 
     603            for i in range(len(dataMatrix)): 
     604                for j in range(i+1, len(dataMatrix)): 
     605                    L[i,j] = -int(classArray[i] != classArray[j]) 
     606                    L[j,i] = -int(classArray[i] != classArray[j]) 
     607 
     608            s = numpy.sum(L, axis=0)      # doesn't matter which axis since the matrix L is symmetrical 
     609            for i in range(len(dataMatrix)): 
     610                L[i,i] = -s[i] 
     611 
     612            if self.useGeneralizedEigenvectors: 
     613                covarMatrix = numpy.dot(numpy.transpose(dataMatrix), dataMatrix) 
     614                matrix = inv(covarMatrix) 
     615                matrix = numpy.dot(matrix, numpy.transpose(dataMatrix)) 
     616            else: 
     617                matrix = numpy.transpose(dataMatrix) 
     618 
     619            # compute dataMatrixT * L * dataMatrix 
     620            if SPCA: 
     621                matrix = numpy.dot(matrix, L) 
     622 
     623            matrix = numpy.dot(matrix, dataMatrix) 
     624 
     625            vals, vectors = eig(matrix) 
     626            firstInd  = list(vals).index(max(vals))     # save the index of the largest eigenvector 
     627            vals[firstInd] = -1 
     628            secondInd = list(vals).index(max(vals));    # save the index of the second largest eigenvector 
     629 
     630            vectors = vectors.transpose() 
     631            return numpy.take(vectors, [firstInd, secondInd], axis = 0) 
     632        except: 
     633            return None 
    546634 
    547635 
  • orange/orngScaleData.py

    r3537 r3698  
    240240                Max = domainSubDataStat[index].max 
    241241                self.attrSubValues[attr.name] = (Min, Max) 
    242                 if self.scalingByVariance or self.globalValueScaling: 
    243                     continue 
    244                 normalizer = self.normalizers[index] or 1 
    245                 projMin = (Min - self.offsets[index]) / normalizer 
    246                 projMax = (Max - self.offsets[index]) / normalizer 
    247                 if projMin < 0.0 or projMax > 1.0: 
    248                     self.subDataMinMaxDict[attr.name] = (min(projMin, 0.0), max(1.0, projMax)) 
     242                #if self.scalingByVariance or self.globalValueScaling: 
     243                #    continue 
     244                #normalizer = self.normalizers[index] or 1 
     245                #projMin = (Min - self.offsets[index]) / normalizer 
     246                #projMax = (Max - self.offsets[index]) / normalizer 
     247                #if projMin < 0.0 or projMax > 1.0: 
     248                #    self.subDataMinMaxDict[attr.name] = (min(projMin, 0.0), max(1.0, projMax)) 
    249249            elif subData.domain[index].varType == orange.VarTypes.Discrete: 
    250250                self.attrSubValues[attr.name] = [0, len(attr.values)] 
  • orange/orngScaleLinProjData.py

    r3537 r3698  
    7171            m = min(values); M = max(values) 
    7272            if m < 0.0 or M > 1.0:  # we have to do rescaling of values so that all the values will be in the 0-1 interval 
     73                #print "example values are not in the 0-1 interval" 
    7374                values = [max(0.0, min(val, 1.0)) for val in values] 
    7475                #m = min(m, 0.0); M = max(M, 1.0); diff = max(M-m, 1e-10) 
     
    146147                    continue 
    147148                m, M = self.subDataMinMaxDict[self.rawdata.domain[attrIndices[i]].name] 
    148                 selectedData[i] = (selectedData[i] - m) / float(M-m) 
     149                selectedData[i] = (selectedData[i] - m) / float(max(M-m, 1e-10)) 
    149150 
    150151        if useAnchorData and self.anchorData: 
Note: See TracChangeset for help on using the changeset viewer.