Changeset 8756:839916280472 in orange


Ignore:
Timestamp:
08/24/11 13:01:26 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
1b92d7e1feb4c8738f4f85c78a5d752f898d9afc
Message:

Enabled vizrank for sphereviz and linproj3d

Location:
orange
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/preprocess/scaling.py

    r8735 r8756  
    854854 
    855855    @deprecated_keywords({"numOfAttr": "num_of_attr"}) 
    856     def create_anchors(self, num_of_attr, labels=None): 
     856    def create_anchors(self, num_of_attrs, labels=None): 
    857857        """ 
    858858        Create anchors on the sphere. 
     
    861861        # Golden Section Spiral algorithm approximates even distribution of points on a sphere 
    862862        # (read more here http://www.softimageblog.com/archives/115) 
    863         n = num_of_attr 
     863        n = num_of_attrs 
    864864        xanchors = [] 
    865865        yanchors = [] 
     
    875875            yanchors.append(y) 
    876876            zanchors.append(math.sin(phi)*r) 
    877         r = numpy.ones(len(xanchors), numpy.float) 
    878  
     877 
     878        self.anchor_dict[num_of_attrs] = [xanchors, yanchors, zanchors] 
     879  
    879880        if labels: 
    880             return [(xanchors[i], yanchors[i], zanchors[i], labels[i]) for i in range(num_of_attr)] 
    881         else: 
    882             return [(xanchors[i], yanchors[i], zanchors[i]) for i in range(num_of_attr)] 
     881            return [(xanchors[i], yanchors[i], zanchors[i], labels[i]) for i in range(num_of_attrs)] 
     882        else: 
     883            return [(xanchors[i], yanchors[i], zanchors[i]) for i in range(num_of_attrs)] 
    883884 
    884885    createAnchors = create_anchors 
     886 
     887    @deprecated_keywords({"numOfAttrs": "num_of_attrs"}) 
     888    def create_xanchors(self, num_of_attrs): 
     889        if not self.anchor_dict.has_key(num_of_attrs): 
     890            self.create_anchors(num_of_attrs) 
     891        return self.anchor_dict[num_of_attrs][0] 
     892 
     893    createXAnchors = create_xanchors 
     894 
     895    @deprecated_keywords({"numOfAttrs": "num_of_attrs"}) 
     896    def create_yanchors(self, num_of_attrs): 
     897        if not self.anchor_dict.has_key(num_of_attrs): 
     898            self.create_anchors(num_of_attrs) 
     899        return self.anchor_dict[num_of_attrs][1] 
     900 
     901    createYAnchors = create_yanchors 
     902 
     903    @deprecated_keywords({"numOfAttrs": "num_of_attrs"}) 
     904    def create_zanchors(self, num_of_attrs): 
     905        if not self.anchor_dict.has_key(num_of_attrs): 
     906            self.create_anchors(num_of_attrs) 
     907        return self.anchor_dict[num_of_attrs][2] 
     908 
     909    createZAnchors = create_zanchors 
    885910 
    886911    @deprecated_keywords({"fileName": "filename", "attrList": "attrlist", 
  • orange/OrangeWidgets/Visualize Qt/OWLinProj3DPlot.py

    r8754 r8756  
    300300 
    301301    def replot(self): 
     302        pass 
     303 
     304    def saveToFile(self): 
    302305        pass 
    303306 
  • orange/OrangeWidgets/Visualize Qt/OWLinProjQt.py

    r8752 r8756  
    9999            self.vizrank = OWVizRank(self, self.signalManager, self.graph, orngVizRank.POLYVIZ, name) 
    100100            self.connect(self.graphButton, SIGNAL("clicked()"), self.graph.saveToFile) 
     101        elif "sphereviz" in name_lower: 
     102            self.vizrank = OWVizRank(self, self.signalManager, self.graph, orngVizRank.SPHEREVIZ3D, name) 
     103            self.connect(self.graphButton, SIGNAL("clicked()"), self.graph.saveToFile) 
     104        elif "3d" in name_lower: 
     105            self.vizrank = OWVizRank(self, self.signalManager, self.graph, orngVizRank.LINEAR_PROJECTION3D, name) 
     106            self.connect(self.graphButton, SIGNAL("clicked()"), self.graph.saveToFile) 
    101107        else: 
    102108            self.vizrank = OWVizRank(self, self.signalManager, self.graph, orngVizRank.LINEAR_PROJECTION, name) 
  • orange/orngVizRank.py

    r8735 r8756  
    8787POLYVIZ = 4 
    8888SCATTERPLOT3D = 5 
     89SPHEREVIZ3D = 6 
     90LINEAR_PROJECTION3D = 7 
    8991KNN_IN_ORIGINAL_SPACE = 10 
    9092 
     
    892894 
    893895                    permutations = self.getNextPermutations() 
     896 
     897        elif self.visualizationMethod in (SPHEREVIZ3D, LINEAR_PROJECTION3D): 
     898            if self.projOptimizationMethod != 0: 
     899                self.freeviz.useGeneralizedEigenvectors = 1 
     900                self.graph.normalize_examples = 0 
     901 
     902            # variables and domain for the table 
     903            domain = orange.Domain([orange.FloatVariable("xVar"), 
     904                                    orange.FloatVariable("yVar"), 
     905                                    orange.FloatVariable("zVar"), 
     906                                    orange.EnumVariable(self.graph.data_domain.classVar.name, values = getVariableValuesSorted(self.graph.data_domain.classVar))]) 
     907            minLength = (self.optimizationType == EXACT_NUMBER_OF_ATTRS and self.attributeCount) or 3 
     908            maxLength = self.attributeCount 
     909            classListFull = self.graph.original_data[self.graph.data_class_index] 
     910 
     911            # each call to selectNextAttributeSubset gets a new combination of attributes in a range from minLength to maxLength. if we return None for a given number of attributes this 
     912            # doesn't mean yet that there are no more possible combinations. it may be just that we wanted a combination of 6 attributes in a domain with 4 attributes. therefore we have 
     913            # to try maxLength-minLength+1 times and if we fail every time then there are no more valid projections 
     914 
     915            newProjectionsExist = 1 
     916            while newProjectionsExist: 
     917                for experiment in range(maxLength-minLength+1): 
     918                    if self.selectNextAttributeSubset(minLength, maxLength): break 
     919                    newProjectionsExist = 0 
     920                permutations = self.getNextPermutations() 
     921                while permutations: 
     922                    attrIndices = permutations[0] 
     923 
     924                    # if we use SPCA, PLS 
     925                    if self.projOptimizationMethod != 0: 
     926                        projections = self.freeviz.findProjection(self.projOptimizationMethod, attrIndices, set_anchors = 0, percentDataUsed = self.percentDataUsed) 
     927                        if projections != None: 
     928                            xanchors, yanchors, zanchors, (attrNames, newIndices) = projections 
     929                            table = self.graph.create_projection_as_example_table(newIndices, 
     930                                                                                  domain = domain, 
     931                                                                                  XAnchors = xanchors, 
     932                                                                                  YAnchors = yanchors, 
     933                                                                                  ZAnchors = zanchors) 
     934                        if len(table) < self.minNumOfExamples: continue 
     935                        self.evaluatedProjectionsCount += 1 
     936                        accuracy, other_results = self.evaluateProjection(table) 
     937                        generalDict = {"XAnchors": list(xanchors), 
     938                                       "YAnchors": list(yanchors), 
     939                                       "ZAnchors": list(zanchors), 
     940                                       "Results": self.evaluationResults} if self.saveEvaluationResults else {"XAnchors": list(xanchors), 
     941                                                                                                              "YAnchors": list(yanchors), 
     942                                                                                                              "ZAnchors": list(zanchors)} 
     943                        self.addResult(accuracy, other_results, len(table), attrNames, self.evaluatedProjectionsCount, generalDict = generalDict) 
     944                        if self.isEvaluationCanceled(): return self.evaluatedProjectionsCount 
     945                        if self.__class__ != VizRank: 
     946                            self.setStatusBarText("Evaluated %s projections..." % (orngVisFuncts.createStringFromNumber(self.evaluatedProjectionsCount))) 
     947                    else: 
     948                        XAnchors = self.graph.create_xanchors(len(attrIndices)) 
     949                        YAnchors = self.graph.create_yanchors(len(attrIndices)) 
     950                        ZAnchors = self.graph.create_zanchors(len(attrIndices)) 
     951                        validData = self.graph.get_valid_list(attrIndices) 
     952                        if numpy.sum(validData) >= self.minNumOfExamples: 
     953                            classList = numpy.compress(validData, classListFull) 
     954                            selectedData = numpy.compress(validData, numpy.take(self.graph.no_jittering_scaled_data, attrIndices, axis = 0), axis = 1) 
     955                            sum_i = self.graph._getSum_i(selectedData) 
     956 
     957                            tempList = [] 
     958 
     959                            # for every permutation compute how good it separates different classes 
     960                            for permutation in permutations: 
     961                                if self.evaluatedProjectionsCount % 10 == 0 and self.isEvaluationCanceled(): 
     962                                    continue 
     963 
     964                                table = self.graph.create_projection_as_example_table(permutation, 
     965                                                                                      validData = validData, 
     966                                                                                      classList = classList, 
     967                                                                                      sum_i = sum_i, 
     968                                                                                      XAnchors = XAnchors, 
     969                                                                                      YAnchors = YAnchors, 
     970                                                                                      ZAnchors = ZAnchors, 
     971                                                                                      domain = domain) 
     972                                accuracy, other_results = self.evaluateProjection(table) 
     973 
     974                                # save the permutation 
     975                                if self.storeEachPermutation: 
     976                                    generalDict = {"Results": self.evaluationResults} if self.saveEvaluationResults else {} 
     977                                    self.addResult(accuracy, other_results, len(table), [self.graph.attribute_names[i] for i in permutation], self.evaluatedProjectionsCount, generalDict) 
     978                                else: 
     979                                    tempList.append((accuracy, other_results, len(table), [self.graph.attribute_names[i] for i in permutation])) 
     980 
     981                                self.evaluatedProjectionsCount += 1 
     982                                if self.__class__ != VizRank: 
     983                                    self.setStatusBarText("Evaluated %s projections..." % (orngVisFuncts.createStringFromNumber(self.evaluatedProjectionsCount))) 
     984                                    qApp.processEvents()        # allow processing of other events 
     985 
     986                            if not self.storeEachPermutation and len(tempList) > 0:   # return only the best attribute placements 
     987                                (acc, other_results, lenTable, attrList) = maxFunct(tempList) 
     988                                generalDict = {"Results": self.evaluationResults} if self.saveEvaluationResults else {} 
     989                                self.addResult(acc, other_results, lenTable, attrList, self.evaluatedProjectionsCount, generalDict=generalDict) 
     990 
     991                        if self.isEvaluationCanceled(): 
     992                            return self.evaluatedProjectionsCount 
     993 
     994                    permutations = self.getNextPermutations() 
     995 
    894996        elif self.visualizationMethod == SCATTERPLOT3D: 
    895997            evaluatedAttributes = self.getEvaluatedAttributes() 
     
    9941096                    for testProj in testProjections: 
    9951097                        table = self.graph.create_projection_as_example_table(testProj, domain = domain) 
     1098                        if len(table) < self.minNumOfExamples: continue 
     1099                        acc, other_results = self.evaluateProjection(table) 
     1100                        if hasattr(self, "setStatusBarText") and self.optimizedProjectionsCount % 10 == 0: 
     1101                            self.setStatusBarText("Evaluated %s projections. Last accuracy was: %2.2f%%" % (orngVisFuncts.createStringFromNumber(self.optimizedProjectionsCount), acc)) 
     1102                        if acc > accuracy: 
     1103                            self.addResult(acc, other_results, len(table), [self.graph.attribute_names[i] for i in testProj], projIndex) 
     1104                            self.insertTempProjection(projections, acc, testProj) 
     1105                            tempDict[tuple(testProj)] = 1 
     1106                            if min(acc, accuracy) != 0 and max(acc, accuracy) > 1.005 *min(acc, accuracy):  significantImprovement = 1 
     1107 
     1108                        self.optimizedProjectionsCount += 1 
     1109                        if self.__class__ != VizRank: 
     1110                            qApp.processEvents()        # allow processing of other events 
     1111                        if self.optimizedProjectionsCount % 10 == 0 and self.isOptimizationCanceled(): 
     1112                            return self.optimizedProjectionsCount 
     1113                    if significantImprovement: break 
     1114 
     1115        elif self.visualizationMethod == SCATTERPLOT3D: 
     1116            classListFull = self.graph.original_data[self.graph.data_class_index] 
     1117 
     1118            tempDict = {} 
     1119            projIndex = 0 
     1120            while len(projections) > 0: 
     1121                (accuracy, projection) = projections.pop(0) 
     1122                projIndex -= 1 
     1123 
     1124                significantImprovement = 0 
     1125                strTotalAtts = orngVisFuncts.createStringFromNumber(lenOfAttributes) 
     1126                for (attrIndex, attr) in enumerate(attributes): 
     1127                    if attr in projection: continue 
     1128                    testProjections = [] 
     1129                    if not tempDict.has_key((projection[0], attr)) and not tempDict.has_key((attr, projection[0])): testProjections.append([projection[0], attr]) 
     1130                    if not tempDict.has_key((projection[1], attr)) and not tempDict.has_key((attr, projection[1])): testProjections.append([attr, projection[1]]) 
     1131 
     1132                    for testProj in testProjections: 
     1133                        table = self.graph.create_projection_as_example_table_3D(testProj, domain = domain) 
    9961134                        if len(table) < self.minNumOfExamples: continue 
    9971135                        acc, other_results = self.evaluateProjection(table) 
Note: See TracChangeset for help on using the changeset viewer.