Changeset 8539:6a5575b4de0c in orange


Ignore:
Timestamp:
07/30/11 15:36:04 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
69ca375fa506a51a0c9c6aad944b5fab66f6b7f6
Message:

Integrated VizRank, issues probably still exist

Location:
orange
Files:
4 edited

Legend:

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

    r8042 r8539  
    10891089    @deprecated_keywords({"attrIndices": "attr_indices", 
    10901090                          "settingsDict": "settings_dict"}) 
     1091    def create_projection_as_example_table_3D(self, attr_indices, **settings_dict): 
     1092        """ 
     1093        Create the projection of attribute indices given in attr_indices and 
     1094        create an example table with it. 
     1095         
     1096        """ 
     1097        if self.data_has_class: 
     1098            domain = settings_dict.get("domain") or \ 
     1099                     Orange.data.Domain([Orange.data.variable.Continuous(self.data_domain[attr_indices[0]].name), 
     1100                                         Orange.data.variable.Continuous(self.data_domain[attr_indices[1]].name), 
     1101                                         Orange.data.variable.Continuous(self.data_domain[attr_indices[2]].name), 
     1102                                         Orange.data.variable.Discrete(self.data_domain.class_var.name, 
     1103                                                                       values = get_variable_values_sorted(self.data_domain.class_var))]) 
     1104        else: 
     1105            domain = settings_dict.get("domain") or \ 
     1106                     Orange.data.Domain([Orange.data.variable.Continuous(self.data_domain[attr_indices[0]].name), 
     1107                                         Orange.data.variable.Continuous(self.data_domain[attr_indices[1]].name), 
     1108                                         Orange.data.variable.Continuous(self.data_domain[attr_indices[2]].name)]) 
     1109 
     1110        data = self.create_projection_as_numeric_array_3D(attr_indices, 
     1111                                                          **settings_dict) 
     1112        if data != None: 
     1113            return Orange.data.Table(domain, data) 
     1114        else: 
     1115            return Orange.data.Table(domain) 
     1116 
     1117    createProjectionAsExampleTable3D = create_projection_as_example_table_3D 
     1118 
     1119    @deprecated_keywords({"attrIndices": "attr_indices", 
     1120                          "settingsDict": "settings_dict"}) 
    10911121    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    10921122        validData = settings_dict.get("validData") 
     
    11151145 
    11161146    createProjectionAsNumericArray = create_projection_as_numeric_array 
     1147 
     1148    @deprecated_keywords({"attrIndices": "attr_indices", 
     1149                          "settingsDict": "settings_dict"}) 
     1150    def create_projection_as_numeric_array_3D(self, attr_indices, **settings_dict): 
     1151        validData = settings_dict.get("validData") 
     1152        classList = settings_dict.get("classList") 
     1153        jitterSize = settings_dict.get("jitter_size", 0.0) 
     1154 
     1155        if validData == None: 
     1156            validData = self.get_valid_list(attr_indices) 
     1157        if sum(validData) == 0: 
     1158            return None 
     1159 
     1160        if classList == None and self.data_has_class: 
     1161            classList = self.original_data[self.data_class_index] 
     1162 
     1163        xArray = self.no_jittering_scaled_data[attr_indices[0]] 
     1164        yArray = self.no_jittering_scaled_data[attr_indices[1]] 
     1165        zArray = self.no_jittering_scaled_data[attr_indices[2]] 
     1166        if jitterSize > 0.0: 
     1167            xArray += (numpy.random.random(len(xArray))-0.5)*jitterSize 
     1168            yArray += (numpy.random.random(len(yArray))-0.5)*jitterSize 
     1169            zArray += (numpy.random.random(len(zArray))-0.5)*jitterSize 
     1170        if classList != None: 
     1171            data = numpy.compress(validData, numpy.array((xArray, yArray, zArray, classList)), axis = 1) 
     1172        else: 
     1173            data = numpy.compress(validData, numpy.array((xArray, yArray, zArray)), axis = 1) 
     1174        data = numpy.transpose(data) 
     1175        return data 
     1176 
     1177    createProjectionAsNumericArray3D = create_projection_as_numeric_array_3D 
    11171178 
    11181179    @deprecated_keywords({"attributeNameOrder": "attribute_name_order", 
     
    11861247                                           "getProjectedPointPosition": "get_projected_point_position", 
    11871248                                           "createProjectionAsExampleTable": "create_projection_as_example_table", 
     1249                                           "createProjectionAsExampleTable3D": "create_projection_as_example_table_3D", 
    11881250                                           "createProjectionAsNumericArray": "create_projection_as_numeric_array", 
     1251                                           "createProjectionAsNumericArray3D": "create_projection_as_numeric_array_3D", 
    11891252                                           "getOptimalClusters": "get_optimal_clusters" 
    11901253                                           })(ScaleScatterPlotData) 
  • orange/OrangeWidgets/Prototypes/OWScatterPlot3D.py

    r8536 r8539  
    1212import OWToolbars 
    1313import OWColorPalette 
     14import orngVizRank 
     15from OWkNNOptimization import * 
     16from orngScaleScatterPlotData import * 
    1417 
    1518import numpy 
    1619 
    1720TooltipKind = enum('NONE', 'VISIBLE', 'ALL') # Which attributes should be displayed in tooltips? 
     21 
     22class ScatterPlot(OWPlot3D, orngScaleScatterPlotData): 
     23    def __init__(self, parent=None): 
     24        OWPlot3D.__init__(self, parent) 
     25        orngScaleScatterPlotData.__init__(self) 
     26 
     27    def set_data(self, data, subsetData=None, **args): 
     28        orngScaleScatterPlotData.setData(self, data, subsetData, **args) 
    1829 
    1930class OWScatterPlot3D(OWWidget): 
     
    2435                    'auto_send_selection', 'auto_send_selection_update', 
    2536                    'jitter_size', 'jitter_continuous'] 
    26     contextHandlers = {"": DomainContextHandler("", ["xAttr", "yAttr", "zAttr"])} 
     37    contextHandlers = {"": DomainContextHandler("", ["x_attr", "y_attr", "z_attr"])} 
    2738    jitter_sizes = [0.0, 0.1, 0.5, 1, 2, 3, 4, 5, 7, 10, 15, 20, 30, 40, 50] 
    2839 
     
    95106            ) 
    96107 
    97         self.plot = OWPlot3D(self) 
     108        self.plot = ScatterPlot(self) 
     109        self.vizrank = OWVizRank(self, self.signalManager, self.plot, orngVizRank.SCATTERPLOT3D, "ScatterPlot3D") 
     110        self.optimization_dlg = self.vizrank 
     111 
     112        self.optimization_buttons = OWGUI.widgetBox(self.main_tab, 'Optimization dialogs', orientation='horizontal') 
     113        OWGUI.button(self.optimization_buttons, self, "VizRank", callback=self.vizrank.reshow, 
     114            tooltip='Opens VizRank dialog, where you can search for interesting projections with different subsets of attributes', 
     115            debuggingEnabled=0) 
    98116 
    99117        box = OWGUI.widgetBox(self.settings_tab, 'Point properties') 
     
    246264        self.closeContext("") 
    247265        self.data = data 
     266        self.plot.set_data(data) 
    248267        self.x_attr_cb.clear() 
    249268        self.y_attr_cb.clear() 
     
    468487        return X, Y, Z, None 
    469488 
     489    def showSelectedAttributes(self): 
     490        val = self.vizrank.getSelectedProjection() 
     491        if not val: return 
     492        if self.data.domain.classVar: 
     493            self.attr_color = self.attr_name_index[self.data.domain.classVar.name] 
     494        if not self.plot.have_data: 
     495            return 
     496        attr_list = val[3] 
     497        if attr_list and len(attr_list) == 3: 
     498            self.x_attr = self.attr_name_index[attr_list[0]] 
     499            self.y_attr = self.attr_name_index[attr_list[1]] 
     500            self.z_attr = self.attr_name_index[attr_list[2]] 
     501 
     502        #if self.graph.dataHasDiscreteClass and (self.vizrank.showKNNCorrectButton.isChecked() or self.vizrank.showKNNWrongButton.isChecked()): 
     503        #    kNNExampleAccuracy, probabilities = self.vizrank.kNNClassifyData(self.graph.createProjectionAsExampleTable([self.graph.attributeNameIndex[self.attrX], self.graph.attributeNameIndex[self.attrY]])) 
     504        #    if self.vizrank.showKNNCorrectButton.isChecked(): kNNExampleAccuracy = ([1.0 - val for val in kNNExampleAccuracy], "Probability of wrong classification = %.2f%%") 
     505        #    else: kNNExampleAccuracy = (kNNExampleAccuracy, "Probability of correct classification = %.2f%%") 
     506        #else: 
     507        #    kNNExampleAccuracy = None 
     508        #self.graph.insideColors = insideColors or self.classificationResults or kNNExampleAccuracy or self.outlierValues 
     509        #self.graph.updateData(self.attrX, self.attrY, self.attrColor, self.attrShape, self.attrSize, self.attrLabel) 
     510        self.update_plot() 
     511 
    470512if __name__ == "__main__": 
    471513    app = QApplication(sys.argv) 
  • orange/OrangeWidgets/plot/owplot3d.py

    r8536 r8539  
    385385    def __init__(self, parent=None): 
    386386        QtOpenGL.QGLWidget.__init__(self, QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) 
    387  
    388         void = lambda: None 
    389         self.activateZooming = void 
    390         self.activateRectangleSelection = void 
    391         self.activatePolygonSelection = void 
    392         self.activatePanning = void 
    393         self.activateSelection = void 
    394         self.removeLastSelection = void 
    395387 
    396388        self.commands = [] 
  • orange/orngVizRank.py

    r8378 r8539  
    8686LINEAR_PROJECTION = 3 
    8787POLYVIZ = 4 
     88SCATTERPLOT3D = 5 
    8889KNN_IN_ORIGINAL_SPACE = 10 
    8990 
     
    891892 
    892893                    permutations = self.getNextPermutations() 
     894        elif self.visualizationMethod == SCATTERPLOT3D: 
     895            evaluatedAttributes = self.getEvaluatedAttributes() 
     896            contVars = [orange.FloatVariable(attr.name) for attr in self.graph.data_domain.attributes] 
     897            attrCount = len(self.graph.data_domain.attributes) 
     898 
     899            count = len(evaluatedAttributes)*(len(evaluatedAttributes)-1)/2 
     900            strCount = orngVisFuncts.createStringFromNumber(count) 
     901             
     902            for i in range(len(evaluatedAttributes)): 
     903                attr1 = self.graph.attribute_name_index[evaluatedAttributes[i]] 
     904                for j in range(i): 
     905                    attr2 = self.graph.attribute_name_index[evaluatedAttributes[j]] 
     906                    for k in range(j): 
     907                        attr3 = self.graph.attribute_name_index[evaluatedAttributes[k]] 
     908                        self.evaluatedProjectionsCount += 1 
     909                        if self.isEvaluationCanceled(): 
     910                            return self.evaluatedProjectionsCount 
     911 
     912                        table = self.graph.create_projection_as_example_table_3D([attr1, attr2, attr3]) 
     913                        if len(table) < self.minNumOfExamples: continue 
     914                        accuracy, other_results = self.evaluateProjection(table) 
     915                        generalDict = {"Results": self.evaluationResults} if self.saveEvaluationResults else {} 
     916                        self.addResult(accuracy, other_results, len(table), 
     917                            [self.graph.data_domain[attr1].name, self.graph.data_domain[attr2].name, self.graph.data_domain[attr3].name], 
     918                            self.evaluatedProjectionsCount, generalDict=generalDict) 
     919 
     920                        if self.__class__ != VizRank: 
     921                            self.setStatusBarText("Evaluated %s/%s projections..." % (orngVisFuncts.createStringFromNumber(self.evaluatedProjectionsCount), strCount)) 
     922                            self.parentWidget.progressBarSet(100.0*self.evaluatedProjectionsCount/max(1,float(count))) 
     923 
    893924        else: 
    894925            print "unknown visualization method" 
Note: See TracChangeset for help on using the changeset viewer.