Changeset 10475:61c2249d671f in orange


Ignore:
Timestamp:
03/08/12 19:44:26 (2 years ago)
Author:
Matija Polajnar <matija.polajnar@…>
Branch:
default
Message:

Major refactorization of linear projections, fixing some bugs in the process.

Files:
4 added
2 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Visualize Qt/OWLinProjGraphQt.py

    r9671 r10475  
    697697            # We never have different sizes in LinProj 
    698698            self.main_curve.set_point_sizes([self.pointWidth]) 
    699          
     699 
     700OWLinProjGraph = graph_deprecator(OWLinProjGraph) 
    700701 
    701702 
  • Orange/OrangeWidgets/Visualize/OWLinProjGraph.py

    r9671 r10475  
    720720        OWGraph.drawCanvas(self, painter) 
    721721 
     722OWLinProjGraph = graph_deprecator(OWLinProjGraph) 
    722723 
    723724if __name__== "__main__": 
  • Orange/orng/orngScaleLinProjData.py

    r9671 r10475  
    11from orngScaleData import * 
    22from Orange.preprocess.scaling import ScaleLinProjData as orngScaleLinProjData 
     3from Orange.preprocess.scaling import graph_deprecator 
  • Orange/preprocess/scaling.py

    r10020 r10475  
    442442        if also_class_if_exists and self.data_has_class:  
    443443            inds.append(self.data_class_index)  
    444         selectedArray = self.valid_data_array.take(inds, axis = 0) 
    445         arr = numpy.add.reduce(selectedArray) 
     444        selected_array = self.valid_data_array.take(inds, axis = 0) 
     445        arr = numpy.add.reduce(selected_array) 
    446446        return numpy.equal(arr, len(inds)) 
    447447     
     
    459459        if also_class_if_exists and self.data_class_index:  
    460460            inds.append(self.data_class_index) 
    461         selectedArray = self.valid_subset_data_array.take(inds, axis = 0) 
    462         arr = numpy.add.reduce(selectedArray) 
     461        selected_array = self.valid_subset_data_array.take(inds, axis = 0) 
     462        arr = numpy.add.reduce(selected_array) 
    463463        return numpy.equal(arr, len(inds)) 
    464464     
     
    470470        valid data value. 
    471471        """ 
    472         validList = self.get_valid_list(indices) 
    473         return numpy.nonzero(validList)[0] 
     472        valid_list = self.get_valid_list(indices) 
     473        return numpy.nonzero(valid_list)[0] 
    474474     
    475475    getValidIndices = get_valid_indices 
     
    480480        valid data value. 
    481481        """ 
    482         validList = self.get_valid_subset_list(indices) 
    483         return numpy.nonzero(validList)[0] 
     482        valid_list = self.get_valid_subset_list(indices) 
     483        return numpy.nonzero(valid_list)[0] 
    484484     
    485485    getValidSubsetIndices = get_valid_subset_indices 
     
    608608 
    609609    @deprecated_keywords({"attrIndices": "attr_indices", 
    610                           "settingsDict": "settings_dict"}) 
     610                          "settingsDict": "settings_dict", 
     611                          "useAnchorData": "use_anchor_data", 
     612                          "xAnchors": "xanchors", 
     613                          "yAnchors": "yanchors", 
     614                          "anchorRadius": "anchor_radius", 
     615                          "normalizeExample": "normalize_example" 
     616                          }) 
    611617    def get_projected_point_position(self, attr_indices, values, **settings_dict): 
    612618        """ 
     
    617623        """ 
    618624        # load the elements from the settings dict 
    619         use_anchor_data = settings_dict.get("useAnchorData") 
    620         xanchors = settings_dict.get("xAnchors") 
    621         yanchors = settings_dict.get("yAnchors") 
    622         anchor_radius = settings_dict.get("anchorRadius") 
    623         normalize_example = settings_dict.get("normalizeExample") 
     625        use_anchor_data = settings_dict.get("use_anchor_data") 
     626        xanchors = settings_dict.get("x_anchors") 
     627        yanchors = settings_dict.get("y_anchors") 
     628        anchor_radius = settings_dict.get("anchor_radius") 
     629        normalize_example = settings_dict.get("normalize_example") 
    624630 
    625631        if attr_indices != self.last_attr_indices: 
     
    695701 
    696702    @deprecated_keywords({"attrIndices": "attr_indices", 
    697                           "settingsDict": "settings_dict"}) 
     703                          "settingsDict": "settings_dict", 
     704                          "validData": "valid_data", 
     705                          "classList": "class_list", 
     706                          "XAnchors": "xanchors", 
     707                          "YAnchors": "yanchors", 
     708                          "scaleFactor": "scale_factor", 
     709                          "jitterSize": "jitter_size", 
     710                          "useAnchorData": "use_anchor_data", 
     711                          "removeMissingData": "remove_missing_data", 
     712                          "useSubsetData": "use_subset_data", 
     713                          }) 
    698714    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    699715        # load the elements from the settings dict 
    700         validData = settings_dict.get("validData") 
    701         classList = settings_dict.get("classList") 
     716        valid_data = settings_dict.get("valid_data") 
     717        class_list = settings_dict.get("class_list") 
    702718        sum_i     = settings_dict.get("sum_i") 
    703         XAnchors = settings_dict.get("XAnchors") 
    704         YAnchors = settings_dict.get("YAnchors") 
    705         scaleFactor = settings_dict.get("scaleFactor", 1.0) 
     719        xanchors = settings_dict.get("xanchors") 
     720        yanchors = settings_dict.get("yanchors") 
     721        scale_factor = settings_dict.get("scale_factor", 1.0) 
    706722        normalize = settings_dict.get("normalize") 
    707         jitterSize = settings_dict.get("jitterSize", 0.0) 
    708         useAnchorData = settings_dict.get("useAnchorData", 0) 
    709         removeMissingData = settings_dict.get("removeMissingData", 1) 
    710         useSubsetData = settings_dict.get("useSubsetData", 0)        # use the data or subsetData? 
     723        jitter_size = settings_dict.get("jitter_size", 0.0) 
     724        use_anchor_data = settings_dict.get("use_anchor_data", 0) 
     725        remove_missing_data = settings_dict.get("remove_missing_data", 1) 
     726        use_subset_data = settings_dict.get("use_subset_data", 0)        # use the data or subsetData? 
    711727        #minmaxVals = settings_dict.get("minmaxVals", None) 
    712728 
    713729        # if we want to use anchor data we can get attr_indices from the anchor_data 
    714         if useAnchorData and self.anchor_data: 
     730        if use_anchor_data and self.anchor_data: 
    715731            attr_indices = [self.attribute_name_index[val[2]] for val in self.anchor_data] 
    716732 
    717         if validData == None: 
    718             if useSubsetData: validData = self.get_valid_subset_list(attr_indices) 
    719             else:             validData = self.get_valid_list(attr_indices) 
    720         if sum(validData) == 0: 
     733        if valid_data == None: 
     734            if use_subset_data: valid_data = self.get_valid_subset_list(attr_indices) 
     735            else:             valid_data = self.get_valid_list(attr_indices) 
     736        if sum(valid_data) == 0: 
    721737            return None 
    722738 
    723         if classList == None and self.data_domain.class_var: 
    724             if useSubsetData: classList = self.original_subset_data[self.data_class_index] 
    725             else:             classList = self.original_data[self.data_class_index] 
     739        if class_list == None and self.data_domain.class_var: 
     740            if use_subset_data: class_list = self.original_subset_data[self.data_class_index] 
     741            else:             class_list = self.original_data[self.data_class_index] 
    726742 
    727743        # if jitterSize is set below zero we use scaled_data that has already jittered data 
    728         if useSubsetData: 
    729             if jitterSize < 0.0: data = self.scaled_subset_data 
     744        if use_subset_data: 
     745            if jitter_size < 0.0: data = self.scaled_subset_data 
    730746            else:                data = self.no_jittering_scaled_subset_data 
    731747        else: 
    732             if jitterSize < 0.0: data = self.scaled_data 
     748            if jitter_size < 0.0: data = self.scaled_data 
    733749            else:                data = self.no_jittering_scaled_data 
    734750 
    735751        selectedData = numpy.take(data, attr_indices, axis = 0) 
    736         if removeMissingData: 
    737             selectedData = numpy.compress(validData, selectedData, axis = 1) 
    738             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    739                 classList = numpy.compress(validData, classList) 
    740  
    741         if useAnchorData and self.anchor_data: 
    742             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    743             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    744             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
     752        if remove_missing_data: 
     753            selectedData = numpy.compress(valid_data, selectedData, axis = 1) 
     754            if class_list != None and len(class_list) != numpy.shape(selectedData)[1]: 
     755                class_list = numpy.compress(valid_data, class_list) 
     756 
     757        if use_anchor_data and self.anchor_data: 
     758            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     759            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     760            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors)     # compute the distance of each anchor from the center of the circle 
    745761            if normalize == 1 or (normalize == None and self.normalize_examples): 
    746                 XAnchors *= r 
    747                 YAnchors *= r 
    748         elif (XAnchors != None and YAnchors != None): 
    749             XAnchors = numpy.array(XAnchors); YAnchors = numpy.array(YAnchors) 
    750             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors)     # compute the distance of each anchor from the center of the circle 
    751         else: 
    752             XAnchors = self.create_xanchors(len(attr_indices)) 
    753             YAnchors = self.create_yanchors(len(attr_indices)) 
    754             r = numpy.ones(len(XAnchors), numpy.float) 
    755  
    756         x_positions = numpy.dot(XAnchors, selectedData) 
    757         y_positions = numpy.dot(YAnchors, selectedData) 
     762                xanchors *= r 
     763                yanchors *= r 
     764        elif (xanchors != None and yanchors != None): 
     765            xanchors = numpy.array(xanchors); yanchors = numpy.array(yanchors) 
     766            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors)     # compute the distance of each anchor from the center of the circle 
     767        else: 
     768            xanchors = self.create_xanchors(len(attr_indices)) 
     769            yanchors = self.create_yanchors(len(attr_indices)) 
     770            r = numpy.ones(len(xanchors), numpy.float) 
     771 
     772        x_positions = numpy.dot(xanchors, selectedData) 
     773        y_positions = numpy.dot(yanchors, selectedData) 
    758774 
    759775        if normalize == 1 or (normalize == None and self.normalize_examples): 
    760776            if sum_i == None: 
    761                 sum_i = self._getSum_i(selectedData, useAnchorData, r) 
     777                sum_i = self._getSum_i(selectedData, use_anchor_data, r) 
    762778            x_positions /= sum_i 
    763779            y_positions /= sum_i 
    764             self.trueScaleFactor = scaleFactor 
    765         else: 
    766             if not removeMissingData: 
     780            self.trueScaleFactor = scale_factor 
     781        else: 
     782            if not remove_missing_data: 
    767783                try: 
    768                     x_validData = numpy.compress(validData, x_positions) 
    769                     y_validData = numpy.compress(validData, y_positions) 
     784                    x_valid_data = numpy.compress(valid_data, x_positions) 
     785                    y_valid_data = numpy.compress(valid_data, y_positions) 
    770786                except: 
    771                     print validData 
     787                    print valid_data 
    772788                    print x_positions 
    773                     print numpy.shape(validData) 
     789                    print numpy.shape(valid_data) 
    774790                    print numpy.shape(x_positions) 
    775791            else: 
    776                 x_validData = x_positions 
    777                 y_validData = y_positions 
     792                x_valid_data = x_positions 
     793                y_valid_data = y_positions 
    778794             
    779             dist = math.sqrt(max(x_validData*x_validData + y_validData*y_validData)) or 1 
    780             self.trueScaleFactor = scaleFactor / dist 
     795            dist = math.sqrt(max(x_valid_data*x_valid_data + y_valid_data*y_valid_data)) or 1 
     796            self.trueScaleFactor = scale_factor / dist 
    781797 
    782798        self.unscaled_x_positions = numpy.array(x_positions) 
     
    787803            y_positions *= self.trueScaleFactor 
    788804 
    789         if jitterSize > 0.0: 
    790             x_positions += numpy.random.uniform(-jitterSize, jitterSize, len(x_positions)) 
    791             y_positions += numpy.random.uniform(-jitterSize, jitterSize, len(y_positions)) 
     805        if jitter_size > 0.0: 
     806            x_positions += numpy.random.uniform(-jitter_size, jitter_size, len(x_positions)) 
     807            y_positions += numpy.random.uniform(-jitter_size, jitter_size, len(y_positions)) 
    792808 
    793809        self.last_attr_indices = attr_indices 
    794         if classList != None: 
    795             return numpy.transpose(numpy.array((x_positions, y_positions, classList))) 
     810        if class_list != None: 
     811            return numpy.transpose(numpy.array((x_positions, y_positions, class_list))) 
    796812        else: 
    797813            return numpy.transpose(numpy.array((x_positions, y_positions))) 
     
    818834     
    819835    _getSum_i = _getsum_i 
     836 
     837graph_deprecator = deprecated_members({"setData": "set_data", 
     838                                       "updateData": "update_data", 
     839                                       "scaleFactor": "scale_factor"}) 
    820840 
    821841ScaleLinProjData = deprecated_members({"setAnchors": "set_anchors", 
     
    834854                                       "anchorData": "anchor_data", 
    835855                                       "lastAttrIndices": "last_attr_indices", 
    836                                        "anchorDict": "anchor_dict", 
    837                                       })(ScaleLinProjData) 
     856                                       "anchorDict": "anchor_dict"})(ScaleLinProjData) 
    838857 
    839858class ScaleLinProjData3D(ScaleData): 
     
    927946 
    928947    @deprecated_keywords({"attrIndices": "attr_indices", 
    929                           "settingsDict": "settings_dict"}) 
     948                          "settingsDict": "settings_dict", 
     949                          "useAnchorData": "use_anchor_data", 
     950                          "xAnchors": "xanchors", 
     951                          "yAnchors": "yanchors", 
     952                          "zAnchors": "zanchors", 
     953                          "anchorRadius": "anchor_radius", 
     954                          "normalizeExample": "normalize_example", 
     955                          }) 
    930956    def get_projected_point_position(self, attr_indices, values, **settings_dict): 
    931957        """ 
     
    936962        """ 
    937963        # load the elements from the settings dict 
    938         use_anchor_data = settings_dict.get("useAnchorData") 
    939         xanchors = settings_dict.get('xAnchors') 
    940         yanchors = settings_dict.get('yAnchors') 
    941         zanchors = settings_dict.get('zAnchors') 
    942         anchor_radius = settings_dict.get("anchorRadius") 
    943         normalize_example = settings_dict.get("normalizeExample") 
     964        use_anchor_data = settings_dict.get("use_anchor_data") 
     965        xanchors = settings_dict.get('xanchors') 
     966        yanchors = settings_dict.get('yanchors') 
     967        zanchors = settings_dict.get('zanchors') 
     968        anchor_radius = settings_dict.get("anchor_radius") 
     969        normalize_example = settings_dict.get("normalize_example") 
    944970 
    945971        if attr_indices != self.last_attr_indices: 
     
    9821008            s = sum(numpy.array(values)*anchor_radius) 
    9831009            if s == 0: return [0.0, 0.0] 
    984             x = self.trueScaleFactor * numpy.dot(xanchors*anchor_radius, 
     1010            x = self.true_scale_factor * numpy.dot(xanchors*anchor_radius, 
    9851011                                                 values) / float(s) 
    986             y = self.trueScaleFactor * numpy.dot(yanchors*anchor_radius, 
     1012            y = self.true_scale_factor * numpy.dot(yanchors*anchor_radius, 
    9871013                                                 values) / float(s) 
    988             z = self.trueScaleFactor * numpy.dot(zanchors*anchor_radius, 
     1014            z = self.true_scale_factor * numpy.dot(zanchors*anchor_radius, 
    9891015                                                 values) / float(s) 
    9901016        else: 
    991             x = self.trueScaleFactor * numpy.dot(xanchors, values) 
    992             y = self.trueScaleFactor * numpy.dot(yanchors, values) 
    993             z = self.trueScaleFactor * numpy.dot(zanchors, values) 
     1017            x = self.true_scale_factor * numpy.dot(xanchors, values) 
     1018            y = self.true_scale_factor * numpy.dot(yanchors, values) 
     1019            z = self.true_scale_factor * numpy.dot(zanchors, values) 
    9941020 
    9951021        return [x, y, z] 
     
    10261052 
    10271053    @deprecated_keywords({"attrIndices": "attr_indices", 
    1028                           "settingsDict": "settings_dict"}) 
     1054                          "settingsDict": "settings_dict", 
     1055                          "validData": "valid_data", 
     1056                          "classList": "class_list", 
     1057                          "XAnchors": "xanchors", 
     1058                          "YAnchors": "yanchors", 
     1059                          "ZAnchors": "zanchors", 
     1060                          "scaleFactor": "scale_factor", 
     1061                          "jitterSize": "jitter_size", 
     1062                          "useAnchorData": "use_anchor_data", 
     1063                          "removeMissingData": "remove_missing_data", 
     1064                          "useSubsetData": "use_subset_data", 
     1065                          }) 
    10291066    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    10301067        # load the elements from the settings dict 
    1031         validData = settings_dict.get("validData") 
    1032         classList = settings_dict.get("classList") 
     1068        valid_data = settings_dict.get("valid_data") 
     1069        class_list = settings_dict.get("class_list") 
    10331070        sum_i     = settings_dict.get("sum_i") 
    1034         XAnchors = settings_dict.get("XAnchors") 
    1035         YAnchors = settings_dict.get("YAnchors") 
    1036         ZAnchors = settings_dict.get("ZAnchors") 
    1037         scaleFactor = settings_dict.get("scaleFactor", 1.0) 
     1071        xanchors = settings_dict.get("xanchors") 
     1072        yanchors = settings_dict.get("yanchors") 
     1073        zanchors = settings_dict.get("zanchors") 
     1074        scale_factor = settings_dict.get("scale_factor", 1.0) 
    10381075        normalize = settings_dict.get("normalize") 
    1039         jitterSize = settings_dict.get("jitterSize", 0.0) 
    1040         useAnchorData = settings_dict.get("useAnchorData", 0) 
    1041         removeMissingData = settings_dict.get("removeMissingData", 1) 
    1042         useSubsetData = settings_dict.get("useSubsetData", 0)        # use the data or subsetData? 
     1076        jitter_size = settings_dict.get("jitter_size", 0.0) 
     1077        use_anchor_data = settings_dict.get("use_anchor_data", 0) 
     1078        remove_missing_data = settings_dict.get("remove_missing_data", 1) 
     1079        use_subset_data = settings_dict.get("use_subset_data", 0)        # use the data or subsetData? 
    10431080        #minmaxVals = settings_dict.get("minmaxVals", None) 
    10441081 
    10451082        # if we want to use anchor data we can get attr_indices from the anchor_data 
    1046         if useAnchorData and self.anchor_data: 
     1083        if use_anchor_data and self.anchor_data: 
    10471084            attr_indices = [self.attribute_name_index[val[3]] for val in self.anchor_data] 
    10481085 
    1049         if validData == None: 
    1050             if useSubsetData: validData = self.get_valid_subset_list(attr_indices) 
    1051             else:             validData = self.get_valid_list(attr_indices) 
    1052         if sum(validData) == 0: 
     1086        if valid_data == None: 
     1087            if use_subset_data: valid_data = self.get_valid_subset_list(attr_indices) 
     1088            else:             valid_data = self.get_valid_list(attr_indices) 
     1089        if sum(valid_data) == 0: 
    10531090            return None 
    10541091 
    1055         if classList == None and self.data_domain.class_var: 
    1056             if useSubsetData: classList = self.original_subset_data[self.data_class_index] 
    1057             else:             classList = self.original_data[self.data_class_index] 
     1092        if class_list == None and self.data_domain.class_var: 
     1093            if use_subset_data: class_list = self.original_subset_data[self.data_class_index] 
     1094            else:             class_list = self.original_data[self.data_class_index] 
    10581095 
    10591096        # if jitterSize is set below zero we use scaled_data that has already jittered data 
    1060         if useSubsetData: 
    1061             if jitterSize < 0.0: data = self.scaled_subset_data 
     1097        if use_subset_data: 
     1098            if jitter_size < 0.0: data = self.scaled_subset_data 
    10621099            else:                data = self.no_jittering_scaled_subset_data 
    10631100        else: 
    1064             if jitterSize < 0.0: data = self.scaled_data 
     1101            if jitter_size < 0.0: data = self.scaled_data 
    10651102            else:                data = self.no_jittering_scaled_data 
    10661103 
    1067         selectedData = numpy.take(data, attr_indices, axis=0) 
    1068         if removeMissingData: 
    1069             selectedData = numpy.compress(validData, selectedData, axis=1) 
    1070             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    1071                 classList = numpy.compress(validData, classList) 
    1072  
    1073         if useAnchorData and self.anchor_data: 
    1074             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    1075             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    1076             ZAnchors = numpy.array([val[2] for val in self.anchor_data]) 
    1077             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors + ZAnchors*ZAnchors)     # compute the distance of each anchor from the center of the circle 
     1104        selected_data = numpy.take(data, attr_indices, axis=0) 
     1105        if remove_missing_data: 
     1106            selected_data = numpy.compress(valid_data, selected_data, axis=1) 
     1107            if class_list != None and len(class_list) != numpy.shape(selected_data)[1]: 
     1108                class_list = numpy.compress(valid_data, class_list) 
     1109 
     1110        if use_anchor_data and self.anchor_data: 
     1111            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     1112            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     1113            zanchors = numpy.array([val[2] for val in self.anchor_data]) 
     1114            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors + zanchors*zanchors)     # compute the distance of each anchor from the center of the circle 
    10781115            if normalize == 1 or (normalize == None and self.normalize_examples): 
    1079                 XAnchors *= r 
    1080                 YAnchors *= r 
    1081                 ZAnchors *= r 
    1082         elif (XAnchors != None and YAnchors != None and ZAnchors != None): 
    1083             XAnchors = numpy.array(XAnchors) 
    1084             YAnchors = numpy.array(YAnchors) 
    1085             ZAnchors = numpy.array(ZAnchors) 
    1086             r = numpy.sqrt(XAnchors*XAnchors + YAnchors*YAnchors + ZAnchors*ZAnchors)     # compute the distance of each anchor from the center of the circle 
     1116                xanchors *= r 
     1117                yanchors *= r 
     1118                zanchors *= r 
     1119        elif (xanchors != None and yanchors != None and zanchors != None): 
     1120            xanchors = numpy.array(xanchors) 
     1121            yanchors = numpy.array(yanchors) 
     1122            zanchors = numpy.array(zanchors) 
     1123            r = numpy.sqrt(xanchors*xanchors + yanchors*yanchors + zanchors*zanchors)     # compute the distance of each anchor from the center of the circle 
    10871124        else: 
    10881125            self.create_anchors(len(attr_indices)) 
    1089             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    1090             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    1091             ZAnchors = numpy.array([val[2] for val in self.anchor_data]) 
    1092             r = numpy.ones(len(XAnchors), numpy.float) 
    1093  
    1094         x_positions = numpy.dot(XAnchors, selectedData) 
    1095         y_positions = numpy.dot(YAnchors, selectedData) 
    1096         z_positions = numpy.dot(ZAnchors, selectedData) 
     1126            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     1127            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     1128            zanchors = numpy.array([val[2] for val in self.anchor_data]) 
     1129            r = numpy.ones(len(xanchors), numpy.float) 
     1130 
     1131        x_positions = numpy.dot(xanchors, selected_data) 
     1132        y_positions = numpy.dot(yanchors, selected_data) 
     1133        z_positions = numpy.dot(zanchors, selected_data) 
    10971134 
    10981135        if normalize == 1 or (normalize == None and self.normalize_examples): 
    10991136            if sum_i == None: 
    1100                 sum_i = self._getSum_i(selectedData, useAnchorData, r) 
     1137                sum_i = self._getSum_i(selected_data, use_anchor_data, r) 
    11011138            x_positions /= sum_i 
    11021139            y_positions /= sum_i 
    11031140            z_positions /= sum_i 
    1104             self.trueScaleFactor = scaleFactor 
    1105         else: 
    1106             if not removeMissingData: 
     1141            self.true_scale_factor = scale_factor 
     1142        else: 
     1143            if not remove_missing_data: 
    11071144                try: 
    1108                     x_validData = numpy.compress(validData, x_positions) 
    1109                     y_validData = numpy.compress(validData, y_positions) 
    1110                     z_validData = numpy.compress(validData, z_positions) 
     1145                    x_valid_data = numpy.compress(valid_data, x_positions) 
     1146                    y_valid_data = numpy.compress(valid_data, y_positions) 
     1147                    z_valid_data = numpy.compress(valid_data, z_positions) 
    11111148                except: 
    1112                     print validData 
     1149                    print valid_data 
    11131150                    print x_positions 
    1114                     print numpy.shape(validData) 
     1151                    print numpy.shape(valid_data) 
    11151152                    print numpy.shape(x_positions) 
    11161153            else: 
    1117                 x_validData = x_positions 
    1118                 y_validData = y_positions 
    1119                 z_validData = z_positions 
    1120  
    1121             dist = math.sqrt(max(x_validData*x_validData + y_validData*y_validData + z_validData*z_validData)) or 1 
    1122             self.trueScaleFactor = scaleFactor / dist 
     1154                x_valid_data = x_positions 
     1155                y_valid_data = y_positions 
     1156                z_valid_data = z_positions 
     1157 
     1158            dist = math.sqrt(max(x_valid_data*x_valid_data + y_valid_data*y_valid_data + z_valid_data*z_valid_data)) or 1 
     1159            self.true_scale_factor = scale_factor / dist 
    11231160 
    11241161        self.unscaled_x_positions = numpy.array(x_positions) 
     
    11261163        self.unscaled_z_positions = numpy.array(z_positions) 
    11271164 
    1128         if self.trueScaleFactor != 1.0: 
    1129             x_positions *= self.trueScaleFactor 
    1130             y_positions *= self.trueScaleFactor 
    1131             z_positions *= self.trueScaleFactor 
    1132  
    1133         if jitterSize > 0.0: 
    1134             x_positions += numpy.random.uniform(-jitterSize, jitterSize, len(x_positions)) 
    1135             y_positions += numpy.random.uniform(-jitterSize, jitterSize, len(y_positions)) 
    1136             z_positions += numpy.random.uniform(-jitterSize, jitterSize, len(z_positions)) 
     1165        if self.true_scale_factor != 1.0: 
     1166            x_positions *= self.true_scale_factor 
     1167            y_positions *= self.true_scale_factor 
     1168            z_positions *= self.true_scale_factor 
     1169 
     1170        if jitter_size > 0.0: 
     1171            x_positions += numpy.random.uniform(-jitter_size, jitter_size, len(x_positions)) 
     1172            y_positions += numpy.random.uniform(-jitter_size, jitter_size, len(y_positions)) 
     1173            z_positions += numpy.random.uniform(-jitter_size, jitter_size, len(z_positions)) 
    11371174 
    11381175        self.last_attr_indices = attr_indices 
    1139         if classList != None: 
    1140             return numpy.transpose(numpy.array((x_positions, y_positions, z_positions, classList))) 
     1176        if class_list != None: 
     1177            return numpy.transpose(numpy.array((x_positions, y_positions, z_positions, class_list))) 
    11411178        else: 
    11421179            return numpy.transpose(numpy.array((x_positions, y_positions, z_positions))) 
     
    11781215                                       "lastAttrIndices": "last_attr_indices", 
    11791216                                       "anchorDict": "anchor_dict", 
     1217                                       "trueScaleFactor": "true_scale_factor" 
    11801218                                      })(ScaleLinProjData3D) 
    11811219 
     
    12101248     
    12111249    @deprecated_keywords({"attrIndices": "attr_indices", 
    1212                           "settingsDict": "settings_dict"}) 
     1250                          "settingsDict": "settings_dict", 
     1251                          "validData": "valid_data", 
     1252                          "classList": "class_list", 
     1253                          "XAnchors": "xanchors", 
     1254                          "YAnchors": "yanchors", 
     1255                          "scaleFactor": "scale_factor", 
     1256                          "jitterSize": "jitter_size", 
     1257                          "removeMissingData": "remove_missing_data", 
     1258                          }) 
    12131259    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    12141260        # load the elements from the settings dict 
    1215         attributeReverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
    1216         validData = settings_dict.get("validData") 
    1217         classList = settings_dict.get("classList") 
     1261        attribute_reverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
     1262        valid_data = settings_dict.get("valid_data") 
     1263        class_list = settings_dict.get("class_list") 
    12181264        sum_i     = settings_dict.get("sum_i") 
    1219         XAnchors  = settings_dict.get("XAnchors") 
    1220         YAnchors  = settings_dict.get("YAnchors") 
    1221         scaleFactor = settings_dict.get("scaleFactor", 1.0) 
    1222         jitterSize  = settings_dict.get("jitterSize", 0.0) 
    1223         removeMissingData = settings_dict.get("removeMissingData", 1) 
    1224          
    1225         if validData == None: 
    1226             validData = self.get_valid_list(attr_indices) 
    1227         if sum(validData) == 0: 
     1265        xanchors  = settings_dict.get("xanchors") 
     1266        yanchors  = settings_dict.get("yanchors") 
     1267        scale_factor = settings_dict.get("scale_factor", 1.0) 
     1268        jitter_size  = settings_dict.get("jitter_size", 0.0) 
     1269        remove_missing_data = settings_dict.get("remove_missing_data", 1) 
     1270         
     1271        if valid_data == None: 
     1272            valid_data = self.get_valid_list(attr_indices) 
     1273        if sum(valid_data) == 0: 
    12281274            return None 
    12291275 
    1230         if classList == None and self.data_has_class: 
    1231             classList = self.original_data[self.data_class_index]   
    1232  
    1233         if removeMissingData: 
    1234             selectedData = numpy.compress(validData, 
     1276        if class_list == None and self.data_has_class: 
     1277            class_list = self.original_data[self.data_class_index] 
     1278 
     1279        if remove_missing_data: 
     1280            selected_data = numpy.compress(valid_data, 
    12351281                                          numpy.take(self.no_jittering_scaled_data, 
    12361282                                                     attr_indices, axis = 0), 
    12371283                                                     axis = 1) 
    1238             if classList != None and len(classList) != numpy.shape(selectedData)[1]: 
    1239                 classList = numpy.compress(validData, classList) 
    1240         else: 
    1241             selectedData = numpy.take(self.no_jittering_scaled_data, 
     1284            if class_list != None and len(class_list) != numpy.shape(selected_data)[1]: 
     1285                class_list = numpy.compress(valid_data, class_list) 
     1286        else: 
     1287            selected_data = numpy.take(self.no_jittering_scaled_data, 
    12421288                                      attr_indices, axis = 0) 
    12431289         
    12441290        if sum_i == None: 
    1245             sum_i = self._getSum_i(selectedData) 
    1246  
    1247         if XAnchors == None or YAnchors == None: 
    1248             XAnchors = self.create_xanchors(len(attr_indices)) 
    1249             YAnchors = self.create_yanchors(len(attr_indices)) 
    1250  
    1251         xanchors = numpy.zeros(numpy.shape(selectedData), numpy.float) 
    1252         yanchors = numpy.zeros(numpy.shape(selectedData), numpy.float) 
     1291            sum_i = self._getSum_i(selected_data) 
     1292 
     1293        if xanchors == None or yanchors == None: 
     1294            xanchors = self.create_xanchors(len(attr_indices)) 
     1295            yanchors = self.create_yanchors(len(attr_indices)) 
     1296 
     1297        xanchors = numpy.zeros(numpy.shape(selected_data), numpy.float) 
     1298        yanchors = numpy.zeros(numpy.shape(selected_data), numpy.float) 
    12531299        length = len(attr_indices) 
    12541300 
    12551301        for i in range(length): 
    1256             if attributeReverse[i]: 
    1257                 xanchors[i] = selectedData[i] * XAnchors[i] + (1-selectedData[i]) * XAnchors[(i+1)%length] 
    1258                 yanchors[i] = selectedData[i] * YAnchors[i] + (1-selectedData[i]) * YAnchors[(i+1)%length] 
     1302            if attribute_reverse[i]: 
     1303                xanchors[i] = selected_data[i] * xanchors[i] + (1-selected_data[i]) * xanchors[(i+1)%length] 
     1304                yanchors[i] = selected_data[i] * yanchors[i] + (1-selected_data[i]) * yanchors[(i+1)%length] 
    12591305            else: 
    1260                 xanchors[i] = (1-selectedData[i]) * XAnchors[i] + selectedData[i] * XAnchors[(i+1)%length] 
    1261                 yanchors[i] = (1-selectedData[i]) * YAnchors[i] + selectedData[i] * YAnchors[(i+1)%length] 
    1262  
    1263         x_positions = numpy.sum(numpy.multiply(xanchors, selectedData), axis=0)/sum_i 
    1264         y_positions = numpy.sum(numpy.multiply(yanchors, selectedData), axis=0)/sum_i 
     1306                xanchors[i] = (1-selected_data[i]) * xanchors[i] + selected_data[i] * xanchors[(i+1)%length] 
     1307                yanchors[i] = (1-selected_data[i]) * yanchors[i] + selected_data[i] * yanchors[(i+1)%length] 
     1308 
     1309        x_positions = numpy.sum(numpy.multiply(xanchors, selected_data), axis=0)/sum_i 
     1310        y_positions = numpy.sum(numpy.multiply(yanchors, selected_data), axis=0)/sum_i 
    12651311        #x_positions = numpy.sum(numpy.transpose(xanchors* numpy.transpose(selectedData)), axis=0) / sum_i 
    12661312        #y_positions = numpy.sum(numpy.transpose(yanchors* numpy.transpose(selectedData)), axis=0) / sum_i 
    12671313 
    1268         if scaleFactor != 1.0: 
    1269             x_positions = x_positions * scaleFactor 
    1270             y_positions = y_positions * scaleFactor 
    1271         if jitterSize > 0.0: 
    1272             x_positions += (numpy.random.random(len(x_positions))-0.5)*jitterSize 
    1273             y_positions += (numpy.random.random(len(y_positions))-0.5)*jitterSize 
    1274  
    1275         if classList != None: 
    1276             return numpy.transpose(numpy.array((x_positions, y_positions, classList))) 
     1314        if scale_factor != 1.0: 
     1315            x_positions = x_positions * scale_factor 
     1316            y_positions = y_positions * scale_factor 
     1317        if jitter_size > 0.0: 
     1318            x_positions += (numpy.random.random(len(x_positions))-0.5)*jitter_size 
     1319            y_positions += (numpy.random.random(len(y_positions))-0.5)*jitter_size 
     1320 
     1321        if class_list != None: 
     1322            return numpy.transpose(numpy.array((x_positions, y_positions, class_list))) 
    12771323        else: 
    12781324            return numpy.transpose(numpy.array((x_positions, y_positions))) 
     
    12811327 
    12821328    @deprecated_keywords({"attrIndices": "attr_indices", 
    1283                           "settingsDict": "settings_dict"}) 
     1329                          "settingsDict": "settings_dict", 
     1330                          "useAnchorData": "use_anchor_data", 
     1331                          "XAnchors": "xanchors", 
     1332                          "YAnchors": "yanchors"}) 
    12841333    def get_projected_point_position(self, attr_indices, values, **settings_dict): 
    12851334        # load the elements from the settings dict 
    1286         attributeReverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
    1287         useAnchorData = settings_dict.get("useAnchorData") 
    1288         XAnchors = settings_dict.get("XAnchors") 
    1289         YAnchors = settings_dict.get("YAnchors") 
    1290      
    1291         if XAnchors != None and YAnchors != None: 
    1292             XAnchors = numpy.array(XAnchors) 
    1293             YAnchors = numpy.array(YAnchors) 
    1294         elif useAnchorData: 
    1295             XAnchors = numpy.array([val[0] for val in self.anchor_data]) 
    1296             YAnchors = numpy.array([val[1] for val in self.anchor_data]) 
    1297         else: 
    1298             XAnchors = self.create_xanchors(len(attr_indices)) 
    1299             YAnchors = self.create_yanchors(len(attr_indices)) 
     1335        attribute_reverse = settings_dict.get("reverse", [0]*len(attr_indices)) 
     1336        use_anchor_data = settings_dict.get("use_anchor_data") 
     1337        xanchors = settings_dict.get("xanchors") 
     1338        yanchors = settings_dict.get("yanchors") 
     1339     
     1340        if xanchors != None and yanchors != None: 
     1341            xanchors = numpy.array(xanchors) 
     1342            yanchors = numpy.array(yanchors) 
     1343        elif use_anchor_data: 
     1344            xanchors = numpy.array([val[0] for val in self.anchor_data]) 
     1345            yanchors = numpy.array([val[1] for val in self.anchor_data]) 
     1346        else: 
     1347            xanchors = self.create_xanchors(len(attr_indices)) 
     1348            yanchors = self.create_yanchors(len(attr_indices)) 
    13001349 
    13011350        m = min(values); M = max(values) 
     
    13131362        yanchors = numpy.zeros(length, numpy.float) 
    13141363        for i in range(length): 
    1315             if attributeReverse[i]: 
    1316                 xanchors[i] = values[i] * XAnchors[i] + (1-values[i]) * XAnchors[(i+1)%length] 
    1317                 yanchors[i] = values[i] * YAnchors[i] + (1-values[i]) * YAnchors[(i+1)%length] 
     1364            if attribute_reverse[i]: 
     1365                xanchors[i] = values[i] * xanchors[i] + (1-values[i]) * xanchors[(i+1)%length] 
     1366                yanchors[i] = values[i] * yanchors[i] + (1-values[i]) * yanchors[(i+1)%length] 
    13181367            else: 
    1319                 xanchors[i] = (1-values[i]) * XAnchors[i] + values[i] * XAnchors[(i+1)%length] 
    1320                 yanchors[i] = (1-values[i]) * YAnchors[i] + values[i] * YAnchors[(i+1)%length] 
     1368                xanchors[i] = (1-values[i]) * xanchors[i] + values[i] * xanchors[(i+1)%length] 
     1369                yanchors[i] = (1-values[i]) * yanchors[i] + values[i] * yanchors[(i+1)%length] 
    13211370 
    13221371        x_positions = numpy.sum(numpy.dot(xanchors, values), axis=0) / float(s) 
     
    14711520 
    14721521    @deprecated_keywords({"attrIndices": "attr_indices", 
    1473                           "settingsDict": "settings_dict"}) 
     1522                          "settingsDict": "settings_dict", 
     1523                          "validData": "valid_data", 
     1524                          "classList": "class_list", 
     1525                          "jutterSize": "jitter_size"}) 
    14741526    def create_projection_as_numeric_array(self, attr_indices, **settings_dict): 
    1475         validData = settings_dict.get("validData") 
    1476         classList = settings_dict.get("classList") 
    1477         jitterSize = settings_dict.get("jitter_size", 0.0) 
    1478  
    1479         if validData == None: 
    1480             validData = self.get_valid_list(attr_indices) 
    1481         if sum(validData) == 0: 
     1527        valid_data = settings_dict.get("valid_data") 
     1528        class_list = settings_dict.get("class_list") 
     1529        jitter_size = settings_dict.get("jitter_size", 0.0) 
     1530 
     1531        if valid_data == None: 
     1532            valid_data = self.get_valid_list(attr_indices) 
     1533        if sum(valid_data) == 0: 
    14821534            return None 
    14831535 
    1484         if classList == None and self.data_has_class: 
    1485             classList = self.original_data[self.data_class_index] 
    1486  
    1487         xArray = self.no_jittering_scaled_data[attr_indices[0]] 
    1488         yArray = self.no_jittering_scaled_data[attr_indices[1]] 
    1489         if jitterSize > 0.0: 
    1490             xArray += (numpy.random.random(len(xArray))-0.5)*jitterSize 
    1491             yArray += (numpy.random.random(len(yArray))-0.5)*jitterSize 
    1492         if classList != None: 
    1493             data = numpy.compress(validData, numpy.array((xArray, yArray, classList)), axis = 1) 
    1494         else: 
    1495             data = numpy.compress(validData, numpy.array((xArray, yArray)), axis = 1) 
     1536        if class_list == None and self.data_has_class: 
     1537            class_list = self.original_data[self.data_class_index] 
     1538 
     1539        xarray = self.no_jittering_scaled_data[attr_indices[0]] 
     1540        yarray = self.no_jittering_scaled_data[attr_indices[1]] 
     1541        if jitter_size > 0.0: 
     1542            xarray += (numpy.random.random(len(xarray))-0.5)*jitter_size 
     1543            yarray += (numpy.random.random(len(yarray))-0.5)*jitter_size 
     1544        if class_list != None: 
     1545            data = numpy.compress(valid_data, numpy.array((xarray, yarray, class_list)), axis = 1) 
     1546        else: 
     1547            data = numpy.compress(valid_data, numpy.array((xarray, yarray)), axis = 1) 
    14961548        data = numpy.transpose(data) 
    14971549        return data 
     
    15001552 
    15011553    @deprecated_keywords({"attrIndices": "attr_indices", 
    1502                           "settingsDict": "settings_dict"}) 
     1554                          "settingsDict": "settings_dict", 
     1555                          "validData": "valid_data", 
     1556                          "classList": "class_list", 
     1557                          "jutterSize": "jitter_size"}) 
    15031558    def create_projection_as_numeric_array_3D(self, attr_indices, **settings_dict): 
    1504         validData = settings_dict.get("validData") 
    1505         classList = settings_dict.get("classList") 
    1506         jitterSize = settings_dict.get("jitter_size", 0.0) 
    1507  
    1508         if validData == None: 
    1509             validData = self.get_valid_list(attr_indices) 
    1510         if sum(validData) == 0: 
     1559        valid_data = settings_dict.get("valid_data") 
     1560        class_list = settings_dict.get("class_list") 
     1561        jitter_size = settings_dict.get("jitter_size", 0.0) 
     1562 
     1563        if valid_data == None: 
     1564            valid_data = self.get_valid_list(attr_indices) 
     1565        if sum(valid_data) == 0: 
    15111566            return None 
    15121567 
    1513         if classList == None and self.data_has_class: 
    1514             classList = self.original_data[self.data_class_index] 
    1515  
    1516         xArray = self.no_jittering_scaled_data[attr_indices[0]] 
    1517         yArray = self.no_jittering_scaled_data[attr_indices[1]] 
    1518         zArray = self.no_jittering_scaled_data[attr_indices[2]] 
    1519         if jitterSize > 0.0: 
    1520             xArray += (numpy.random.random(len(xArray))-0.5)*jitterSize 
    1521             yArray += (numpy.random.random(len(yArray))-0.5)*jitterSize 
    1522             zArray += (numpy.random.random(len(zArray))-0.5)*jitterSize 
    1523         if classList != None: 
    1524             data = numpy.compress(validData, numpy.array((xArray, yArray, zArray, classList)), axis = 1) 
    1525         else: 
    1526             data = numpy.compress(validData, numpy.array((xArray, yArray, zArray)), axis = 1) 
     1568        if class_list == None and self.data_has_class: 
     1569            class_list = self.original_data[self.data_class_index] 
     1570 
     1571        xarray = self.no_jittering_scaled_data[attr_indices[0]] 
     1572        yarray = self.no_jittering_scaled_data[attr_indices[1]] 
     1573        zarray = self.no_jittering_scaled_data[attr_indices[2]] 
     1574        if jitter_size > 0.0: 
     1575            xarray += (numpy.random.random(len(xarray))-0.5)*jitter_size 
     1576            yarray += (numpy.random.random(len(yarray))-0.5)*jitter_size 
     1577            zarray += (numpy.random.random(len(zarray))-0.5)*jitter_size 
     1578        if class_list != None: 
     1579            data = numpy.compress(valid_data, numpy.array((xarray, yarray, zarray, class_list)), axis = 1) 
     1580        else: 
     1581            data = numpy.compress(valid_data, numpy.array((xarray, yarray, zarray)), axis = 1) 
    15271582        data = numpy.transpose(data) 
    15281583        return data 
     
    15431598        # init again, in case that the attribute ordering took too much time 
    15441599        self.scatterWidget.progressBarInit() 
    1545         startTime = time.time() 
     1600        start_time = time.time() 
    15461601        count = len(attribute_name_order)*(len(attribute_name_order)-1)/2 
    1547         testIndex = 0 
     1602        test_index = 0 
    15481603 
    15491604        for i in range(len(attribute_name_order)): 
     
    15521607                    attr1 = self.attribute_name_index[attribute_name_order[j]] 
    15531608                    attr2 = self.attribute_name_index[attribute_name_order[i]] 
    1554                     testIndex += 1 
     1609                    test_index += 1 
    15551610                    if self.clusterOptimization.isOptimizationCanceled(): 
    1556                         secs = time.time() - startTime 
     1611                        secs = time.time() - start_time 
    15571612                        self.clusterOptimization.setStatusBarText("Evaluation stopped (evaluated %d projections in %d min, %d sec)" 
    1558                                                                   % (testIndex, secs/60, secs%60)) 
     1613                                                                  % (test_index, secs/60, secs%60)) 
    15591614                        self.scatterWidget.progressBarFinished() 
    15601615                        return 
     
    15631618                                                                   domain = domain, 
    15641619                                                                   jitter_size = jitter_size) 
    1565                     graph, valueDict, closureDict, polygonVerticesDict, enlargedClosureDict, otherDict = self.clusterOptimization.evaluateClusters(data) 
    1566  
    1567                     allValue = 0.0 
    1568                     classesDict = {} 
    1569                     for key in valueDict.keys(): 
    1570                         add_result_funct(valueDict[key], closureDict[key], 
    1571                                          polygonVerticesDict[key], 
     1620                    graph, valuedict, closuredict, polygon_vertices_dict, enlarged_closure_dict, other_dict = self.clusterOptimization.evaluateClusters(data) 
     1621 
     1622                    all_value = 0.0 
     1623                    classes_dict = {} 
     1624                    for key in valuedict.keys(): 
     1625                        add_result_funct(valuedict[key], closuredict[key], 
     1626                                         polygon_vertices_dict[key], 
    15721627                                         [attribute_name_order[i], 
    15731628                                          attribute_name_order[j]], 
    1574                                           int(graph.objects[polygonVerticesDict[key][0]].getclass()), 
    1575                                           enlargedClosureDict[key], otherDict[key]) 
    1576                         classesDict[key] = int(graph.objects[polygonVerticesDict[key][0]].getclass()) 
    1577                         allValue += valueDict[key] 
    1578                     add_result_funct(allValue, closureDict, polygonVerticesDict, 
     1629                                          int(graph.objects[polygon_vertices_dict[key][0]].getclass()), 
     1630                                          enlarged_closure_dict[key], other_dict[key]) 
     1631                        classes_dict[key] = int(graph.objects[polygon_vertices_dict[key][0]].getclass()) 
     1632                        all_value += valuedict[key] 
     1633                    add_result_funct(all_value, closuredict, polygon_vertices_dict, 
    15791634                                     [attribute_name_order[i], attribute_name_order[j]], 
    1580                                      classesDict, enlargedClosureDict, otherDict)     # add all the clusters 
     1635                                     classes_dict, enlarged_closure_dict, other_dict)     # add all the clusters 
    15811636                     
    15821637                    self.clusterOptimization.setStatusBarText("Evaluated %d projections..." 
    1583                                                               % (testIndex)) 
    1584                     self.scatterWidget.progressBarSet(100.0*testIndex/float(count)) 
    1585                     del data, graph, valueDict, closureDict, polygonVerticesDict, enlargedClosureDict, otherDict, classesDict 
     1638                                                              % (test_index)) 
     1639                    self.scatterWidget.progressBarSet(100.0*test_index/float(count)) 
     1640                    del data, graph, valuedict, closuredict, polygon_vertices_dict, enlarged_closure_dict, other_dict, classes_dict 
    15861641                except: 
    15871642                    type, val, traceback = sys.exc_info() 
    15881643                    sys.excepthook(type, val, traceback)  # print the exception 
    15891644         
    1590         secs = time.time() - startTime 
    1591         self.clusterOptimization.setStatusBarText("Finished evaluation (evaluated %d projections in %d min, %d sec)" % (testIndex, secs/60, secs%60)) 
     1645        secs = time.time() - start_time 
     1646        self.clusterOptimization.setStatusBarText("Finished evaluation (evaluated %d projections in %d min, %d sec)" % (test_index, secs/60, secs%60)) 
    15921647        self.scatterWidget.progressBarFinished() 
    15931648     
  • Orange/projection/linear.py

    r9916 r10475  
    1 ''' 
    2 ############################## 
    3 Linear projection (``linear``) 
    4 ############################## 
    5  
    6 .. index:: linear projection 
    7  
    8 .. index:: 
    9    single: projection; linear 
    10  
    11 This module contains the FreeViz algorithm 
    12 `(Demsar et al, 2005) <http://www.ailab.si/idamap/idamap2005/papers/12%20Demsar%20CR.pdf>`_ 
    13 [1], which finds a good two-dimensional projection of the given data, where the 
    14 quality is defined by a separation of the data from different classes and the 
    15 proximity of the instances from the same class. FreeViz would normally be used 
    16 through a widget since it is primarily a method for graphical exploration of 
    17 the data. About the only case where one would like to use this module directly 
    18 is to tests the classification aspects of the method, that is, to verify the 
    19 accuracy of the resulting kNN-like classifiers on a set of benchmark data sets. 
    20  
    21 Description of the method itself is far beyond the scope of this page. See the 
    22 above paper for the original version of the method; at the moment of writing 
    23 the method has been largely extended and not published yet, though the basic 
    24 principles are the same. 
    25  
    26 [1] Janez Demsar, Gregor Leban, Blaz Zupan: FreeViz - An Intelligent 
    27 Visualization Approach for Class-Labeled Multidimensional Data Sets, 
    28 Proceedings of IDAMAP 2005, Edinburgh.  
    29  
    30 *********************** 
    31 Projection Optimization 
    32 *********************** 
    33  
    34 .. autoclass:: Orange.projection.linear.FreeViz 
    35    :members: 
    36    :show-inheritance: 
    37    :exclude-members: attractG, attractG, autoSetParameters, cancelOptimization, 
    38       classPermutationList, classPermutationList, findProjection, 
    39       forceBalancing, forceSigma, getShownAttributeList, mirrorSymmetry, 
    40       optimizeSeparation, optimize_FAST_Separation, optimize_LDA_Separation, 
    41       optimize_SLOW_Separation, radialAnchors, randomAnchors, repelG, 
    42       s2nMixAnchors, s2nMixData, s2nPlaceAttributes, s2nSpread, 
    43       setStatusBarText, showAllAttributes, stepsBeforeUpdate, 
    44       useGeneralizedEigenvectors 
    45  
    46 ********************** 
    47 Learner and Classifier 
    48 ********************** 
    49  
    50 .. autoclass:: Orange.projection.linear.FreeVizLearner 
    51    :members: 
    52    :show-inheritance: 
    53  
    54 .. autoclass:: Orange.projection.linear.FreeVizClassifier 
    55    :members: 
    56    :show-inheritance: 
    57  
    58 .. autoclass:: Orange.projection.linear.S2NHeuristicLearner 
    59    :members: 
    60    :show-inheritance: 
    61  
    62 ''' 
    63  
     1#TODO: eliminate create_pls_projection (transform into a class) 
     2#TODO: Projector as a preprocessor 
    643 
    654import Orange 
     
    698import numpy 
    709 
    71 from numpy.linalg import inv, pinv, eig      # matrix inverse and eigenvectors 
    7210from Orange.preprocess.scaling import ScaleLinProjData 
    7311from Orange.orng import orngVisFuncts as visfuncts 
     
    11048    """ 
    11149    Contains an easy-to-use interface to the core of the method, which is 
    112     written in C++. 
     50    written in C++. Differs from other linear projection optimizers in that it itself can store the data 
     51    to make iterative optimization and visualization possible. It can, however, still be used as any other 
     52    projection optimizer by calling (:obj:`~Orange.projection.linear.FreeViz.__call__`) it. 
    11353     
    11454    .. attribute:: attract_g 
     
    184124                          1000] 
    185125 
     126    def __call__(self, dataset=None): 
     127        """ 
     128        Perform FreeViz optimization on the dataset, if given, and return a resulting 
     129        linear :class:`~Orange.projection.linear.Projector`. If no dataset is given, 
     130        the projection currently stored within the FreeViz object is returned as 
     131        a :class:`~Orange.projection.linear.Projector`. 
     132 
     133        :param dataset: input data set. 
     134        :type dataset: :class:`Orange.data.Table` 
     135 
     136        :rtype: :class:`~Orange.projection.linear.Projector` 
     137        """ 
     138        if dataset: 
     139            self.graph.setData(dataset) 
     140            self.show_all_attributes() 
     141 
     142            self.radial_anchors() 
     143            self.optimize_separation() 
     144 
     145            X = dataset.to_numpy_MA("a")[0] 
     146            Xm = numpy.mean(X, axis=0) 
     147            Xd = X - Xm 
     148            stdev = numpy.std(Xd, axis=0) 
     149        else: 
     150            Xm = numpy.zeros(len(self.graph.anchor_data)) 
     151            stdev = None 
     152 
     153        graph = self.graph 
     154 
     155        U = numpy.array([val[:2] for val in self.graph.anchor_data]).T 
     156 
     157        domain = graph.data_domain 
     158        if len(domain) > len(self.graph.anchor_data): 
     159            domain = Orange.data.Domain([graph.data_domain[a] 
     160                                         for _,_,a in self.graph.anchor_data], 
     161                graph.data_domain.class_var) 
     162 
     163        return Orange.projection.linear.Projector(input_domain = domain, 
     164            mean = Xm, 
     165            stdev = stdev, 
     166            standardize = False, 
     167            projection = U) 
     168 
     169 
    186170    def clear_data(self): 
    187171        self.s2n_mix_data = None 
     
    196180 
    197181    def show_all_attributes(self): 
    198         self.graph.anchorData = [(0,0, a.name) 
    199                                  for a in self.graph.dataDomain.attributes] 
     182        self.graph.anchor_data = [(0,0, a.name) 
     183                                 for a in self.graph.data_domain.attributes] 
    200184        self.radial_anchors() 
    201185         
     
    203187 
    204188    def get_shown_attribute_list(self): 
    205         return [anchor[2] for anchor in self.graph.anchorData] 
     189        return [anchor[2] for anchor in self.graph.anchor_data] 
    206190 
    207191    getShownAttributeList = get_shown_attribute_list 
     
    216200        if not attr_list: 
    217201            return 
    218         if "3d" in self.parentName.lower(): 
     202        if hasattr(self, "parentName") and "3d" in self.parentName.lower(): 
    219203            self.graph.anchor_data = self.graph.create_anchors(len(attr_list), attr_list) 
    220204            return 
    221205        phi = 2*math.pi/len(attr_list) 
    222         self.graph.anchorData = [(math.cos(i*phi), math.sin(i*phi), a) 
     206        self.graph.anchor_data = [(math.cos(i*phi), math.sin(i*phi), a) 
    223207                                 for i, a in enumerate(attr_list)] 
    224208 
     
    230214         
    231215        """ 
    232         if not self.graph.haveData: 
     216        if not self.graph.have_data: 
    233217            return 
    234218        attr_list = self.get_shown_attribute_list() 
     
    269253                anchors = [(x[0]/maxdist, x[1]/maxdist, x[2]/maxdist, x[3]) for x in anchors] 
    270254 
    271             self.graph.anchorData = anchors 
     255            self.graph.anchor_data = anchors 
    272256            return 
    273257 
     
    299283            pass 
    300284 
    301         self.graph.anchorData = anchors 
     285        self.graph.anchor_data = anchors 
    302286 
    303287    randomAnchors = random_anchors 
     
    319303        """ 
    320304        # check if we have data and a discrete class 
    321         if (not self.graph.haveData or len(self.graph.rawData) == 0 
    322             or not (self.graph.dataHasClass or distances)): 
     305        if (not self.graph.have_data or len(self.graph.raw_data) == 0 
     306            or not (self.graph.data_has_class or distances)): 
    323307            return 
    324         ai = self.graph.attributeNameIndex 
     308        ai = self.graph.attribute_name_index 
    325309        attr_indices = [ai[label] for label in self.get_shown_attribute_list()] 
    326310        if not attr_indices: return 
     
    352336                    if self.__class__ != FreeViz and self.cancel_optimization == 1: 
    353337                        return 
    354                     self.graph.anchorData, (xanchors, yanchors, zanchors) = impl(attr_indices, 
    355                                                                                  self.graph.anchorData, 
     338                    self.graph.anchor_data, (xanchors, yanchors, zanchors) = impl(attr_indices, 
     339                                                                                 self.graph.anchor_data, 
    356340                                                                                 xanchors, 
    357341                                                                                 yanchors, 
     
    364348                    if self.__class__ != FreeViz and self.cancel_optimization == 1: 
    365349                        return 
    366                     self.graph.anchorData, (xanchors, yanchors) = impl(attr_indices, 
    367                                                                        self.graph.anchorData, 
     350                    self.graph.anchor_data, (xanchors, yanchors) = impl(attr_indices, 
     351                                                                       self.graph.anchor_data, 
    368352                                                                       xanchors, 
    369353                                                                       yanchors) 
     
    377361        optimizer = [orangeom.optimizeAnchors, orangeom.optimizeAnchorsRadial, 
    378362                     orangeom.optimizeAnchorsR][self.restrain] 
    379         ai = self.graph.attributeNameIndex 
     363        ai = self.graph.attribute_name_index 
    380364        attr_indices = [ai[label] for label in self.get_shown_attribute_list()] 
    381365        if not attr_indices: return 
    382366 
    383367        # repeat until less than 1% energy decrease in 5 consecutive iterations*steps steps 
    384         positions = [numpy.array([x[:2] for x in self.graph.anchorData])] 
     368        positions = [numpy.array([x[:2] for x in self.graph.anchor_data])] 
    385369        needed_steps = 0 
    386370 
    387         valid_data = self.graph.getValidList(attr_indices) 
     371        valid_data = self.graph.get_valid_list(attr_indices) 
    388372        n_valid = sum(valid_data)  
    389373        if not n_valid: 
    390374            return 0 
    391375 
    392         data = numpy.compress(valid_data, self.graph.noJitteringScaledData, 
     376        data = numpy.compress(valid_data, self.graph.no_jittering_scaled_data, 
    393377                              axis=1) 
    394378        data = numpy.transpose(data).tolist() 
     
    412396        else: 
    413397            classes = numpy.compress(valid_data, 
    414                                      self.graph.originalData[self.graph.dataClassIndex]).tolist() 
     398                                     self.graph.original_data[self.graph.data_class_index]).tolist() 
    415399        while 1: 
    416             self.graph.anchorData = optimizer(data, classes, 
    417                                               self.graph.anchorData, 
     400            self.graph.anchor_data = optimizer(data, classes, 
     401                                              self.graph.anchor_data, 
    418402                                              attr_indices, 
    419403                                              attractG = self.attract_g, 
     
    423407                                              dynamicBalancing = self.force_balancing, 
    424408                                              steps = steps, 
    425                                               normalizeExamples = self.graph.normalizeExamples, 
     409                                              normalizeExamples = self.graph.normalize_examples, 
    426410                                              contClass = 2 if distances 
    427                                               else self.graph.dataHasContinuousClass, 
     411                                              else self.graph.data_has_continuous_class, 
    428412                                              mirrorSymmetry = self.mirror_symmetry) 
    429413            needed_steps += steps 
     
    433417 
    434418            if hasattr(self.graph, "updateData"): 
    435                 self.graph.potentialsBmp = None 
     419                self.graph.potentials_emp = None 
    436420                self.graph.updateData() 
    437421 
    438422            positions = positions[-49:]+[numpy.array([x[:2] for x 
    439                                                       in self.graph.anchorData])] 
     423                                                      in self.graph.anchor_data])] 
    440424            if len(positions)==50: 
    441425                m = max(numpy.sum((positions[0]-positions[49])**2), 0) 
     
    453437                          "YAnchors": "yanchors"}) 
    454438    def optimize_lda_separation(self, attr_indices, anchor_data, xanchors = None, yanchors = None): 
    455         if (not self.graph.haveData or len(self.graph.rawData) == 0 
    456             or not self.graph.dataHasDiscreteClass):  
     439        if (not self.graph.have_data or len(self.graph.raw_data) == 0 
     440            or not self.graph.data_has_discrete_class):  
    457441            return anchor_data, (xanchors, yanchors) 
    458         class_count = len(self.graph.dataDomain.classVar.values) 
    459         valid_data = self.graph.getValidList(attr_indices) 
     442        class_count = len(self.graph.data_domain.classVar.values) 
     443        valid_data = self.graph.get_valid_list(attr_indices) 
    460444        selected_data = numpy.compress(valid_data, 
    461                                        numpy.take(self.graph.noJitteringScaledData, 
     445                                       numpy.take(self.graph.no_jittering_scaled_data, 
    462446                                                  attr_indices, axis = 0), 
    463447                                       axis = 1) 
     
    468452            yanchors = numpy.array([a[1] for a in anchor_data], numpy.float) 
    469453 
    470         trans_proj_data = self.graph.createProjectionAsNumericArray(attr_indices, 
    471                                                                     valid_data = valid_data, 
     454        trans_proj_data = self.graph.create_projection_as_numeric_array(attr_indices, 
     455                                                                    validData = valid_data, 
    472456                                                                    xanchors = xanchors, 
    473457                                                                    yanchors = yanchors, 
    474                                                                     scaleFactor = self.graph.scaleFactor, 
    475                                                                     normalize = self.graph.normalizeExamples, 
     458                                                                    scaleFactor = self.graph.scale_factor, 
     459                                                                    normalize = self.graph.normalize_examples, 
    476460                                                                    useAnchorData = 1) 
    477461        if trans_proj_data == None: 
     
    580564                          "YAnchors": "yanchors"}) 
    581565    def optimize_slow_separation(self, attr_indices, anchor_data, xanchors = None, yanchors = None): 
    582         if (not self.graph.haveData or len(self.graph.rawData) == 0 
    583             or not self.graph.dataHasDiscreteClass):  
     566        if (not self.graph.have_data or len(self.graph.raw_data) == 0 
     567            or not self.graph.data_has_discrete_class):  
    584568            return anchor_data, (xanchors, yanchors) 
    585         valid_data = self.graph.getValidList(attr_indices) 
    586         selected_data = numpy.compress(valid_data, numpy.take(self.graph.noJitteringScaledData, 
     569        valid_data = self.graph.get_valid_list(attr_indices) 
     570        selected_data = numpy.compress(valid_data, numpy.take(self.graph.no_jittering_scaled_data, 
    587571                                                              attr_indices, 
    588572                                                              axis = 0), 
     
    594578            yanchors = numpy.array([a[1] for a in anchor_data], numpy.float) 
    595579 
    596         trans_proj_data = self.graph.createProjectionAsNumericArray(attr_indices, 
    597                                                                     valid_data = valid_data, 
     580        trans_proj_data = self.graph.create_projection_as_numeric_array(attr_indices, 
     581                                                                    validData = valid_data, 
    598582                                                                    xanchors = xanchors, 
    599583                                                                    yanchors = yanchors, 
    600                                                                     scaleFactor = self.graph.scaleFactor, 
    601                                                                     normalize = self.graph.normalizeExamples, 
     584                                                                    scaleFactor = self.graph.scale_factor, 
     585                                                                    normalize = self.graph.normalize_examples, 
    602586                                                                    useAnchorData = 1) 
    603587        if trans_proj_data == None: 
     
    660644                          "YAnchors": "yanchors"}) 
    661645    def optimize_lda_separation_3D(self, attr_indices, anchor_data, xanchors = None, yanchors = None, zanchors = None): 
    662         if (not self.graph.haveData or len(self.graph.rawData) == 0 
    663             or not self.graph.dataHasDiscreteClass):  
     646        if (not self.graph.have_data or len(self.graph.raw_data) == 0 
     647            or not self.graph.data_has_discrete_class):  
    664648            return anchor_data, (xanchors, yanchors, zanchors) 
    665         class_count = len(self.graph.dataDomain.classVar.values) 
    666         valid_data = self.graph.getValidList(attr_indices) 
     649        class_count = len(self.graph.data_domain.classVar.values) 
     650        valid_data = self.graph.get_valid_list(attr_indices) 
    667651        selected_data = numpy.compress(valid_data, 
    668                                        numpy.take(self.graph.noJitteringScaledData, 
     652                                       numpy.take(self.graph.no_jittering_scaled_data, 
    669653                                                  attr_indices, axis = 0), 
    670654                                       axis = 1) 
     
    677661            zanchors = numpy.array([a[2] for a in anchor_data], numpy.float) 
    678662 
    679         trans_proj_data = self.graph.createProjectionAsNumericArray(attr_indices, 
    680                                                                     valid_data = valid_data, 
     663        trans_proj_data = self.graph.create_projection_as_numeric_array(attr_indices, 
     664                                                                    validData = valid_data, 
    681665                                                                    xanchors = xanchors, 
    682666                                                                    yanchors = yanchors, 
    683667                                                                    zanchors = zanchors, 
    684                                                                     scaleFactor = self.graph.scaleFactor, 
    685                                                                     normalize = self.graph.normalizeExamples, 
     668                                                                    scaleFactor = self.graph.scale_factor, 
     669                                                                    normalize = self.graph.normalize_examples, 
    686670                                                                    useAnchorData = 1) 
    687671        if trans_proj_data == None: 
     
    796780                          "YAnchors": "yanchors"}) 
    797781    def optimize_slow_separation_3D(self, attr_indices, anchor_data, xanchors = None, yanchors = None, zanchors = None): 
    798         if (not self.graph.haveData or len(self.graph.rawData) == 0 
    799             or not self.graph.dataHasDiscreteClass):  
     782        if (not self.graph.have_data or len(self.graph.raw_data) == 0 
     783            or not self.graph.data_has_discrete_class):  
    800784            return anchor_data, (xanchors, yanchors, zanchors) 
    801         valid_data = self.graph.getValidList(attr_indices) 
    802         selected_data = numpy.compress(valid_data, numpy.take(self.graph.noJitteringScaledData, 
     785        valid_data = self.graph.get_valid_list(attr_indices) 
     786        selected_data = numpy.compress(valid_data, numpy.take(self.graph.no_jittering_scaled_data, 
    803787                                                              attr_indices, 
    804788                                                              axis = 0), 
     
    812796            zanchors = numpy.array([a[2] for a in anchor_data], numpy.float) 
    813797 
    814         trans_proj_data = self.graph.createProjectionAsNumericArray(attr_indices, 
    815                                                                     valid_data = valid_data, 
     798        trans_proj_data = self.graph.create_projection_as_numeric_array(attr_indices, 
     799                                                                    validData = valid_data, 
    816800                                                                    XAnchors = xanchors, 
    817801                                                                    YAnchors = yanchors, 
    818802                                                                    ZAnchors = zanchors, 
    819                                                                     scaleFactor = self.graph.scaleFactor, 
    820                                                                     normalize = self.graph.normalizeExamples, 
     803                                                                    scaleFactor = self.graph.scale_factor, 
     804                                                                    normalize = self.graph.normalize_examples, 
    821805                                                                    useAnchorData = 1) 
    822806        if trans_proj_data == None: 
     
    898882    def s2n_mix_anchors(self, set_attribute_list_in_radviz = 1): 
    899883        # check if we have data and a discrete class 
    900         if (not self.graph.haveData or len(self.graph.rawData) == 0 
    901             or not self.graph.dataHasDiscreteClass):  
     884        if (not self.graph.have_data or len(self.graph.raw_data) == 0 
     885            or not self.graph.data_has_discrete_class):  
    902886            self.set_statusbar_text("S2N only works on data with a discrete class value") 
    903887            return 
     
    905889        # compute the quality of attributes only once 
    906890        if self.s2n_mix_data == None: 
    907             ranked_attrs, ranked_attrs_by_class = visfuncts.findAttributeGroupsForRadviz(self.graph.rawData, 
     891            ranked_attrs, ranked_attrs_by_class = visfuncts.findAttributeGroupsForRadviz(self.graph.raw_data, 
    908892                                                                                         visfuncts.S2NMeasureMix()) 
    909893            self.s2n_mix_data = (ranked_attrs, ranked_attrs_by_class) 
     
    939923 
    940924        anchor_data = anchor_data[(len(attrs)/(2*class_count)):] + anchor_data[:(len(attrs)/(2*class_count))] 
    941         self.graph.anchorData = anchor_data 
     925        self.graph.anchor_data = anchor_data 
    942926        attrNames = [anchor[2] for anchor in anchor_data] 
    943927 
     
    956940                          "percentDataUsed": "percent_data_used"}) 
    957941    def find_projection(self, method, attr_indices = None, set_anchors = 0, percent_data_used = 100): 
    958         if not self.graph.haveData: return 
    959         ai = self.graph.attributeNameIndex 
     942        if not self.graph.have_data: return 
     943        ai = self.graph.attribute_name_index 
    960944        if attr_indices == None: 
    961945            attributes = self.get_shown_attribute_list() 
     
    963947        if len(attr_indices) == 0: return None 
    964948 
    965         valid_data = self.graph.getValidList(attr_indices) 
     949        valid_data = self.graph.get_valid_list(attr_indices) 
    966950        if sum(valid_data) == 0: return None 
    967951 
    968         data_matrix = numpy.compress(valid_data, numpy.take(self.graph.noJitteringScaledData, 
     952        data_matrix = numpy.compress(valid_data, numpy.take(self.graph.no_jittering_scaled_data, 
    969953                                                            attr_indices, 
    970954                                                            axis = 0), 
    971955                                     axis = 1) 
    972         if self.graph.dataHasClass: 
     956        if self.graph.data_has_class: 
    973957            class_array = numpy.compress(valid_data, 
    974                                          self.graph.noJitteringScaledData[self.graph.dataClassIndex]) 
     958                                         self.graph.no_jittering_scaled_data[self.graph.data_class_index]) 
    975959 
    976960        if percent_data_used != 100: 
    977             indices = Orange.data.sample.SubsetIndices2(self.graph.rawData, 
     961            indices = Orange.data.sample.SubsetIndices2(self.graph.raw_data, 
    978962                                                1.0-(float(percent_data_used)/100.0)) 
    979963            try: 
     
    981965            except: 
    982966                pass 
    983             if self.graph.dataHasClass: 
     967            if self.graph.data_has_class: 
    984968                class_array = numpy.compress(indices, class_array) 
    985969 
     
    987971        vectors = None 
    988972        if method == DR_PCA: 
    989             vals, vectors = create_pca_projection(data_matrix, ncomps = ncomps, 
    990                                                   use_generalized_eigenvectors = self.use_generalized_eigenvectors) 
    991         elif method == DR_SPCA and self.graph.dataHasClass: 
    992             vals, vectors = create_pca_projection(data_matrix, class_array, 
    993                                                   ncomps = ncomps, 
    994                                                   use_generalized_eigenvectors = self.use_generalized_eigenvectors) 
    995         elif method == DR_PLS and self.graph.dataHasClass: 
     973            pca = Pca(standardize=False, max_components=ncomps, 
     974                use_generalized_eigenvectors=0) 
     975            domain = Orange.data.Domain([Orange.feature.Continuous("g%d"%i) for i 
     976                                         in xrange(len(data_matrix))], False) 
     977            pca = pca(Orange.data.Table(domain, data_matrix.T)) 
     978            vals, vectors = pca.eigen_values, pca.projection 
     979        elif method == DR_SPCA and self.graph.data_has_class: 
     980            pca = Spca(standardize=False, max_components=ncomps, 
     981                use_generalized_eigenvectors=self.use_generalized_eigenvectors) 
     982            domain = Orange.data.Domain([Orange.feature.Continuous("g%d"%i) for i 
     983                                         in xrange(len(data_matrix))], Orange.feature.Continuous("c")) 
     984            pca = pca(Orange.data.Table(domain, 
     985                numpy.hstack([data_matrix.T, numpy.array(class_array, ndmin=2).T]))) 
     986            vals, vectors = pca.eigen_values, pca.projection 
     987        elif method == DR_PLS and self.graph.data_has_class: 
    996988            data_matrix = data_matrix.transpose() 
    997989            class_matrix = numpy.transpose(numpy.matrix(class_array)) 
     
    10171009        xanchors /= m 
    10181010        yanchors /= m 
    1019         names = self.graph.attributeNames 
     1011        names = self.graph.attribute_names 
    10201012        attributes = [names[attr_indices[i]] for i in range(len(attr_indices))] 
    10211013 
    10221014        if set_anchors: 
    10231015            if ncomps == 3: 
    1024                 self.graph.setAnchors(list(xanchors), list(yanchors), list(zanchors), attributes) 
     1016                self.graph.set_anchors(list(xanchors), list(yanchors), list(zanchors), attributes) 
    10251017            else: 
    1026                 self.graph.setAnchors(list(xanchors), list(yanchors), attributes) 
    1027             self.graph.updateData() 
    1028             self.graph.repaint() 
     1018                self.graph.set_anchors(list(xanchors), list(yanchors), attributes) 
     1019            if hasattr(self.graph, "updateData"): 
     1020                self.graph.updateData() 
     1021            if hasattr(self.graph, "repaint"): 
     1022                self.graph.repaint() 
    10291023 
    10301024        if ncomps == 3: 
     
    11131107createPLSProjection = create_pls_projection 
    11141108 
    1115 # if no class data is provided we create PCA projection 
    1116 # if there is class data then create SPCA projection 
     1109# ############################################################################# 
     1110# class that represents freeviz classifier 
     1111class FreeVizClassifier(Orange.classification.Classifier): 
     1112    """ 
     1113    A kNN classifier on the 2D projection of the data, optimized by FreeViz. 
     1114     
     1115    Usually the learner 
     1116    (:class:`Orange.projection.linear.FreeVizLearner`) is used to construct the 
     1117    classifier. 
     1118     
     1119    When constructing the classifier manually, the following parameters can 
     1120    be passed: 
     1121     
     1122    :param data: table of data instances to project to a 2D plane and use for 
     1123        classification. 
     1124    :type data: :class:`Orange.data.Table` 
     1125     
     1126    :param freeviz: the FreeViz algorithm instance to use to optimize the 2D 
     1127        projection. 
     1128    :type freeviz: :class:`Orange.projection.linear.FreeViz` 
     1129     
     1130    """ 
     1131     
     1132    def __init__(self, data, freeviz): 
     1133        self.freeviz = freeviz 
     1134 
     1135        if self.freeviz.__class__ != FreeViz: 
     1136            self.freeviz.parentWidget.setData(data) 
     1137            self.freeviz.parentWidget.showAllAttributes = 1 
     1138        else: 
     1139            self.freeviz.graph.set_data(data) 
     1140            self.freeviz.show_all_attributes() 
     1141 
     1142        #self.FreeViz.randomAnchors() 
     1143        self.freeviz.radial_anchors() 
     1144        self.freeviz.optimize_separation() 
     1145 
     1146        graph = self.freeviz.graph 
     1147        ai = graph.attribute_name_index 
     1148        labels = [a[2] for a in graph.anchor_data] 
     1149        indices = [ai[label] for label in labels] 
     1150 
     1151        valid_data = graph.get_valid_list(indices) 
     1152        domain = Orange.data.Domain([graph.data_domain[i].name for i in indices]+ 
     1153                               [graph.data_domain.classVar.name], 
     1154                               graph.data_domain) 
     1155        offsets = [graph.attr_values[graph.attribute_names[i]][0] 
     1156                   for i in indices] 
     1157        normalizers = [graph.get_min_max_val(i) for i in indices] 
     1158        selected_data = numpy.take(graph.original_data, indices, axis = 0) 
     1159        averages = numpy.average(numpy.compress(valid_data, selected_data, 
     1160                                                axis=1), 1) 
     1161        class_data = numpy.compress(valid_data, 
     1162                                    graph.original_data[graph.data_class_index]) 
     1163 
     1164        graph.create_projection_as_numeric_array(indices, use_anchor_data = 1, 
     1165                                             remove_missing_data = 0, 
     1166                                             valid_data = valid_data, 
     1167                                             jitter_size = -1) 
     1168        self.classifier = Orange.classification.knn.P2NN(domain, 
     1169                                      numpy.transpose(numpy.array([numpy.compress(valid_data, 
     1170                                                                                  graph.unscaled_x_positions), 
     1171                                                                   numpy.compress(valid_data, 
     1172                                                                                  graph.unscaled_y_positions), 
     1173                                                                   class_data])), 
     1174                                      graph.anchor_data, offsets, normalizers, 
     1175                                      averages, graph.normalize_examples, law=1) 
     1176 
     1177    # for a given instance run argumentation and find out to which class it most often fall 
     1178    @deprecated_keywords({"example": "instance", "returnType": "return_type"}) 
     1179    def __call__(self, instance, return_type=Orange.classification.Classifier.GetValue): 
     1180        #instance.setclass(0) 
     1181        return self.classifier(instance, return_type) 
     1182 
     1183FreeVizClassifier = deprecated_members({"FreeViz":"freeviz"})(FreeVizClassifier) 
     1184 
     1185class FreeVizLearner(Orange.classification.Learner): 
     1186    """ 
     1187    A learner that builds a :class:`FreeVizClassifier` on given data. An 
     1188    instance of :class:`FreeViz` can be passed to the constructor as a 
     1189    keyword argument :obj:`freeviz`.     
     1190 
     1191    If data instances are provided to the constructor, the learning algorithm 
     1192    is called and the resulting classifier is returned instead of the learner. 
     1193     
     1194    """ 
     1195    def __new__(cls, freeviz = None, instances = None, weight_id = 0, **argkw): 
     1196        self = Orange.classification.Learner.__new__(cls, **argkw) 
     1197        if instances: 
     1198            self.__init__(freeviz, **argkw) 
     1199            return self.__call__(instances, weight_id) 
     1200        else: 
     1201            return self 
     1202 
     1203    def __init__(self, freeviz = None): 
     1204        if not freeviz: 
     1205            freeviz = FreeViz() 
     1206        self.freeviz = freeviz 
     1207        self.name = "freeviz Learner" 
     1208 
     1209    @deprecated_keywords({"examples": "instances", "weightID": "weight_id"}) 
     1210    def __call__(self, instances, weight_id = 0): 
     1211        return FreeVizClassifier(instances, self.freeviz) 
     1212 
     1213FreeVizLearner = deprecated_members({"FreeViz":"freeviz"})(FreeVizLearner) 
     1214 
     1215 
     1216class S2NHeuristicLearner(Orange.classification.Learner): 
     1217    """ 
     1218    This class is not documented yet. 
     1219     
     1220    """ 
     1221    def __new__(cls, freeviz = None, instances = None, weight_id = 0, **argkw): 
     1222        self = Orange.classification.Learner.__new__(cls, **argkw) 
     1223        if instances: 
     1224            self.__init__(freeviz, **argkw) 
     1225            return self.__call__(instances, weight_id) 
     1226        else: 
     1227            return self 
     1228 
     1229    def __init__(self, freeviz = None): 
     1230        if not freeviz: 
     1231            freeviz = FreeViz() 
     1232        self.freeviz = freeviz 
     1233        self.name = "S2N Feature Selection Learner" 
     1234 
     1235    @deprecated_keywords({"examples": "instances", "weightID": "weight_id"}) 
     1236    def __call__(self, instances, weight_id = 0): 
     1237        return S2NHeuristicClassifier(instances, self.freeviz) 
     1238 
     1239S2NHeuristicLearner = deprecated_members({"FreeViz": 
     1240                                          "freeviz"})(S2NHeuristicLearner) 
     1241 
     1242class Projector(object): 
     1243    """ 
     1244    Stores a linear projection of data and uses it to transform any given data with matching input domain. 
     1245 
     1246    .. attribute:: input_domain 
     1247 
     1248        Domain of the data set that was used to construct principal component 
     1249        subspace. 
     1250 
     1251    .. attribute:: output_domain 
     1252 
     1253        Domain used in returned data sets. This domain has a continuous 
     1254        variable for each axis in the projected space, 
     1255        and no class variable(s). 
     1256 
     1257    .. attribute:: mean 
     1258 
     1259        Array containing means of each variable in the data set that was used 
     1260        to construct the projection. 
     1261 
     1262    .. attribute:: stdev 
     1263 
     1264        An array containing standard deviations of each variable in the data 
     1265        set that was used to construct the projection. 
     1266 
     1267    .. attribute:: standardize 
     1268 
     1269        True, if standardization was used when constructing the projection. If 
     1270        set, instances will be standardized before being projected. 
     1271 
     1272    .. attribute:: projection 
     1273 
     1274        Array containing projection (vectors that describe the 
     1275        transformation from input to output domain). 
     1276 
     1277    """ 
     1278    def __init__(self, **kwds): 
     1279        self.__dict__.update(kwds) 
     1280        if not hasattr(self, "output_domain"): 
     1281            self.output_domain = Orange.data.Domain([Orange.feature.Continuous("a.%d"%(i+1)) for i in range(len(self.projection))], False) 
     1282 
     1283 
     1284    def __call__(self, data): 
     1285        """ 
     1286        Project data. 
     1287 
     1288        :param data: input data set 
     1289        :type data: :class:`Orange.data.Table` 
     1290 
     1291        :rtype: :class:`Orange.data.Table` 
     1292        """ 
     1293        if type(data) != Orange.data.Table: 
     1294            data = Orange.data.Table([data]) 
     1295        if len(self.projection.T) != len(data.domain.features): 
     1296            data = Orange.data.Table(self.input_domain, data) 
     1297 
     1298        X = data.to_numpy_MA("a")[0] 
     1299        Xm, U = self.mean, self.projection 
     1300        n, m = X.shape 
     1301 
     1302        if m != len(self.projection.T): 
     1303            raise Orange.core.KernelException, "Invalid number of features" 
     1304 
     1305        Xd = X - Xm 
     1306 
     1307        if self.standardize: 
     1308            Xd /= self.stdev 
     1309 
     1310        self.A = numpy.ma.dot(Xd, U.T) 
     1311 
     1312        return Orange.data.Table(self.output_domain, self.A.tolist()) 
     1313 
     1314#color table for biplot 
     1315Colors = ['bo','go','yo','co','mo'] 
     1316 
     1317class Pca(object): 
     1318    """ 
     1319    Orthogonal transformation of data into a set of uncorrelated variables called 
     1320    principal components. This transformation is defined in such a way that the 
     1321    first variable has as high variance as possible. 
     1322 
     1323    If data instances are provided to the constructor, 
     1324    the optimization algorithm is called and the resulting projector 
     1325    (:class:`~Orange.projection.linear.PcaProjector`) is 
     1326    returned instead of the optimizer (instance of this class). 
     1327 
     1328    :param standardize: perform standardization of the data set. 
     1329    :type standardize: boolean 
     1330    :param max_components: maximum number of retained components. 
     1331    :type max_components: int 
     1332    :param variance_covered: percent of the variance to cover with components. 
     1333    :type variance_covered: float 
     1334    :param use_generalized_eigenvectors: use generalized eigenvectors (ie. 
     1335        multiply data matrix with inverse of its covariance matrix). 
     1336    :type use_generalized_eigenvectors: boolean 
     1337 
     1338    :rtype: :class:`~Orange.projection.linear.Pca` or 
     1339            :class:`~Orange.projection.linear.PcaProjector` 
     1340    """ 
     1341 
     1342    def __new__(cls, dataset = None, **kwds): 
     1343        optimizer = object.__new__(cls) 
     1344        optimizer.__init__(**kwds) 
     1345 
     1346        if dataset: 
     1347            return optimizer(dataset) 
     1348        else: 
     1349            return optimizer 
     1350 
     1351    def __init__(self, standardize = True, 
     1352                 max_components = 0, variance_covered = 1, 
     1353                 use_generalized_eigenvectors = 0): 
     1354        self.standardize = standardize 
     1355        self.max_components = max_components 
     1356        self.variance_covered = variance_covered if variance_covered < 1. else 1 
     1357        self.use_generalized_eigenvectors = use_generalized_eigenvectors 
     1358 
     1359    def _pca(self, dataset, Xd, Xg): 
     1360        n,m = Xd.shape 
     1361        if n < m: 
     1362            C = numpy.ma.dot(Xg.T, Xd.T) 
     1363            V, D, T = numpy.linalg.svd(C) 
     1364            U = numpy.ma.dot(V.T, Xd) / numpy.sqrt(D.reshape(-1,1)) 
     1365        else: 
     1366            C = numpy.ma.dot(Xg, Xd) 
     1367            U, D, T = numpy.linalg.svd(C) 
     1368 
     1369        U = U.T  # eigenvectors are now in rows 
     1370        return U, D 
     1371 
     1372    def __call__(self, dataset): 
     1373        """ 
     1374        Perform a PCA analysis on a data set and return a linear projector 
     1375        that maps data into principal component subspace. 
     1376 
     1377        :param dataset: input data set. 
     1378        :type dataset: :class:`Orange.data.Table` 
     1379 
     1380        :rtype: :class:`~Orange.projection.linear.PcaProjector` 
     1381        """ 
     1382 
     1383        X = dataset.to_numpy_MA("a")[0] 
     1384        N,M = X.shape 
     1385        Xm = numpy.mean(X, axis=0) 
     1386        Xd = X - Xm 
     1387 
     1388        #take care of the constant features 
     1389        stdev = numpy.std(Xd, axis=0) 
     1390        relevant_features = stdev != 0 
     1391        if self.standardize: 
     1392            stdev[stdev == 0] = 1. 
     1393            Xd /= stdev 
     1394        Xd = Xd[:,relevant_features] 
     1395 
     1396        #use generalized eigenvectors 
     1397        if self.use_generalized_eigenvectors: 
     1398            inv_covar = numpy.linalg.inv(numpy.dot(Xd.T, Xd)) 
     1399            Xg = numpy.dot(inv_covar, Xd.T) 
     1400        else: 
     1401            Xg = Xd.T 
     1402 
     1403        #actual pca 
     1404        n,m = Xd.shape 
     1405        U, D = self._pca(dataset, Xd, Xg) 
     1406 
     1407        #insert zeros for constant features 
     1408        n, m = U.shape 
     1409        if m != M: 
     1410            U_ = numpy.zeros((n,M)) 
     1411            U_[:,relevant_features] = U 
     1412            U = U_ 
     1413 
     1414        variance_sum = D.sum() 
     1415 
     1416        #select eigen vectors 
     1417        if self.variance_covered != 1: 
     1418            nfeatures = numpy.nonzero(numpy.cumsum(D) / sum(D) >= self.variance_covered)[0][0] + 1 
     1419            U = U[:nfeatures, :] 
     1420            D = D[:nfeatures] 
     1421 
     1422        if self.max_components > 0: 
     1423            U = U[:self.max_components, :] 
     1424            D = D[:self.max_components] 
     1425 
     1426        n, m = U.shape 
     1427        pc_domain = Orange.data.Domain([Orange.feature.Continuous("Comp.%d"% 
     1428                                                                  (i+1)) for i in range(n)], False) 
     1429 
     1430        return PcaProjector(input_domain = dataset.domain, 
     1431            output_domain = pc_domain, 
     1432            pc_domain = pc_domain, 
     1433            mean = Xm, 
     1434            stdev = stdev, 
     1435            standardize = self.standardize, 
     1436            eigen_vectors = U, 
     1437            projection = U, 
     1438            eigen_values = D, 
     1439            variance_sum = variance_sum) 
     1440 
     1441 
     1442class Spca(Pca): 
     1443    def _pca(self, dataset, Xd, Xg): 
     1444        # define the Laplacian matrix 
     1445        c = dataset.to_numpy("c")[0] 
     1446        l = -numpy.array(numpy.hstack( [(c != v) for v in c]), dtype='f') 
     1447        l -= numpy.diagflat(numpy.sum(l, axis=0)) 
     1448 
     1449        Xg = numpy.dot(Xg, l) 
     1450 
     1451        return Pca._pca(self, dataset, Xd, Xg) 
     1452 
     1453class PcaProjector(Projector): 
     1454    """ 
     1455    .. attribute:: pc_domain 
     1456 
     1457        Synonymous for :obj:`~Orange.projection.linear.Projector.output_domain`. 
     1458 
     1459    .. attribute:: eigen_vectors 
     1460 
     1461        Synonymous for :obj:`~Orange.projection.linear.Projector.projection`. 
     1462 
     1463    .. attribute:: eigen_values 
     1464 
     1465        Array containing standard deviations of principal components. 
     1466 
     1467    .. attribute:: variance_sum 
     1468 
     1469        Sum of all variances in the data set that was used to construct the PCA 
     1470        space. 
     1471 
     1472    """ 
     1473 
     1474    def __init__(self, **kwds): 
     1475        self.__dict__.update(kwds) 
     1476 
     1477    def __str__(self): 
     1478        ncomponents = 10 
     1479        s = self.variance_sum 
     1480        cs = numpy.cumsum(self.eigen_values) / s 
     1481        return "\n".join([ 
     1482            "PCA SUMMARY", 
     1483            "", 
     1484            "Std. deviation of components:", 
     1485            " ".join(["              "] + 
     1486                     ["%10s" % a.name for a in self.pc_domain.attributes]), 
     1487            " ".join(["Std. deviation"] + 
     1488                     ["%10.3f" % a for a in self.eigen_values]), 
     1489            " ".join(["Proportion Var"] + 
     1490                     ["%10.3f" % a for a in  self.eigen_values / s * 100]), 
     1491            " ".join(["Cumulative Var"] + 
     1492                     ["%10.3f" % a for a in cs * 100]), 
     1493            "", 
     1494            #"Loadings:", 
     1495            #" ".join(["%10s"%""] + ["%10s" % a.name for a in self.pc_domain]), 
     1496            #"\n".join([ 
     1497            #    " ".join([a.name] + ["%10.3f" % b for b in self.eigen_vectors.T[i]]) 
     1498            #          for i, a in enumerate(self.input_domain.attributes) 
     1499            #          ]) 
     1500        ]) if len(self.pc_domain) <= ncomponents else\ 
     1501        "\n".join([ 
     1502            "PCA SUMMARY", 
     1503            "", 
     1504            "Std. deviation of components:", 
     1505            " ".join(["              "] + 
     1506                     ["%10s" % a.name for a in self.pc_domain.attributes[:ncomponents]] + 
     1507                     ["%10s" % "..."] + 
     1508                     ["%10s" % self.pc_domain.attributes[-1].name]), 
     1509            " ".join(["Std. deviation"] + 
     1510                     ["%10.3f" % a for a in self.eigen_values[:ncomponents]] + 
     1511                     ["%10s" % ""] + 
     1512                     ["%10.3f" % self.eigen_values[-1]]), 
     1513            " ".join(["Proportion Var"] + 
     1514                     ["%10.3f" % a for a in self.eigen_values[:ncomponents] / s * 100] + 
     1515                     ["%10s" % ""] + 
     1516                     ["%10.3f" % (self.eigen_values[-1] / s * 100)]), 
     1517            " ".join(["Cumulative Var"] + 
     1518                     ["%10.3f" % a for a in cs[:ncomponents] * 100] + 
     1519                     ["%10s" % ""] + 
     1520                     ["%10.3f" % (cs[-1] * 100)]), 
     1521            "", 
     1522            #"Loadings:", 
     1523            #" ".join(["%16s" % ""] + 
     1524            #         ["%8s" % a.name for a in self.pc_domain.attributes[:ncomponents]] + 
     1525            #         ["%8s" % "..."] + 
     1526            #         ["%8s" % self.pc_domain.attributes[-1].name]), 
     1527            #"\n".join([ 
     1528            #    " ".join(["%16.16s" %a.name] + 
     1529            #             ["%8.3f" % b for b in self.eigen_vectors.T[i, :ncomponents]] + 
     1530            #             ["%8s" % ""] + 
     1531            #             ["%8.3f" % self.eigen_vectors.T[i, -1]]) 
     1532            #          for i, a in enumerate(self.input_domain.attributes) 
     1533            #          ]) 
     1534        ]) 
     1535 
     1536 
     1537 
     1538    ################ Plotting functions ################### 
     1539 
     1540    def scree_plot(self, filename = None, title = 'Scree plot'): 
     1541        """ 
     1542        Draw a scree plot of principal components 
     1543 
     1544        :param filename: Name of the file to which the plot will be saved. \ 
     1545        If None, plot will be displayed instead. 
     1546        :type filename: str 
     1547        :param title: Plot title 
     1548        :type title: str 
     1549        """ 
     1550        import pylab as plt 
     1551 
     1552        s = self.variance_sum 
     1553        vc = self.eigen_values / s 
     1554        cs = numpy.cumsum(self.eigen_values) / s 
     1555 
     1556        fig = plt.figure() 
     1557        ax = fig.add_subplot(111) 
     1558 
     1559        x_axis = range(len(self.eigen_values)) 
     1560        x_labels = ["PC%d" % (i + 1, ) for i in x_axis] 
     1561 
     1562        ax.set_xticks(x_axis) 
     1563        ax.set_xticklabels(x_labels) 
     1564        plt.setp(ax.get_xticklabels(), "rotation", 90) 
     1565        plt.grid(True) 
     1566 
     1567        ax.set_xlabel('Principal components') 
     1568        ax.set_ylabel('Proportion of Variance') 
     1569        ax.set_title(title + "\n") 
     1570        ax.plot(x_axis, vc, color="red") 
     1571        ax.scatter(x_axis, vc, color="red", label="Variance") 
     1572 
     1573        ax.plot(x_axis, cs, color="orange") 
     1574        ax.scatter(x_axis, cs, color="orange", label="Cumulative Variance") 
     1575        ax.legend(loc=0) 
     1576 
     1577        ax.axis([-0.5, len(self.eigen_values) - 0.5, 0, 1]) 
     1578 
     1579        if filename: 
     1580            plt.savefig(filename) 
     1581        else: 
     1582            plt.show() 
     1583 
     1584    def biplot(self, filename = None, components = [0,1], title = 'Biplot'): 
     1585        """ 
     1586        Draw biplot for PCA. Actual projection must be performed via pca(data) 
     1587        before bipot can be used. 
     1588 
     1589        :param filename: Name of the file to which the plot will be saved. \ 
     1590        If None, plot will be displayed instead. 
     1591        :type plot: str 
     1592        :param components: List of two components to plot. 
     1593        :type components: list 
     1594        :param title: Plot title 
     1595        :type title: str 
     1596        """ 
     1597        import pylab as plt 
     1598 
     1599        if len(components) < 2: 
     1600            raise orange.KernelException, 'Two components are needed for biplot' 
     1601 
     1602        if not (0 <= min(components) <= max(components) < len(self.eigen_values)): 
     1603            raise orange.KernelException, 'Invalid components' 
     1604 
     1605        X = self.A[:,components[0]] 
     1606        Y = self.A[:,components[1]] 
     1607 
     1608        vectorsX = self.eigen_vectors[:,components[0]] 
     1609        vectorsY = self.eigen_vectors[:,components[1]] 
     1610 
     1611 
     1612        #TO DO -> pc.biplot (maybe) 
     1613        #trDataMatrix = dataMatrix / lam 
     1614        #trLoadings = loadings * lam 
     1615 
     1616        #max_data_value = numpy.max(abs(trDataMatrix)) * 1.05 
     1617        max_load_value = self.eigen_vectors.max() * 1.5 
     1618 
     1619        #plt.clf() 
     1620        fig = plt.figure() 
     1621        ax1 = fig.add_subplot(111) 
     1622        ax1.set_title(title + "\n") 
     1623        ax1.set_xlabel("PC%s (%d%%)" % (components[0], self.eigen_values[components[0]] / self.variance_sum * 100)) 
     1624        ax1.set_ylabel("PC%s (%d%%)" % (components[1], self.eigen_values[components[1]] / self.variance_sum * 100)) 
     1625        ax1.xaxis.set_label_position('bottom') 
     1626        ax1.xaxis.set_ticks_position('bottom') 
     1627        ax1.yaxis.set_label_position('left') 
     1628        ax1.yaxis.set_ticks_position('left') 
     1629 
     1630        #if self._classArray == None: 
     1631        #trDataMatrix = transpose(trDataMatrix) 
     1632        ax1.plot(X, Y, Colors[0]) 
     1633        #else: 
     1634        #suboptimal 
     1635        #    classValues = [] 
     1636        #    for classValue in self._classArray: 
     1637        #        if classValue not in classValues: 
     1638        #            classValues.append(classValue) 
     1639        #    for i in range(len(classValues)): 
     1640        #        choice = numpy.array([classValues[i] == cv for cv in self._classArray]) 
     1641        #        partialDataMatrix = transpose(trDataMatrix[choice]) 
     1642        #        ax1.plot(partialDataMatrix[0], partialDataMatrix[1], 
     1643        #                 Colors[i % len(Colors)], label = str(classValues[i])) 
     1644        #    ax1.legend() 
     1645 
     1646        #ax1.set_xlim(-max_data_value, max_data_value) 
     1647        #ax1.set_ylim(-max_data_value, max_data_value) 
     1648 
     1649        #eliminate double axis on right 
     1650        ax0 = ax1.twinx() 
     1651        ax0.yaxis.set_visible(False) 
     1652 
     1653        ax2 = ax0.twiny() 
     1654        ax2.xaxis.set_label_position('top') 
     1655        ax2.xaxis.set_ticks_position('top') 
     1656        ax2.yaxis.set_label_position('right') 
     1657        ax2.yaxis.set_ticks_position('right') 
     1658        for tl in ax2.get_xticklabels(): 
     1659            tl.set_color('r') 
     1660        for tl in ax2.get_yticklabels(): 
     1661            tl.set_color('r') 
     1662 
     1663        arrowprops = dict(facecolor = 'red', edgecolor = 'red', width = 1, headwidth = 4) 
     1664 
     1665        for (x, y, a) in zip(vectorsX, vectorsY,self.input_domain.attributes): 
     1666            if max(x, y) < 0.1: 
     1667                continue 
     1668            print x, y, a 
     1669            ax2.annotate('', (x, y), (0, 0), arrowprops = arrowprops) 
     1670            ax2.text(x * 1.1, y * 1.2, a.name, color = 'red') 
     1671 
     1672        ax2.set_xlim(-max_load_value, max_load_value) 
     1673        ax2.set_ylim(-max_load_value, max_load_value) 
     1674 
     1675        if filename: 
     1676            plt.savefig(filename) 
     1677        else: 
     1678            plt.show() 
     1679 
     1680 
     1681class Fda(object): 
     1682    """ 
     1683    Construct a linear projection of data using FDA. When using this projection optimization method, data is always 
     1684    standardized prior to being projected. 
     1685 
     1686    If data instances are provided to the constructor, 
     1687    the optimization algorithm is called and the resulting projector 
     1688    (:class:`~Orange.projection.linear.FdaProjector`) is 
     1689    returned instead of the optimizer (instance of this class). 
     1690 
     1691    :rtype: :class:`~Orange.projection.linear.Fda` or 
     1692            :class:`~Orange.projection.linear.FdaProjector` 
     1693    """ 
     1694 
     1695    def __new__(cls, data = None): 
     1696        self = object.__new__(cls) 
     1697        if data: 
     1698            self.__init__() 
     1699            return self.__call__(data) 
     1700        else: 
     1701            return self 
     1702 
     1703    def __call__(self, dataset): 
     1704        """ 
     1705        Perform a FDA analysis on a data set and return a linear projector 
     1706        that maps data into another vector space. 
     1707 
     1708        :param dataset: input data set. 
     1709        :type dataset: :class:`Orange.data.Table` 
     1710 
     1711        :rtype: :class:`~Orange.projection.linear.FdaProjector` 
     1712        """ 
     1713        X, Y = dataset.to_numpy_MA("a/c") 
     1714 
     1715        Xm = numpy.mean(X, axis=0) 
     1716        X = X - Xm 
     1717 
     1718        #take care of the constant features 
     1719        stdev = numpy.std(X, axis=0) 
     1720        relevant_features = stdev != 0 
     1721        stdev[stdev == 0] = 1. 
     1722        X /= stdev 
     1723        X = X[:,relevant_features] 
     1724 
     1725        instances, features = X.shape 
     1726        class_count = len(set(Y)) 
     1727        # special case when we have two classes 
     1728        if class_count == 2: 
     1729            data1 = MA.take(X, numpy.argwhere(Y == 0).flatten(), axis=0) 
     1730            data2 = MA.take(X, numpy.argwhere(Y != 0).flatten(), axis=0) 
     1731            miDiff = MA.average(data1, axis=1) - MA.average(data2, axis=1) 
     1732            covMatrix = (MA.dot(data1.T, data1) + MA.dot(data2.T, data2)) / instances 
     1733            U = numpy.linalg.inv(covMatrix) * miDiff 
     1734            D = numpy.array([1]) 
     1735        else: 
     1736            # compute means and average covariances of examples in each class group 
     1737            Sw = MA.zeros([features, features]) 
     1738            for v in set(Y): 
     1739                d = MA.take(X, numpy.argwhere(Y == v).flatten(), axis=0) 
     1740                d = d - numpy.mean(d, axis=0) 
     1741                Sw += MA.dot(d.T, d) 
     1742            Sw /= instances 
     1743            total = MA.dot(X.T, X)/float(instances) 
     1744            Sb = total - Sw 
     1745 
     1746            matrix = numpy.linalg.inv(Sw)*Sb 
     1747            D, U = numpy.linalg.eigh(matrix) 
     1748 
     1749        sorted_indices = [i for _,i in sorted([(ev, i) 
     1750                          for i, ev in enumerate(D)], reverse=True)] 
     1751        U = numpy.take(U, sorted_indices, axis = 1) 
     1752        D = numpy.take(D, sorted_indices) 
     1753 
     1754        #insert zeros for constant features 
     1755        n, m = U.shape 
     1756        if m != M: 
     1757            U_ = numpy.zeros((n,M)) 
     1758            U_[:,relevant_features] = U 
     1759            U = U_ 
     1760 
     1761        out_domain = Orange.data.Domain([Orange.feature.Continuous("Comp.%d"% 
     1762                                                                  (i+1)) for 
     1763                                         i in range(len(D))], False) 
     1764 
     1765        return FdaProjector(input_domain = dataset.domain, 
     1766            output_domain = out_domain, 
     1767            mean = Xm, 
     1768            stdev = stdev, 
     1769            standardize = True, 
     1770            eigen_vectors = U, 
     1771            projection = U, 
     1772            eigen_values = D) 
     1773 
     1774class FdaProjector(Projector): 
     1775    """ 
     1776    .. attribute:: eigen_vectors 
     1777 
     1778        Synonymous for :obj:`~Orange.projection.linear.Projector.projection`. 
     1779 
     1780    .. attribute:: eigen_values 
     1781 
     1782        Array containing eigenvalues corresponding to eigenvectors. 
     1783 
     1784    """ 
     1785 
     1786    def __init__(self, **kwds): 
     1787        self.__dict__.update(kwds) 
     1788 
     1789 
     1790 
    11171791@deprecated_keywords({"dataMatrix": "data_matrix", 
    11181792                      "classArray": "class_array", 
     
    11201794                      "useGeneralizedEigenvectors": "use_generalized_eigenvectors"}) 
    11211795def create_pca_projection(data_matrix, class_array = None, ncomps = -1, use_generalized_eigenvectors = 1): 
     1796    import warnings 
     1797    warnings.warn("Deprecated in favour of Orange" 
     1798                  ".projection.linear.Pca.", 
     1799        DeprecationWarning) 
    11221800    if type(data_matrix) == numpy.ma.core.MaskedArray: 
    11231801        data_matrix = numpy.array(data_matrix) 
    11241802    if class_array != None and type(class_array) == numpy.ma.core.MaskedArray: 
    11251803        class_array = numpy.array(class_array) 
    1126          
     1804 
    11271805    data_matrix = numpy.transpose(data_matrix) 
    11281806 
     
    11591837    vals, vectors = eig(matrix) 
    11601838    if vals.dtype.kind == "c":       # if eigenvalues are complex numbers then do nothing 
    1161          return None, None 
     1839        return None, None 
    11621840    vals = list(vals) 
    1163      
     1841 
    11641842    if ncomps == -1: 
    11651843        ncomps = len(vals) 
    11661844    ncomps = min(ncomps, len(vals)) 
    1167      
     1845 
    11681846    ret_vals = [] 
    11691847    ret_indices = [] 
     
    11731851        ret_indices.append(bestind) 
    11741852        vals[bestind] = -1 
    1175      
     1853 
    11761854    return ret_vals, numpy.take(vectors.T, ret_indices, axis = 0)         # i-th eigenvector is the i-th column in vectors so we have to transpose the array 
    11771855 
    11781856createPCAProjection = create_pca_projection 
    1179  
    1180  
    1181 # ############################################################################# 
    1182 # class that represents freeviz classifier 
    1183 class FreeVizClassifier(Orange.classification.Classifier): 
    1184     """ 
    1185     A kNN classifier on the 2D projection of the data, optimized by FreeViz. 
    1186      
    1187     Usually the learner 
    1188     (:class:`Orange.projection.linear.FreeVizLearner`) is used to construct the 
    1189     classifier. 
    1190      
    1191     When constructing the classifier manually, the following parameters can 
    1192     be passed: 
    1193      
    1194     :param data: table of data instances to project to a 2D plane and use for 
    1195         classification. 
    1196     :type data: :class:`Orange.data.Table` 
    1197      
    1198     :param freeviz: the FreeViz algorithm instance to use to optimize the 2D 
    1199         projection. 
    1200     :type freeviz: :class:`Orange.projection.linear.FreeViz` 
    1201      
    1202     """ 
    1203      
    1204     def __init__(self, data, freeviz): 
    1205         self.freeviz = freeviz 
    1206  
    1207         if self.freeviz.__class__ != FreeViz: 
    1208             self.freeviz.parentWidget.setData(data) 
    1209             self.freeviz.parentWidget.show_all_attributes = 1 
    1210         else: 
    1211             self.freeviz.graph.setData(data) 
    1212             self.freeviz.show_all_attributes() 
    1213  
    1214         #self.FreeViz.randomAnchors() 
    1215         self.freeviz.radial_anchors() 
    1216         self.freeviz.optimize_separation() 
    1217  
    1218         graph = self.freeviz.graph 
    1219         ai = graph.attributeNameIndex 
    1220         labels = [a[2] for a in graph.anchorData] 
    1221         indices = [ai[label] for label in labels] 
    1222  
    1223         valid_data = graph.getValidList(indices) 
    1224         domain = Orange.data.Domain([graph.dataDomain[i].name for i in indices]+ 
    1225                                [graph.dataDomain.classVar.name], 
    1226                                graph.dataDomain) 
    1227         offsets = [graph.attrValues[graph.attributeNames[i]][0] 
    1228                    for i in indices] 
    1229         normalizers = [graph.getMinMaxVal(i) for i in indices] 
    1230         selected_data = numpy.take(graph.originalData, indices, axis = 0) 
    1231         averages = numpy.average(numpy.compress(valid_data, selected_data, 
    1232                                                 axis=1), 1) 
    1233         class_data = numpy.compress(valid_data, 
    1234                                     graph.originalData[graph.dataClassIndex]) 
    1235  
    1236         graph.createProjectionAsNumericArray(indices, useAnchorData = 1, 
    1237                                              removeMissingData = 0, 
    1238                                              valid_data = valid_data, 
    1239                                              jitterSize = -1) 
    1240         self.classifier = Orange.classification.knn.P2NN(domain, 
    1241                                       numpy.transpose(numpy.array([numpy.compress(valid_data, 
    1242                                                                                   graph.unscaled_x_positions), 
    1243                                                                    numpy.compress(valid_data, 
    1244                                                                                   graph.unscaled_y_positions), 
    1245                                                                    class_data])), 
    1246                                       graph.anchorData, offsets, normalizers, 
    1247                                       averages, graph.normalizeExamples, law=1) 
    1248  
    1249     # for a given instance run argumentation and find out to which class it most often fall 
    1250     @deprecated_keywords({"example": "instance", "returnType": "return_type"}) 
    1251     def __call__(self, instance, return_type=Orange.classification.Classifier.GetValue): 
    1252         #instance.setclass(0) 
    1253         return self.classifier(instance, return_type) 
    1254  
    1255 FreeVizClassifier = deprecated_members({"FreeViz":"freeviz"})(FreeVizClassifier) 
    1256  
    1257 class FreeVizLearner(Orange.classification.Learner): 
    1258     """ 
    1259     A learner that builds a :class:`FreeVizClassifier` on given data. An 
    1260     instance of :class:`FreeViz` can be passed to the constructor as a 
    1261     keyword argument :obj:`freeviz`.     
    1262  
    1263     If data instances are provided to the constructor, the learning algorithm 
    1264     is called and the resulting classifier is returned instead of the learner. 
    1265      
    1266     """ 
    1267     def __new__(cls, freeviz = None, instances = None, weight_id = 0, **argkw): 
    1268         self = Orange.classification.Learner.__new__(cls, **argkw) 
    1269         if instances: 
    1270             self.__init__(freeviz, **argkw) 
    1271             return self.__call__(instances, weight_id) 
    1272         else: 
    1273             return self 
    1274  
    1275     def __init__(self, freeviz = None): 
    1276         if not freeviz: 
    1277             freeviz = FreeViz() 
    1278         self.freeviz = freeviz 
    1279         self.name = "freeviz Learner" 
    1280  
    1281     @deprecated_keywords({"examples": "instances", "weightID": "weight_id"}) 
    1282     def __call__(self, instances, weight_id = 0): 
    1283         return FreeVizClassifier(instances, self.freeviz) 
    1284  
    1285 FreeVizLearner = deprecated_members({"FreeViz":"freeviz"})(FreeVizLearner) 
    1286  
    1287  
    1288 class S2NHeuristicLearner(Orange.classification.Learner): 
    1289     """ 
    1290     This class is not documented yet. 
    1291      
    1292     """ 
    1293     def __new__(cls, freeviz = None, instances = None, weight_id = 0, **argkw): 
    1294         self = Orange.classification.Learner.__new__(cls, **argkw) 
    1295         if instances: 
    1296             self.__init__(freeviz, **argkw) 
    1297             return self.__call__(instances, weight_id) 
    1298         else: 
    1299             return self 
    1300  
    1301     def __init__(self, freeviz = None): 
    1302         if not freeviz: 
    1303             freeviz = FreeViz() 
    1304         self.freeviz = freeviz 
    1305         self.name = "S2N Feature Selection Learner" 
    1306  
    1307     @deprecated_keywords({"examples": "instances", "weightID": "weight_id"}) 
    1308     def __call__(self, instances, weight_id = 0): 
    1309         return S2NHeuristicClassifier(instances, self.freeviz) 
    1310  
    1311 S2NHeuristicLearner = deprecated_members({"FreeViz": 
    1312                                           "freeviz"})(S2NHeuristicLearner) 
  • docs/reference/rst/Orange.projection.linear.rst

    r9372 r10475  
    11.. automodule:: Orange.projection.linear 
     2 
     3############################## 
     4Linear projection (``linear``) 
     5############################## 
     6 
     7.. index:: linear projection 
     8 
     9.. index:: 
     10   single: projection; linear 
     11 
     12Linear transformation of the data might provide a unique insight into the data through observation of the optimized 
     13projection or through visualization of the space with reduced dimensionality. 
     14 
     15This module contains the FreeViz linear projection optimization algorithm 
     16[1], PCA and FDA and utility classes for classification of instances based on 
     17kNN in the linearly transformed space. 
     18 
     19Methods in this module use given data set to optimize a linear projection of features into a new vector space. The 
     20transformation is returned as a :class:`~Orange.projection.linear.Projector` instance that, when invoked, projects 
     21any given data with the domain that matches the domain that was used to optimize the projection. 
     22 
     23.. autoclass:: Orange.projection.linear.Projector 
     24   :members: 
     25 
     26************************************* 
     27Pricipal Component Analysis (``pca``) 
     28************************************* 
     29 
     30.. index:: Pricipal Component Analysis 
     31 
     32.. index:: 
     33   single: projection, Principal Component Analysis 
     34 
     35`PCA <http://en.wikipedia.org/wiki/Principal_component_analysis>`_ uses an orthogonal transformation to transform input 
     36features into a set of uncorrelated features called principal 
     37components. This transformation is defined in such a way that the first principal component has as high variance as 
     38possible and each succeeding component in turn has the highest variance possible under constraint that it is orthogonal 
     39to the preceding components. 
     40 
     41Because PCA is sensitive to the relative scaling of the original variables, the default behaviour of PCA class is to 
     42standardize the input data. 
     43 
     44Optimizer and Projector 
     45======================= 
     46 
     47.. index:: PCA 
     48.. autoclass:: Orange.projection.linear.Pca 
     49   :members: 
     50 
     51.. autoclass:: Orange.projection.linear.PcaProjector 
     52   :members: 
     53   :show-inheritance: 
     54 
     55Examples 
     56======== 
     57 
     58The following example demonstrates a straightforward invocation of PCA 
     59(:download:`pca-run.py <code/pca-run.py>`): 
     60 
     61.. literalinclude:: code/pca-run.py 
     62   :lines: 7- 
     63 
     64The call to the Pca constructor returns an instance of PcaClassifier, which is later used to transform data to PCA 
     65feature space. Printing the classifier displays how much variance is covered with the first few components. Classifier 
     66can also be used to access transformation vectors (eigen_vectors) and variance of the pca components (eigen_values). 
     67Scree plot can be used when deciding, how many components to keep (:download:`pca-scree.py <code/pca-scree.py>`): 
     68 
     69.. literalinclude:: code/pca-scree.py 
     70   :lines: 7- 
     71 
     72.. image:: files/pca-scree.png 
     73   :scale: 50 % 
     74 
     75 
     76.. index:: Fisher Discriminant Analysis 
     77 
     78.. index:: 
     79   single: projection, Fisher Discriminant Analysis 
     80 
     81************************************** 
     82Fisher discriminant analysis (``fda``) 
     83************************************** 
     84 
     85As a variant of LDA (Linear Discriminant Analysis), 
     86`FDA <http://en.wikipedia.org/wiki/Linear_discriminant_analysis#Fisher.27s_linear_discriminant>`_ finds 
     87a linear combination of features 
     88that separates two or more classes best. 
     89 
     90Optimizer and Projector 
     91======================= 
     92 
     93.. index:: FDA 
     94.. autoclass:: Orange.projection.linear.Fda 
     95   :members: 
     96 
     97.. autoclass:: Orange.projection.linear.FdaProjector 
     98   :members: 
     99   :show-inheritance: 
     100 
     101******* 
     102FreeViz 
     103******* 
     104 
     105Freeviz 
     106`(Demsar et al, 2005) <http://www.ailab.si/idamap/idamap2005/papers/12%20Demsar%20CR.pdf>`_ 
     107is a method that 
     108finds a good two-dimensional linear projection of the given data, where the 
     109quality is defined by a separation of the data from different classes and the 
     110proximity of the instances from the same class. FreeViz would normally be used 
     111through a widget since it is primarily a method for graphical exploration of 
     112the data. About the only case where one would like to use this module directly 
     113is to tests the classification aspects of the method, that is, to verify the 
     114accuracy of the resulting kNN-like classifiers on a set of benchmark data sets. 
     115 
     116Description of the method itself is far beyond the scope of this page. See the 
     117above paper for the original version of the method; at the moment of writing 
     118the method has been largely extended and not published yet, though the basic 
     119principles are the same. 
     120 
     121[1] Janez Demsar, Gregor Leban, Blaz Zupan: FreeViz - An Intelligent 
     122Visualization Approach for Class-Labeled Multidimensional Data Sets, 
     123Proceedings of IDAMAP 2005, Edinburgh. 
     124 
     125.. autoclass:: Orange.projection.linear.FreeViz 
     126   :members: 
     127   :show-inheritance: 
     128   :exclude-members: attractG, attractG, autoSetParameters, cancelOptimization, 
     129      classPermutationList, classPermutationList, findProjection, 
     130      forceBalancing, forceSigma, getShownAttributeList, mirrorSymmetry, 
     131      optimizeSeparation, optimize_FAST_Separation, optimize_LDA_Separation, 
     132      optimize_SLOW_Separation, radialAnchors, randomAnchors, repelG, 
     133      s2nMixAnchors, s2nMixData, s2nPlaceAttributes, s2nSpread, 
     134      setStatusBarText, showAllAttributes, stepsBeforeUpdate, 
     135      useGeneralizedEigenvectors 
     136 
     137:class:`~Orange.projection.linear.FreeViz` can be used in code to optimize 
     138a linear projection to two dimensions: 
     139 
     140.. literalinclude:: code/freeviz-projector.py 
     141   :lines: 7- 
     142 
     143Learner and Classifier 
     144====================== 
     145 
     146.. autoclass:: Orange.projection.linear.FreeVizLearner 
     147   :members: 
     148   :show-inheritance: 
     149 
     150.. autoclass:: Orange.projection.linear.FreeVizClassifier 
     151   :members: 
     152   :show-inheritance: 
     153 
     154.. autoclass:: Orange.projection.linear.S2NHeuristicLearner 
     155   :members: 
     156   :show-inheritance: 
  • docs/reference/rst/Orange.projection.rst

    r9372 r10475  
    88   Orange.projection.linear 
    99   Orange.projection.mds 
    10    Orange.projection.pca 
    1110   Orange.projection.som 
    1211   Orange.projection.correspondence 
  • docs/reference/rst/code/pca-run.py

    r9372 r10475  
    88iris = Orange.data.Table("iris.tab") 
    99 
    10 pca = Orange.projection.pca.Pca(iris) 
     10pca = Orange.projection.linear.Pca(iris) 
    1111transformed_data = pca(iris) 
    1212 
  • docs/reference/rst/code/pca-scree.py

    r9823 r10475  
    88iris = Orange.data.Table("iris.tab") 
    99 
    10 pca = Orange.projection.pca.Pca()(iris) 
     10pca = Orange.projection.linear.Pca()(iris) 
    1111pca.scree_plot("pca-scree.png") 
Note: See TracChangeset for help on using the changeset viewer.