Changeset 10633:fb05a6f3a235 in orange


Ignore:
Timestamp:
03/23/12 20:20:57 (2 years ago)
Author:
mstajdohar
Branch:
default
Message:

Changed obsolete names.

Files:
19 edited

Legend:

Unmodified
Added
Removed
  • Orange/clustering/hierarchical.py

    r10581 r10633  
    368368 
    369369from Orange.utils import progress_bar_milestones, deprecated_keywords 
    370                          
     370 
    371371import sys 
    372372 
     
    408408    matrix = Orange.misc.SymMatrix(len(data)) 
    409409    for i in range(len(data)): 
    410         for j in range(i+1): 
     410        for j in range(i + 1): 
    411411            matrix[i, j] = distance(data[i], data[j]) 
    412     root = HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value*100.0/(2 if order else 1))) if progress_callback else None) 
     412    root = HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value * 100.0 / (2 if order else 1))) if progress_callback else None) 
    413413    if order: 
    414         order_leaves(root, matrix, progress_callback=(lambda value: progress_callback(50.0 + value/2)) if progress_callback else None) 
     414        order_leaves(root, matrix, progress_callback=(lambda value: progress_callback(50.0 + value / 2)) if progress_callback else None) 
    415415    return root 
    416416 
     
    447447        for a2 in range(a1): 
    448448            matrix[a1, a2] = (1.0 - orange.PearsonCorrelation(a1, a2, data, 0).r) / 2.0 
    449     root = orange.HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value*100.0/(2 if order else 1))) if progress_callback else None) 
     449    root = orange.HierarchicalClustering(matrix, linkage=linkage, progress_callback=(lambda value, obj=None: progress_callback(value * 100.0 / (2 if order else 1))) if progress_callback else None) 
    450450    if order: 
    451         order_leaves(root, matrix, progressCallback=(lambda value: progress_callback(50.0 + value/2)) if progress_callback else None) 
     451        order_leaves(root, matrix, progressCallback=(lambda value: progress_callback(50.0 + value / 2)) if progress_callback else None) 
    452452    return root 
    453453 
    454454clustering_features = \ 
    455455    deprecated_keywords({"progressCallback":"progress_callback"})(clustering_features) 
    456      
    457      
     456 
     457 
    458458def cluster_to_list(node, prune=None): 
    459459    """ Return a list of clusters down from the node of hierarchical clustering. 
     
    470470    if prune: 
    471471        if len(node) <= prune: 
    472             return []  
     472            return [] 
    473473    if node.branches: 
    474474        return [node] + cluster_to_list(node.left, prune) + cluster_to_list(node.right, prune) 
     
    528528     
    529529    """ 
    530      
     530 
    531531    objects = getattr(tree.mapping, "objects", None) 
    532532    tree.mapping.setattr("objects", range(len(tree))) 
     
    534534    ordering = {} 
    535535    visited_clusters = set() 
    536      
     536 
    537537#    def opt_ordering_recursive(tree): 
    538538#        if len(tree)==1: 
     
    588588#    with recursion_limit(sys.getrecursionlimit() + len(tree)): 
    589589#        opt_ordering_recursive(tree) 
    590          
     590 
    591591    def opt_ordering_iterative(tree): 
    592         if len(tree)==1: 
     592        if len(tree) == 1: 
    593593            for leaf in tree: 
    594594                M[tree, leaf, leaf] = 0 
     
    596596#            _optOrdering(tree.left) 
    597597#            _optOrdering(tree.right) 
    598              
     598 
    599599            Vl = set(tree.left) 
    600600            Vr = set(tree.right) 
     
    612612                        ordered_k = sorted(other(w, Vrl, Vrr), key=lambda k: M[tree_right, w, k]) 
    613613                        k0 = ordered_k[0] 
    614                         cur_min = 1e30000  
     614                        cur_min = 1e30000 
    615615                        cur_m = cur_k = None 
    616616                        for m in ordered_m: 
     
    639639#                progressCallback(100.0 * len(visited_clusters) / len(tree.mapping)) 
    640640#                visited_clusters.add(tree) 
    641      
     641 
    642642    subtrees = postorder(tree) 
    643643    milestones = progress_bar_milestones(len(subtrees), 1000) 
    644      
     644 
    645645    for i, subtree in enumerate(subtrees): 
    646646        opt_ordering_iterative(subtree) 
     
    661661#            right.swap() 
    662662#        order_recursive(right, k, w) 
    663          
     663 
    664664    def order_iterative(tree, u, w): 
    665665        """ Order the tree based on the computed optimal ordering.  
     
    672672                opt_uw[left] = (u, m) 
    673673                opt_uw[right] = (k, w) 
    674                  
     674 
    675675                if left.branches and m not in left.right: 
    676676                    left.swap() 
    677                  
     677 
    678678                if right.branches and k not in right.left: 
    679679                    right.swap() 
    680      
     680 
    681681    u, w = min([(u, w) for u in tree.left for w in tree.right], key=lambda (u, w): M[tree, u, w]) 
    682      
     682 
    683683##    print "M(v) =", M[tree, u, w] 
    684      
     684 
    685685#    with recursion_limit(sys.getrecursionlimit() + len(tree)): 
    686686#        order_recursive(tree, u, w) 
    687              
     687 
    688688    order_iterative(tree, u, w) 
    689              
     689 
    690690 
    691691#    def _check(tree, u, w): 
     
    722722    """ 
    723723    node_count = iter(range(len(tree))) 
    724      
     724 
    725725    if progress_callback is not None: 
    726726        def p(*args): 
     
    728728    else: 
    729729        p = None 
    730      
     730 
    731731    Orange.core.HierarchicalClusterOrdering(tree, matrix, progress_callback=p) 
    732732 
     
    735735 
    736736order_leaves = order_leaves_cpp 
    737      
     737 
    738738""" 
    739739Matplotlib dendrogram ploting. This is mostly untested, 
     
    774774 
    775775    def add_cell(self, row, col, *args, **kwargs): 
    776         xy = (0,0) 
     776        xy = (0, 0) 
    777777 
    778778        cell = TableCell(xy, *args, **kwargs) 
     
    798798        cells = numpy.array([[self._cells.get((row, col), None) for col in range(max(keys[:, 1] + 1))] \ 
    799799                             for row in range(max(keys[:, 0] + 1))]) 
    800          
     800 
    801801        widths = self._get_column_widths(renderer) 
    802802        x = self.xy[0] + numpy.array([numpy.sum(widths[:i]) for i in range(len(widths))]) 
    803803        y = self.xy[1] - numpy.arange(cells.shape[0]) - 0.5 
    804          
     804 
    805805        for i in range(cells.shape[0]): 
    806806            for j in range(cells.shape[1]): 
     
    816816    def _get_column_widths(self, renderer): 
    817817        keys = numpy.array(self._cells.keys()) 
    818         widths = numpy.zeros(len(keys)).reshape((numpy.max(keys[:,0]+1), numpy.max(keys[:,1]+1))) 
     818        widths = numpy.zeros(len(keys)).reshape((numpy.max(keys[:, 0] + 1), numpy.max(keys[:, 1] + 1))) 
    819819        fontSize = self._calc_fontsize(renderer) 
    820820        for (row, col), cell in self._cells.items(): 
     
    823823            transform = self._axes.transData.inverted() 
    824824            x1, _ = transform.transform_point((0, 0)) 
    825             x2, _ = transform.transform_point((w + w*TableCell.PAD + 10, 0)) 
     825            x2, _ = transform.transform_point((w + w * TableCell.PAD + 10, 0)) 
    826826            w = abs(x1 - x2) 
    827827            widths[row, col] = w 
     
    832832        _, y1 = transform.transform_point((0, 0)) 
    833833        _, y2 = transform.transform_point((0, 1)) 
    834         return min(max(int(abs(y1 - y2)*0.85) ,4), self.max_fontsize) 
     834        return min(max(int(abs(y1 - y2) * 0.85) , 4), self.max_fontsize) 
    835835 
    836836    def get_children(self): 
     
    867867                    points.append(center) 
    868868                self.plt.plot([tree.height, tree.height], [points[0][1], points[-1][1]], color="black") 
    869                 return (tree.height, (points[0][1] + points[-1][1])/2.0) 
     869                return (tree.height, (points[0][1] + points[-1][1]) / 2.0) 
    870870            else: 
    871871                return (0.0, tree.first) 
    872872        draw_tree(self.root) 
    873          
     873 
    874874    def plotHeatMap(self): 
    875875        import numpy.ma as ma 
    876876        import numpy 
    877877        dx, dy = self.root.height, 0 
    878         fx, fy = self.root.height/len(self.data.domain.attributes), 1.0 
     878        fx, fy = self.root.height / len(self.data.domain.attributes), 1.0 
    879879        data, c, w = self.data.toNumpyMA() 
    880         data = (data - ma.min(data))/(ma.max(data) - ma.min(data)) 
    881         x = numpy.arange(data.shape[1] + 1)/float(numpy.max(data.shape)) 
    882         y = numpy.arange(data.shape[0] + 1)/float(numpy.max(data.shape))*len(self.root) 
     880        data = (data - ma.min(data)) / (ma.max(data) - ma.min(data)) 
     881        x = numpy.arange(data.shape[1] + 1) / float(numpy.max(data.shape)) 
     882        y = numpy.arange(data.shape[0] + 1) / float(numpy.max(data.shape)) * len(self.root) 
    883883        self.heatmap_width = numpy.max(x) 
    884884 
     
    892892        if self.plot_attr_names: 
    893893            names = [attr.name for attr in self.data.domain.attributes] 
    894             self.plt.xticks(numpy.arange(data.shape[1] + 1)/float(numpy.max(data.shape)), names) 
     894            self.plt.xticks(numpy.arange(data.shape[1] + 1) / float(numpy.max(data.shape)), names) 
    895895        self.plt.gca().xaxis.tick_top() 
    896896        for label in self.plt.gca().xaxis.get_ticklabels(): 
     
    909909##            tick.label2On = True 
    910910##        text = TableTextLayout(xy=(self.meshXOffset+1, len(self.root)), tableText=[[label] for label in self.labels]) 
    911         text = TableTextLayout(xy=(self.meshXOffset*1.005, len(self.root) - 1), tableText=[[label] for label in self.labels]) 
     911        text = TableTextLayout(xy=(self.meshXOffset * 1.005, len(self.root) - 1), tableText=[[label] for label in self.labels]) 
    912912        text.set_figure(self.plt.gcf()) 
    913913        self.plt.gca().add_artist(text) 
     
    916916    def plotLabels(self): 
    917917##        table = TablePlot(xy=(self.meshXOffset*1.005, len(self.root) -1), axes=self.plt.gca()) 
    918         table = TablePlot(xy=(0, len(self.root) -1), axes=self.plt.gca()) 
     918        table = TablePlot(xy=(0, len(self.root) - 1), axes=self.plt.gca()) 
    919919        table.set_figure(self.plt.gcf()) 
    920         for i,label in enumerate(self.labels): 
     920        for i, label in enumerate(self.labels): 
    921921            table.add_cell(i, 0, width=1, height=1, text=label, loc="left", edgecolor="w") 
    922922        table.set_zorder(0) 
    923923        self.plt.gca().add_artist(table) 
    924924        self.plt.gca()._set_artist_props(table) 
    925      
     925 
    926926    def plot(self, filename=None, show=False): 
    927927        self.plt.rcParams.update(self.params) 
     
    930930        space = 0.01 if self.space_width == None else self.space_width 
    931931        border = self.border_width 
    932         width = 1.0 - 2*border 
    933         height = 1.0 - 2*border 
    934         textLineHeight = min(max(h/len(self.labels), 4), self.plt.rcParams.get("font.size", 12)) 
    935         maxTextLineWidthEstimate = textLineHeight*labelLen 
     932        width = 1.0 - 2 * border 
     933        height = 1.0 - 2 * border 
     934        textLineHeight = min(max(h / len(self.labels), 4), self.plt.rcParams.get("font.size", 12)) 
     935        maxTextLineWidthEstimate = textLineHeight * labelLen 
    936936##        print maxTextLineWidthEstimate 
    937         textAxisWidthRatio = 2.0*maxTextLineWidthEstimate/w 
     937        textAxisWidthRatio = 2.0 * maxTextLineWidthEstimate / w 
    938938##        print textAxisWidthRatio 
    939939        labelsAreaRatio = min(textAxisWidthRatio, 0.4) if self.label_width == None else self.label_width 
    940940        x, y = len(self.data.domain.attributes), len(self.data) 
    941941 
    942         heatmapAreaRatio = min(1.0*y/h*x/w, 0.3) if self.heatmap_width == None else self.heatmap_width 
    943         dendrogramAreaRatio = 1.0 - labelsAreaRatio - heatmapAreaRatio - 2*space if self.dendrogram_width == None else self.dendrogram_width 
     942        heatmapAreaRatio = min(1.0 * y / h * x / w, 0.3) if self.heatmap_width == None else self.heatmap_width 
     943        dendrogramAreaRatio = 1.0 - labelsAreaRatio - heatmapAreaRatio - 2 * space if self.dendrogram_width == None else self.dendrogram_width 
    944944 
    945945        self.fig = self.plt.figure() 
    946         self.labels_offset = self.root.height/20.0 
    947         dendrogramAxes = self.plt.axes([border, border, width*dendrogramAreaRatio, height]) 
     946        self.labels_offset = self.root.height / 20.0 
     947        dendrogramAxes = self.plt.axes([border, border, width * dendrogramAreaRatio, height]) 
    948948        dendrogramAxes.xaxis.grid(True) 
    949949        import matplotlib.ticker as ticker 
     
    953953        dendrogramAxes.invert_xaxis() 
    954954        self.plotDendrogram() 
    955         heatmapAxes = self.plt.axes([border + width*dendrogramAreaRatio + space, border, width*heatmapAreaRatio, height], sharey=dendrogramAxes) 
     955        heatmapAxes = self.plt.axes([border + width * dendrogramAreaRatio + space, border, width * heatmapAreaRatio, height], sharey=dendrogramAxes) 
    956956 
    957957        heatmapAxes.xaxis.set_major_locator(ticker.NullLocator()) 
     
    959959        heatmapAxes.yaxis.set_major_locator(ticker.NullLocator()) 
    960960        heatmapAxes.yaxis.set_minor_locator(ticker.NullLocator()) 
    961          
     961 
    962962        self.plotHeatMap() 
    963         labelsAxes = self.plt.axes([border + width*(dendrogramAreaRatio + heatmapAreaRatio + 2*space), border, width*labelsAreaRatio, height], sharey=dendrogramAxes) 
     963        labelsAxes = self.plt.axes([border + width * (dendrogramAreaRatio + heatmapAreaRatio + 2 * space), border, width * labelsAreaRatio, height], sharey=dendrogramAxes) 
    964964        self.plotLabels() 
    965965        labelsAxes.set_axis_off() 
     
    974974        if show: 
    975975            self.plt.show() 
    976          
    977          
     976 
     977 
    978978""" 
    979979Dendrogram ploting using Orange.utils.render 
     
    994994         
    995995    """ 
    996     def __init__(self, tree, attr_tree = None, labels=None, data=None, width=None, height=None, tree_height=None, heatmap_width=None, text_width=None,  
     996    def __init__(self, tree, attr_tree=None, labels=None, data=None, width=None, height=None, tree_height=None, heatmap_width=None, text_width=None, 
    997997                 spacing=2, cluster_colors={}, color_palette=ColorPalette([(255, 0, 0), (0, 255, 0)]), maxv=None, minv=None, gamma=None, renderer=EPSRenderer, **kwargs): 
    998998        self.tree = tree 
     
    10061006                labels = [""] * len(tree) 
    10071007        self.labels = labels 
    1008          
     1008 
    10091009#        self.attr_labels = [str(attr.name) for attr in data.domain.attributes] if not attr_labels and data else attr_labels or [] 
    10101010        self.data = data 
     
    10251025        self.set_matrix_color_schema(color_palette, minv, maxv, gamma) 
    10261026        self.renderer = renderer 
    1027          
     1027 
    10281028    def set_matrix_color_schema(self, color_palette, minv, maxv, gamma=None): 
    10291029        """ Set the matrix color scheme. 
     
    10361036        self.maxv = maxv 
    10371037        self.gamma = gamma 
    1038          
     1038 
    10391039    def color_shema(self): 
    1040         vals = [float(val) for ex in self.data for val in ex if not val.isSpecial() and val.variable.varType==orange.VarTypes.Continuous] or [0] 
    1041         avg = sum(vals)/len(vals) 
    1042          
     1040        vals = [float(val) for ex in self.data for val in ex if not val.isSpecial() and val.variable.varType == orange.VarTypes.Continuous] or [0] 
     1041        avg = sum(vals) / len(vals) 
     1042 
    10431043        maxVal = self.maxv if self.maxv else max(vals) 
    10441044        minVal = self.minv if self.minv else min(vals) 
    1045          
     1045 
    10461046        def _colorSchema(val): 
    10471047            if val.isSpecial(): 
    10481048                return self.color_palette(None) 
    1049             elif val.variable.varType==orange.VarTypes.Continuous: 
     1049            elif val.variable.varType == orange.VarTypes.Continuous: 
    10501050                r, g, b = self.color_palette((float(val) - minVal) / abs(maxVal - minVal), gamma=self.gamma) 
    1051             elif val.variable.varType==orange.VarTypes.Discrete: 
    1052                 r = g = b = int(255.0*float(val)/len(val.variable.values)) 
     1051            elif val.variable.varType == orange.VarTypes.Discrete: 
     1052                r = g = b = int(255.0 * float(val) / len(val.variable.values)) 
    10531053            return (r, g, b) 
    10541054        return _colorSchema 
    1055      
     1055 
    10561056    def layout(self): 
    10571057        height_final = False 
     
    10611061            height, height_final = self.height, True 
    10621062            heatmap_height = height - (tree_height + self.spacing if self.attr_tree else 0) - 2 * self.horizontal_margin 
    1063             font_size =  heatmap_height / len(self.labels) #self.font_size or (height - (tree_height + self.spacing if self.attr_tree else 0) - 2 * self.horizontal_margin) / len(self.labels) 
     1063            font_size = heatmap_height / len(self.labels) #self.font_size or (height - (tree_height + self.spacing if self.attr_tree else 0) - 2 * self.horizontal_margin) / len(self.labels) 
    10641064        else: 
    10651065            font_size = self.font_size 
    10661066            heatmap_height = font_size * len(self.labels) 
    10671067            height = heatmap_height + (tree_height + self.spacing if self.attr_tree else 0) + 2 * self.horizontal_margin 
    1068               
     1068 
    10691069        text_width = self.text_width or max([len(label) for label in self.labels] + [0]) * font_size #max([self.renderer.string_size_hint(label) for label in self.labels]) 
    1070          
     1070 
    10711071        if self.width: 
    10721072            width = self.width 
     
    10751075            heatmap_width = len(self.data.domain.attributes) * heatmap_height / len(self.data) if self.data else 0 
    10761076            width = 2 * self.vertical_margin + tree_height + (heatmap_width + self.spacing if self.data else 0) + self.spacing + text_width 
    1077              
     1077 
    10781078        return width, height, tree_height, heatmap_width, heatmap_height, text_width, font_size 
    1079      
     1079 
    10801080    def plot(self, filename="graph.eps", **kwargs): 
    10811081        width, height, tree_height, heatmap_width, heatmap_height, text_width, font_size = self.layout() 
     
    10831083 
    10841084        heatmap_cell_width = 0.0 if not self.data else heatmap_width / len(self.data.domain.attributes) 
    1085          
     1085 
    10861086        self.renderer = self.renderer(width, height) 
    1087          
     1087 
    10881088        def draw_tree(cluster, root, treeheight, treewidth, color): 
    10891089            height = treeheight * cluster.height / root.height 
     
    10931093                    center = draw_tree(branch, root, treeheight, treewidth, self.cluster_colors.get(branch, color)) 
    10941094                    centers.append(center) 
    1095                     self.renderer.draw_line(center[0], center[1], center[0], height, stroke_color = self.cluster_colors.get(branch, color)) 
    1096                      
    1097                 self.renderer.draw_line(centers[0][0], height, centers[-1][0], height, stroke_color = self.cluster_colors.get(cluster, color)) 
     1095                    self.renderer.draw_line(center[0], center[1], center[0], height, stroke_color=self.cluster_colors.get(branch, color)) 
     1096 
     1097                self.renderer.draw_line(centers[0][0], height, centers[-1][0], height, stroke_color=self.cluster_colors.get(cluster, color)) 
    10981098                return (centers[0][0] + centers[-1][0]) / 2.0, height 
    10991099            else: 
     
    11031103        self.renderer.rotate(90) 
    11041104#        print self.renderer.transform() 
    1105         draw_tree(self.tree, self.tree, tree_height, heatmap_height, self.cluster_colors.get(self.tree, (0,0,0))) 
     1105        draw_tree(self.tree, self.tree, tree_height, heatmap_height, self.cluster_colors.get(self.tree, (0, 0, 0))) 
    11061106        self.renderer.restore_render_state() 
    11071107        if self.attr_tree: 
     
    11101110            self.renderer.scale(1.0, -1.0) 
    11111111#            print self.renderer.transform() 
    1112             draw_tree(self.attr_tree, self.attr_tree, tree_height, heatmap_width, self.cluster_colors.get(self.attr_tree, (0,0,0))) 
     1112            draw_tree(self.attr_tree, self.attr_tree, tree_height, heatmap_width, self.cluster_colors.get(self.attr_tree, (0, 0, 0))) 
    11131113            self.renderer.restore_render_state() 
    1114          
     1114 
    11151115        self.renderer.save_render_state() 
    11161116        self.renderer.translate(self.vertical_margin + tree_height + self.spacing, self.horizontal_margin + (tree_height + self.spacing if self.attr_tree else 0)) 
     
    11231123                    r, g, b = colorSchema(ex[jj]) 
    11241124                    self.renderer.draw_rect(j * heatmap_cell_width, i * heatmap_cell_height, heatmap_cell_width, heatmap_cell_height, fill_color=(r, g, b), stroke_color=(255, 255, 255)) 
    1125          
     1125 
    11261126        self.renderer.translate(heatmap_width + self.spacing, heatmap_cell_height) 
    11271127#        print self.renderer.transform() 
     
    11321132        self.renderer.restore_render_state() 
    11331133        self.renderer.save(filename, **kwargs) 
    1134          
    1135          
     1134 
     1135 
    11361136def dendrogram_draw(file, cluster, attr_cluster=None, labels=None, data=None, 
    11371137                    width=None, height=None, tree_height=None, 
    1138                     heatmap_width=None, text_width=None,  spacing=2, 
     1138                    heatmap_width=None, text_width=None, spacing=2, 
    11391139                    cluster_colors={}, 
    11401140                    color_palette=ColorPalette([(255, 0, 0), (0, 255, 0)]), 
     
    11931193        name, ext = os.path.splitext(file) 
    11941194        format = ext.lower().lstrip(".") or format 
    1195          
     1195 
    11961196    if format is None: 
    11971197        format = "png" 
    1198          
     1198 
    11991199    renderer = {"eps":EPSRenderer, "svg":SVGRenderer, "png":PILRenderer}.get(format, "png") 
    1200      
     1200 
    12011201    d = DendrogramPlot(cluster, attr_cluster, labels, data, width, height, 
    12021202                       tree_height, heatmap_width, text_width, spacing, 
     
    12071207    else: 
    12081208        d.plot(file) 
    1209      
     1209 
    12101210def postorder(cluster): 
    12111211    """ Return a post order list of clusters. 
     
    12221222    while stack: 
    12231223        cluster = stack.pop(0) 
    1224          
     1224 
    12251225        if cluster.branches: 
    12261226            if cluster in visited: 
     
    12331233            visited.add(cluster) 
    12341234    return order 
    1235      
    1236      
     1235 
     1236 
    12371237def preorder(cluster): 
    12381238    """ Return a pre order list of clusters. 
     
    12521252            stack = cluster.branches + stack 
    12531253    return order 
    1254      
    1255      
     1254 
     1255 
    12561256def dendrogram_layout(cluster, expand_leaves=False): 
    12571257    """ Return a layout of the cluster dendrogram on a 2D plane. The return  
     
    12921292            cluster_geometry[cluster] = (start, center, end) 
    12931293            result.append((cluster, (start, center, end))) 
    1294              
     1294 
    12951295    return result 
    1296      
     1296 
    12971297def clone(cluster): 
    12981298    """ Clone a cluster, including it's subclusters. 
     
    13131313        node_clone.mapping = mapping 
    13141314        clones[node] = node_clone 
    1315          
     1315 
    13161316    return clones[cluster] 
    1317      
     1317 
    13181318def pruned(cluster, level=None, height=None, condition=None): 
    13191319    """ Return a new pruned clustering instance.     
     
    13421342    prune(cluster, level, height, condition) 
    13431343    return cluster 
    1344      
    1345      
     1344 
     1345 
    13461346def prune(cluster, level=None, height=None, condition=None): 
    13471347    """ Prune the clustering instance ``cluster`` in place. 
     
    13651365    if not any(arg is not None for arg in [level, height, condition]): 
    13661366        raise ValueError("At least one pruning argument must be supplied") 
    1367      
     1367 
    13681368    level_check = height_check = condition_check = lambda cl: False 
    13691369    cluster_depth = cluster_depths(cluster) 
    1370      
     1370 
    13711371    if level is not None: 
    13721372        level_check = lambda cl: cluster_depth[cl] >= level 
    1373          
     1373 
    13741374    if height is not None: 
    13751375        height_check = lambda cl: cl.height <= height 
     
    13771377    if condition is not None: 
    13781378        condition_check = condition 
    1379          
     1379 
    13801380    pruned_set = set() 
    1381      
     1381 
    13821382    def check_all(cl): 
    13831383        return any([check(cl) for check in [level_check, height_check, 
    13841384                                            condition_check]]) 
    1385          
     1385 
    13861386    for cluster in preorder(cluster): 
    13871387        if cluster not in pruned_set: 
     
    13911391            else: 
    13921392                pass 
    1393      
    1394      
     1393 
     1394 
    13951395def cluster_depths(cluster): 
    13961396    """ Return a dictionary mapping :class:`HierarchicalCluster` instances to 
     
    14341434    iter_count = matrix.dim * (matrix.dim - 1) / 2 
    14351435    milestones = progress_bar_milestones(iter_count, 100) 
    1436      
     1436 
    14371437    for count, ((i, a1), (j, a2)) in enumerate(_pairs(enumerate(attributes))): 
    14381438        matrix[i, j] = (1.0 - orange.PearsonCorrelation(a1, a2, data, 0).r) / 2.0 
    14391439        if progress_callback and count in milestones: 
    14401440            progress_callback(100.0 * count / iter_count) 
    1441              
     1441 
    14421442    return matrix 
    14431443 
    14441444 
    1445 def _pairs(seq, same = False): 
     1445def _pairs(seq, same=False): 
    14461446    """ Return all pairs from elements of `seq`. 
    14471447    """ 
     
    14511451        for j in range(i + same, len(seq)): 
    14521452            yield seq[i], seq[j] 
    1453      
    1454      
     1453 
     1454 
    14551455def joining_cluster(cluster, item1, item2): 
    14561456    """ Return the cluster where `item1` and `item2` are first joined 
     
    14741474        else: 
    14751475            return cluster 
    1476          
     1476 
    14771477 
    14781478def cophenetic_distances(cluster): 
     
    14881488    """ 
    14891489 
    1490     mapping = cluster.mapping   
     1490    mapping = cluster.mapping 
    14911491    matrix = Orange.misc.SymMatrix(len(mapping)) 
    14921492    for cluster in postorder(cluster): 
     
    14961496                    for idx2 in mapping[branch2.first: branch2.last]: 
    14971497                        matrix[idx1, idx2] = cluster.height 
    1498                  
     1498 
    14991499        else: 
    15001500            for ind1, ind2 in _pairs(mapping[cluster.first: cluster.last]): 
    15011501                matrix[ind1, ind2] = cluster.height 
    1502      
     1502 
    15031503    return matrix 
    15041504 
    1505      
     1505 
    15061506def cophenetic_correlation(cluster, matrix): 
    15071507    """ Return the `cophenetic correlation coefficient 
     
    15251525    original = numpy.ravel(original) 
    15261526    return numpy.corrcoef(cophenetic, original)[0, 1] 
    1527      
    1528      
     1527 
     1528 
  • Orange/evaluation/reliability.py

    r10393 r10633  
    5555 
    5656def get_prediction_error_list(res): 
    57     return [result.actualClass - result.classes[0] for result in res.results] 
     57    return [result.actual_class - result.classes[0] for result in res.results] 
    5858 
    5959def get_description_list(res, i): 
     
    124124    sig = [0 for _ in xrange(number_of_estimates)] 
    125125    method_list = [0 for _ in xrange(number_of_estimates)] 
    126      
     126 
    127127    for res in results_by_fold: 
    128128        prediction_error = get_prediction_error_list(res) 
     
    139139            sig[i] = signed_or_absolute 
    140140            method_list[i] = method 
    141      
     141 
    142142    # Calculate p-values 
    143143    results = [float(res) / number_of_folds for res in results] 
    144144    ps = [p_value_from_r(r, number_of_instances) for r in results] 
    145      
     145 
    146146    return zip(results, ps, sig, method_list) 
    147147 
     
    151151    """ 
    152152    df = n - 2 
    153     t = r * (df /((-r + 1.0 + 1e-30) * (r + 1.0 + 1e-30)) )**0.5 
    154     return statc.betai (df * 0.5, 0.5, df/(df + t*t)) 
     153    t = r * (df / ((-r + 1.0 + 1e-30) * (r + 1.0 + 1e-30))) ** 0.5 
     154    return statc.betai (df * 0.5, 0.5, df / (df + t * t)) 
    155155 
    156156class Estimate: 
     
    188188 
    189189    """ 
    190     def __init__(self, estimate, signed_or_absolute, method, icv_method = -1): 
     190    def __init__(self, estimate, signed_or_absolute, method, icv_method= -1): 
    191191        self.estimate = estimate 
    192192        self.signed_or_absolute = signed_or_absolute 
     
    202202        self.procentage = procentage 
    203203        self.estimator = estimator 
    204      
     204 
    205205    def __call__(self, instances, weight=None, **kwds): 
    206          
     206 
    207207        # Calculate borders using cross validation 
    208208        res = Orange.evaluation.testing.cross_validation([self.estimator], instances) 
     
    210210        for i in xrange(len(res.results[0].probabilities[0].reliability_estimate)): 
    211211            estimates, signed_or_absolute, method = get_reliability_estimation_list(res, i) 
    212             sorted_estimates = sorted( abs(x) for x in estimates) 
    213             borders = [sorted_estimates[int(len(estimates)*p)-1]  for p in self.procentage] 
     212            sorted_estimates = sorted(abs(x) for x in estimates) 
     213            borders = [sorted_estimates[int(len(estimates) * p) - 1]  for p in self.procentage] 
    214214            all_borders.append(borders) 
    215          
     215 
    216216        # Learn on whole train data 
    217217        estimator_classifier = self.estimator(instances) 
    218          
     218 
    219219        return DescriptiveAnalysisClassifier(estimator_classifier, all_borders, self.desc) 
    220220 
     
    224224        self.all_borders = all_borders 
    225225        self.desc = desc 
    226      
     226 
    227227    def __call__(self, instance, result_type=Orange.core.GetValue): 
    228228        predicted, probabilities = self.estimator_classifier(instance, Orange.core.GetBoth) 
    229          
     229 
    230230        for borders, estimate in zip(self.all_borders, probabilities.reliability_estimate): 
    231231            estimate.text_description = self.desc[0] 
     
    233233                if estimate.estimate >= lower_border: 
    234234                    estimate.text_description = text_desc 
    235          
     235 
    236236        # Return the appropriate type of result 
    237237        if result_type == Orange.core.GetValue: 
     
    269269    def __init__(self, e=[0.01, 0.1, 0.5, 1.0, 2.0]): 
    270270        self.e = e 
    271      
     271 
    272272    def __call__(self, instances, learner): 
    273273        min_value = max_value = instances[0].getclass().value 
     
    278278                min_value = ex.getclass().value 
    279279        return SensitivityAnalysisClassifier(self.e, instances, min_value, max_value, learner) 
    280      
     280 
    281281class SensitivityAnalysisClassifier: 
    282282    def __init__(self, e, instances, min_value, max_value, learner): 
     
    286286        self.min_value = min_value 
    287287        self.learner = learner 
    288      
     288 
    289289    def __call__(self, instance, predicted, probabilities): 
    290290        # Create new dataset 
    291291        r_data = Orange.data.Table(self.instances) 
    292          
     292 
    293293        # Create new instance 
    294294        modified_instance = Orange.data.Instance(instance) 
    295          
     295 
    296296        # Append it to the data 
    297297        r_data.append(modified_instance) 
    298          
     298 
    299299        # Calculate SAvar & SAbias 
    300300        SAvar = SAbias = 0 
    301          
     301 
    302302        for eps in self.e: 
    303303            # +epsilon 
    304             r_data[-1].setclass(predicted.value + eps*(self.max_value - self.min_value)) 
     304            r_data[-1].setclass(predicted.value + eps * (self.max_value - self.min_value)) 
    305305            c = self.learner(r_data) 
    306306            k_plus = c(instance, Orange.core.GetValue) 
    307              
     307 
    308308            # -epsilon 
    309             r_data[-1].setclass(predicted.value - eps*(self.max_value - self.min_value)) 
     309            r_data[-1].setclass(predicted.value - eps * (self.max_value - self.min_value)) 
    310310            c = self.learner(r_data) 
    311311            k_minus = c(instance, Orange.core.GetValue) 
     
    316316            # calculate part SAvar and SAbias 
    317317            SAvar += k_plus.value - k_minus.value 
    318             SAbias += k_plus.value + k_minus.value - 2*predicted.value 
    319          
     318            SAbias += k_plus.value + k_minus.value - 2 * predicted.value 
     319 
    320320        SAvar /= len(self.e) 
    321         SAbias /= 2*len(self.e) 
    322          
     321        SAbias /= 2 * len(self.e) 
     322 
    323323        return [Estimate(SAvar, ABSOLUTE, SAVAR_ABSOLUTE), 
    324324                Estimate(SAbias, SIGNED, SABIAS_SIGNED), 
    325325                Estimate(abs(SAbias), ABSOLUTE, SABIAS_ABSOLUTE)] 
    326      
     326 
    327327class BaggingVariance: 
    328328    """ 
     
    345345    def __init__(self, m=50): 
    346346        self.m = m 
    347      
     347 
    348348    def __call__(self, instances, learner): 
    349349        classifiers = [] 
    350          
     350 
    351351        # Create bagged classifiers using sampling with replacement 
    352352        for _ in xrange(self.m): 
     
    359359    def __init__(self, classifiers): 
    360360        self.classifiers = classifiers 
    361      
     361 
    362362    def __call__(self, instance, *args): 
    363363        BAGV = 0 
    364          
     364 
    365365        # Calculate the bagging variance 
    366366        bagged_values = [c(instance, Orange.core.GetValue).value for c in self.classifiers if c is not None] 
    367          
     367 
    368368        k = sum(bagged_values) / len(bagged_values) 
    369          
    370         BAGV = sum( (bagged_value - k)**2 for bagged_value in bagged_values) / len(bagged_values) 
    371          
     369 
     370        BAGV = sum((bagged_value - k) ** 2 for bagged_value in bagged_values) / len(bagged_values) 
     371 
    372372        return [Estimate(BAGV, ABSOLUTE, BAGV_ABSOLUTE)] 
    373          
     373 
    374374class LocalCrossValidation: 
    375375    """ 
     
    397397    def __init__(self, k=0): 
    398398        self.k = k 
    399      
     399 
    400400    def __call__(self, instances, learner): 
    401401        nearest_neighbours_constructor = Orange.classification.knn.FindNearestConstructor() 
    402402        nearest_neighbours_constructor.distanceConstructor = Orange.distance.Euclidean() 
    403          
     403 
    404404        distance_id = Orange.feature.Descriptor.new_meta_id() 
    405405        nearest_neighbours = nearest_neighbours_constructor(instances, 0, distance_id) 
    406          
     406 
    407407        if self.k == 0: 
    408             self.k = max(5, len(instances)/20) 
    409          
     408            self.k = max(5, len(instances) / 20) 
     409 
    410410        return LocalCrossValidationClassifier(distance_id, nearest_neighbours, self.k, learner) 
    411411 
     
    416416        self.k = k 
    417417        self.learner = learner 
    418      
     418 
    419419    def __call__(self, instance, *args): 
    420420        LCVer = 0 
    421421        LCVdi = 0 
    422          
     422 
    423423        # Find k nearest neighbors 
    424          
     424 
    425425        knn = [ex for ex in self.nearest_neighbours(instance, self.k)] 
    426          
     426 
    427427        # leave one out of prediction error 
    428428        for i in xrange(len(knn)): 
    429429            train = knn[:] 
    430430            del train[i] 
    431              
     431 
    432432            classifier = self.learner(Orange.data.Table(train)) 
    433              
     433 
    434434            returned_value = classifier(knn[i], Orange.core.GetValue) 
    435              
     435 
    436436            e = abs(knn[i].getclass().value - returned_value.value) 
    437              
     437 
    438438            LCVer += e * math.exp(-knn[i][self.distance_id]) 
    439439            LCVdi += math.exp(-knn[i][self.distance_id]) 
    440          
     440 
    441441        LCV = LCVer / LCVdi if LCVdi != 0 else 0 
    442442        if math.isnan(LCV): 
     
    464464    def __init__(self, k=5): 
    465465        self.k = k 
    466      
     466 
    467467    def __call__(self, instances, learner): 
    468468        nearest_neighbours_constructor = Orange.classification.knn.FindNearestConstructor() 
    469469        nearest_neighbours_constructor.distanceConstructor = Orange.distance.Euclidean() 
    470          
     470 
    471471        distance_id = Orange.feature.Descriptor.new_meta_id() 
    472472        nearest_neighbours = nearest_neighbours_constructor(instances, 0, distance_id) 
     
    477477        self.nearest_neighbours = nearest_neighbours 
    478478        self.k = k 
    479      
     479 
    480480    def __call__(self, instance, predicted, probabilities): 
    481481        CNK = 0 
    482          
     482 
    483483        # Find k nearest neighbors 
    484          
     484 
    485485        knn = [ex for ex in self.nearest_neighbours(instance, self.k)] 
    486          
     486 
    487487        # average label of neighbors 
    488488        for ex in knn: 
    489489            CNK += ex.getclass().value 
    490          
     490 
    491491        CNK /= self.k 
    492492        CNK -= predicted.value 
    493          
     493 
    494494        return [Estimate(CNK, SIGNED, CNK_SIGNED), 
    495495                Estimate(abs(CNK), ABSOLUTE, CNK_ABSOLUTE)] 
    496      
     496 
    497497class Mahalanobis: 
    498498    """ 
     
    511511    def __init__(self, k=3): 
    512512        self.k = k 
    513      
     513 
    514514    def __call__(self, instances, *args): 
    515515        nnm = Orange.classification.knn.FindNearestConstructor() 
    516516        nnm.distanceConstructor = Orange.distance.Mahalanobis() 
    517          
     517 
    518518        mid = Orange.feature.Descriptor.new_meta_id() 
    519519        nnm = nnm(instances, 0, mid) 
     
    525525        self.nnm = nnm 
    526526        self.mid = mid 
    527      
     527 
    528528    def __call__(self, instance, *args): 
    529529        mahalanobis_distance = 0 
    530          
     530 
    531531        mahalanobis_distance = sum(ex[self.mid].value for ex in self.nnm(instance, self.k)) 
    532          
     532 
    533533        return [ Estimate(mahalanobis_distance, ABSOLUTE, MAHAL_ABSOLUTE) ] 
    534534 
     
    545545    def __init__(self): 
    546546        pass 
    547      
     547 
    548548    def __call__(self, instances, *args): 
    549549        dc = Orange.core.DomainContinuizer() 
     
    551551        dc.continuousTreatment = Orange.core.DomainContinuizer.NormalizeBySpan 
    552552        dc.multinomialTreatment = Orange.core.DomainContinuizer.NValues 
    553          
     553 
    554554        new_domain = dc(instances) 
    555555        new_instances = instances.translate(new_domain) 
    556          
     556 
    557557        X, _, _ = new_instances.to_numpy() 
    558558        instance_avg = numpy.average(X, 0) 
    559          
     559 
    560560        distance_constructor = Orange.distance.Mahalanobis() 
    561561        distance = distance_constructor(new_instances) 
    562          
     562 
    563563        average_instance = Orange.data.Instance(new_instances.domain, list(instance_avg) + ["?"]) 
    564          
     564 
    565565        return MahalanobisToCenterClassifier(distance, average_instance, new_domain) 
    566566 
     
    570570        self.average_instance = average_instance 
    571571        self.new_domain = new_domain 
    572      
     572 
    573573    def __call__(self, instance, *args): 
    574          
     574 
    575575        inst = Orange.data.Instance(self.new_domain, instance) 
    576          
     576 
    577577        mahalanobis_to_center = self.distance(inst, self.average_instance) 
    578          
     578 
    579579        return [ Estimate(mahalanobis_to_center, ABSOLUTE, MAHAL_TO_CENTER_ABSOLUTE) ] 
    580580 
     
    598598        self.bagv = bagv 
    599599        self.cnk = cnk 
    600      
     600 
    601601    def __call__(self, instances, learner): 
    602602        bagv_classifier = self.bagv(instances, learner) 
     
    608608        self.bagv_classifier = bagv_classifier 
    609609        self.cnk_classifier = cnk_classifier 
    610      
     610 
    611611    def __call__(self, instance, predicted, probabilities): 
    612612        bagv_estimates = self.bagv_classifier(instance, predicted, probabilities) 
    613613        cnk_estimates = self.cnk_classifier(instance, predicted, probabilities) 
    614          
    615         bvck_value = (bagv_estimates[0].estimate + cnk_estimates[1].estimate)/2 
     614 
     615        bvck_value = (bagv_estimates[0].estimate + cnk_estimates[1].estimate) / 2 
    616616        bvck_estimates = [ Estimate(bvck_value, ABSOLUTE, BVCK_ABSOLUTE) ] 
    617617        bvck_estimates.extend(bagv_estimates) 
     
    622622    def __init__(self): 
    623623        pass 
    624      
     624 
    625625    def __call__(self, instances, learner): 
    626626        res = Orange.evaluation.testing.cross_validation([learner], instances) 
    627627        prediction_errors = get_prediction_error_list(res) 
    628          
     628 
    629629        new_domain = Orange.data.Domain(instances.domain.attributes, Orange.core.FloatVariable("pe")) 
    630630        new_dataset = Orange.data.Table(new_domain, instances) 
    631          
     631 
    632632        for instance, prediction_error in izip(new_dataset, prediction_errors): 
    633633            instance.set_class(prediction_error) 
    634          
     634 
    635635        rf = Orange.ensemble.forest.RandomForestLearner() 
    636636        rf_classifier = rf(new_dataset) 
    637          
     637 
    638638        return ErrorPredictingClassification(rf_classifier, new_domain) 
    639          
     639 
    640640class ErrorPredictingClassification: 
    641641    def __init__(self, rf_classifier, new_domain): 
    642642        self.rf_classifier = rf_classifier 
    643643        self.new_domain = new_domain 
    644      
     644 
    645645    def __call__(self, instance, predicted, probabilities): 
    646646        new_instance = Orange.data.Instance(self.new_domain, instance) 
    647647        value = self.rf_classifier(new_instance, Orange.core.GetValue) 
    648          
     648 
    649649        return [Estimate(value.value, SIGNED, SABIAS_SIGNED)] 
    650650 
     
    682682        self.box_learner = box_learner 
    683683        self.blending = False 
    684          
    685      
     684 
     685 
    686686    def __call__(self, instances, weight=None, **kwds): 
    687687        """Learn from the given table of data instances. 
     
    693693        :rtype: :class:`Orange.evaluation.reliability.Classifier` 
    694694        """ 
    695          
     695 
    696696        blending_classifier = None 
    697697        new_domain = None 
    698          
     698 
    699699        if instances.domain.class_var.var_type != Orange.feature.Continuous.Continuous: 
    700700            raise Exception("This method only works on data with continuous class.") 
    701          
     701 
    702702        return Classifier(instances, self.box_learner, self.estimators, self.blending, new_domain, blending_classifier) 
    703      
     703 
    704704    def internal_cross_validation(self, instances, folds=10): 
    705705        """ Perform the internal cross validation for getting the best 
     
    720720        sorted_results = sorted(results) 
    721721        return sorted_results[-1][3] 
    722      
     722 
    723723    def internal_cross_validation_testing(self, instances, folds=10): 
    724724        """ Perform internal cross validation (as in Automatic selection of 
     
    735735        """ 
    736736        cv_indices = Orange.core.MakeRandomIndicesCV(instances, folds) 
    737          
     737 
    738738        list_of_rs = [] 
    739          
     739 
    740740        sum_of_rs = defaultdict(float) 
    741          
     741 
    742742        for fold in xrange(folds): 
    743743            data = instances.select(cv_indices, fold) 
     
    751751        sorted_sum_of_rs = sorted(sum_of_rs.items(), key=lambda estimate: estimate[1], reverse=True) 
    752752        return sorted_sum_of_rs[0][0] 
    753      
     753 
    754754    labels = ["SAvar", "SAbias", "BAGV", "CNK", "LCV", "BVCK", "Mahalanobis", "ICV"] 
    755755 
     
    774774        self.blending_domain = blending_domain 
    775775        self.rf_classifier = rf_classifier 
    776          
     776 
    777777        # Train the learner with original data 
    778778        self.classifier = box_learner(instances) 
    779          
     779 
    780780        # Train all the estimators and create their classifiers 
    781781        self.estimation_classifiers = [estimator(instances, box_learner) for estimator in estimators] 
    782      
     782 
    783783    def __call__(self, instance, result_type=Orange.core.GetValue): 
    784784        """ 
     
    802802        """ 
    803803        predicted, probabilities = self.classifier(instance, Orange.core.GetBoth) 
    804          
     804 
    805805        # Create a place holder for estimates 
    806806        if probabilities is None: 
     
    809809        #    warnings.simplefilter("ignore") 
    810810        probabilities.setattr('reliability_estimate', []) 
    811          
     811 
    812812        # Calculate all the estimates and add them to the results 
    813813        for estimate in self.estimation_classifiers: 
    814814            probabilities.reliability_estimate.extend(estimate(instance, predicted, probabilities)) 
    815          
     815 
    816816        # Return the appropriate type of result 
    817817        if result_type == Orange.core.GetValue: 
  • Orange/evaluation/scoring.py

    r10580 r10633  
    5050    if res.number_of_iterations < 2: 
    5151        return [res] 
    52          
     52 
    5353    ress = [Orange.evaluation.testing.ExperimentResults( 
    5454                1, res.classifier_names, res.class_values, 
     
    6868        r = Orange.evaluation.testing.ExperimentResults(res.numberOfIterations, 
    6969                    [res.classifierNames[i]], res.classValues, 
    70                     weights=res.weights, baseClass=res.baseClass, 
     70                    weights=res.weights, base_class=res.base_class, 
    7171                    classifiers=[res.classifiers[i]] if res.classifiers else [], 
    7272                    test_type=res.test_type, labels=res.labels) 
     
    118118    if not stats[0]: 
    119119        raise ValueError, "Cannot compute the score: no examples or sum of weights is 0." 
    120      
     120 
    121121    if report_se: 
    122122        return [(statc.mean(x), statc.sterr(x)) for x in stats] 
    123123    else: 
    124124        return [statc.mean(x) for x in stats] 
    125      
     125 
    126126def ME(res, **argkw): 
    127127    MEs = [0.] * res.number_of_learners 
     
    129129    if argkw.get("unweighted", 0) or not res.weights: 
    130130        for tex in res.results: 
    131             MEs = map(lambda res, cls, ac = float(tex.actual_class): 
     131            MEs = map(lambda res, cls, ac=float(tex.actual_class): 
    132132                      res + abs(float(cls) - ac), MEs, tex.classes) 
    133133        totweight = gettotsize(res) 
     
    216216                    norm[tex.iteration_number] += abs(ai - a[tex.iteration_number]) 
    217217                elif argkw.get("norm-sqr", 0): 
    218                     norm[tex.iteration_number] += (ai - a[tex.iteration_number])**2 
     218                    norm[tex.iteration_number] += (ai - a[tex.iteration_number]) ** 2 
    219219 
    220220                # iterate accross results of different regressors 
     
    223223                        scores[i][tex.iteration_number] += abs(float(cls) - ai) 
    224224                    else: 
    225                         scores[i][tex.iteration_number] += (float(cls) - ai)**2 
     225                        scores[i][tex.iteration_number] += (float(cls) - ai) ** 2 
    226226        else: # unweighted != 0 
    227227            raise NotImplementedError, "weighted error scores with SE not implemented yet" 
     
    239239 
    240240        return [(statc.mean(x), statc.std(x)) for x in scores] 
    241          
     241 
    242242    else: # single iteration (testing on a single test set) 
    243243        scores = [0.] * res.number_of_learners 
     
    253253                else: 
    254254                    scores = map(lambda res, cls, ac=float(tex.actual_class): 
    255                                  res + (float(cls) - ac)**2, scores, tex.classes) 
     255                                 res + (float(cls) - ac) ** 2, scores, tex.classes) 
    256256 
    257257                if argkw.get("norm-abs", 0): 
    258258                    norm += abs(tex.actual_class - a) 
    259259                elif argkw.get("norm-sqr", 0): 
    260                     norm += (tex.actual_class - a)**2 
     260                    norm += (tex.actual_class - a) ** 2 
    261261            totweight = gettotsize(res) 
    262262        else: 
     
    266266                MSEs = map(lambda res, cls, ac=float(tex.actual_class), 
    267267                           tw=tex.weight: 
    268                            res + tw * (float(cls) - ac)**2, MSEs, tex.classes) 
     268                           res + tw * (float(cls) - ac) ** 2, MSEs, tex.classes) 
    269269            totweight = gettotweight(res) 
    270270 
     
    285285    """Compute mean-squared error.""" 
    286286    return regression_error(res, **argkw) 
    287      
     287 
    288288def RMSE(res, **argkw): 
    289289    """Compute root mean-squared error.""" 
     
    330330                nIter[tex.iteration_number] += 1 
    331331                for i, cls in enumerate(tex.classes): 
    332                     MSEs[i][tex.iteration_number] += (float(cls) - ac)**2 
     332                    MSEs[i][tex.iteration_number] += (float(cls) - ac) ** 2 
    333333        else: 
    334334            raise ValueError, "weighted RMSE with SE not implemented yet" 
     
    337337            MSEs = [[math.sqrt(x) for x in y] for y in MSEs] 
    338338        return [(statc.mean(x), statc.std(x)) for x in MSEs] 
    339          
     339 
    340340    else: 
    341341        MSEs = [0.] * res.number_of_learners 
     
    343343            for tex in res.results: 
    344344                MSEs = map(lambda res, cls, ac=float(tex.actual_class): 
    345                            res + (float(cls) - ac)**2, MSEs, tex.classes) 
     345                           res + (float(cls) - ac) ** 2, MSEs, tex.classes) 
    346346            totweight = gettotsize(res) 
    347347        else: 
    348348            for tex in res.results: 
    349349                MSEs = map(lambda res, cls, ac=float(tex.actual_class), 
    350                            tw=tex.weight: res + tw * (float(cls) - ac)**2, 
     350                           tw=tex.weight: res + tw * (float(cls) - ac) ** 2, 
    351351                           MSEs, tex.classes) 
    352352            totweight = gettotweight(res) 
     
    386386    @deprecated_keywords({"reportSE": "report_se", 
    387387                          "unweighted": "ignore_weights"}) 
    388     def __init__(self, test_results, report_se = False, ignore_weights=False): 
     388    def __init__(self, test_results, report_se=False, ignore_weights=False): 
    389389        super(CA, self).__init__() 
    390390        self.report_se = report_se 
     
    449449            w = 1. if self.ignore_weights else tex.weight 
    450450            for lrn in range(test_results.number_of_learners): 
    451                 CAsByFold[lrn][tex.iteration_number] += (tex.classes[lrn] ==  
     451                CAsByFold[lrn][tex.iteration_number] += (tex.classes[lrn] == 
    452452                    tex.actual_class) and w 
    453453            foldN[tex.iteration_number] += w 
     
    472472    """Compute the average probability assigned to the correct class.""" 
    473473    if res.number_of_iterations == 1: 
    474         APs=[0.] * res.number_of_learners 
     474        APs = [0.] * res.number_of_learners 
    475475        if ignore_weights or not res.weights: 
    476476            for tex in res.results: 
     
    525525 
    526526    if res.number_of_iterations == 1: 
    527         MSEs=[0.] * res.number_of_learners 
     527        MSEs = [0.] * res.number_of_learners 
    528528        if ignore_weights or not res.weights: 
    529529            totweight = 0. 
    530530            for tex in res.results: 
    531531                MSEs = map(lambda res, probs: res + reduce( 
    532                     lambda s, pi: s + pi**2, probs, 0) -  
     532                    lambda s, pi: s + pi ** 2, probs, 0) - 
    533533                    2 * probs[tex.actual_class], MSEs, tex.probabilities) 
    534534                totweight += tex.weight 
     
    536536            for tex in res.results: 
    537537                MSEs = map(lambda res, probs: res + tex.weight * reduce( 
    538                     lambda s, pi: s + pi**2, probs, 0) -  
     538                    lambda s, pi: s + pi ** 2, probs, 0) - 
    539539                    2 * probs[tex.actual_class], MSEs, tex.probabilities) 
    540540            totweight = gettotweight(res) 
     
    553553        for tex in res.results: 
    554554            BSs[tex.iteration_number] = map(lambda rr, probs: rr + reduce( 
    555                 lambda s, pi: s + pi**2, probs, 0) - 
     555                lambda s, pi: s + pi ** 2, probs, 0) - 
    556556                2 * probs[tex.actual_class], BSs[tex.iteration_number], 
    557557                tex.probabilities) 
     
    560560        for tex in res.results: 
    561561            BSs[tex.iteration_number] = map(lambda res, probs: 
    562                 res + tex.weight * reduce(lambda s, pi: s + pi**2, probs, 0) - 
     562                res + tex.weight * reduce(lambda s, pi: s + pi ** 2, probs, 0) - 
    563563                2 * probs[tex. actual_class], BSs[tex.iteration_number], 
    564564                tex.probabilities) 
     
    572572 
    573573def BSS(res, **argkw): 
    574     return [1 - x / 2 for x in apply(Brier_score, (res, ), argkw)] 
     574    return [1 - x / 2 for x in apply(Brier_score, (res,), argkw)] 
    575575 
    576576def IS_ex(Pc, P): 
     
    614614            return [IS / totweight for IS in ISs] 
    615615 
    616          
     616 
    617617    ISs = [[0.] * res.number_of_iterations 
    618618           for _ in range(res.number_of_learners)] 
     
    636636 
    637637    return statistics_by_folds(ISs, foldN, report_se, False) 
    638      
     638 
    639639 
    640640def Wilcoxon(res, statistics, **argkw): 
     
    664664                      "classIndex": "class_index", 
    665665                      "unweighted": "ignore_weights"}) 
    666 def confusion_matrices(test_results, class_index=-1, 
     666def confusion_matrices(test_results, class_index= -1, 
    667667                       ignore_weights=False, cutoff=.5): 
    668668    """ 
     
    678678    """ 
    679679    tfpns = [ConfusionMatrix() for _ in range(test_results.number_of_learners)] 
    680      
     680 
    681681    if class_index < 0: 
    682682        numberOfClasses = len(test_results.class_values) 
     
    699699                            cm[li][trueClass][predClass] += tex.weight 
    700700            return cm 
    701              
    702         elif test_results.baseClass >= 0: 
    703             class_index = test_results.baseClass 
     701 
     702        elif test_results.base_class >= 0: 
     703            class_index = test_results.base_class 
    704704        else: 
    705705            class_index = 1 
     
    708708        if ignore_weights or not test_results.weights: 
    709709            for lr in test_results.results: 
    710                 isPositive=(lr.actual_class==class_index) 
     710                isPositive = (lr.actual_class == class_index) 
    711711                for i in range(test_results.number_of_learners): 
    712712                    tfpns[i].addTFPosNeg(lr.probabilities[i][class_index] > 
     
    714714        else: 
    715715            for lr in test_results.results: 
    716                 isPositive=(lr.actual_class == class_index) 
     716                isPositive = (lr.actual_class == class_index) 
    717717                for i in range(test_results.number_of_learners): 
    718                     tfpns[i].addTFPosNeg(lr.probabilities[i][class_index] >  
     718                    tfpns[i].addTFPosNeg(lr.probabilities[i][class_index] > 
    719719                                         cutoff, isPositive, lr.weight) 
    720720    else: 
     
    766766            if not e: 
    767767                return -1, -1, -1 
    768             ss += (o - e)**2 / e 
    769     df = (dim - 1)**2 
     768            ss += (o - e) ** 2 / e 
     769    df = (dim - 1) ** 2 
    770770    return ss, df, statc.chisqprob(ss, df) 
    771771 
     
    807807    @classmethod 
    808808    def compute(self, confusion_matrix): 
    809         tot = confusion_matrix.TP+confusion_matrix.FN 
     809        tot = confusion_matrix.TP + confusion_matrix.FN 
    810810        if tot < 1e-6: 
    811811            import warnings 
     
    831831    @classmethod 
    832832    def compute(self, confusion_matrix): 
    833         tot = confusion_matrix.FP+confusion_matrix.TN 
     833        tot = confusion_matrix.FP + confusion_matrix.TN 
    834834        if tot < 1e-6: 
    835835            import warnings 
     
    851851            warnings.warn("Can't compute PPV: one or both classes have no instances") 
    852852            return None 
    853         return confusion_matrix.TP/tot 
     853        return confusion_matrix.TP / tot 
    854854 
    855855 
     
    885885        p = Precision.compute(confusion_matrix) 
    886886        r = Recall.compute(confusion_matrix) 
    887         if p is not None and r is not None and (p+r) != 0: 
     887        if p is not None and r is not None and (p + r) != 0: 
    888888            return 2. * p * r / (p + r) 
    889889        else: 
     
    918918        # code by Boris Gorelik 
    919919        TP, TN, FP, FN = cm.TP, cm.TN, cm.FP, cm.FN 
    920            
     920 
    921921        try: 
    922             return (TP*TN - FP*FN) /\ 
    923                  math.sqrt((TP+FP) * (TP+FN) * (TN+ FP) * (TN+FN)) 
     922            return (TP * TN - FP * FN) / \ 
     923                 math.sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN)) 
    924924        except ZeroDivisionError: 
    925925            # Zero division occurs when there is either no true positives 
     
    991991@deprecated_keywords({"classIndex": "class_index", 
    992992                      "unweighted": "ignore_weights"}) 
    993 def AUCWilcoxon(res, class_index=-1, ignore_weights=False, **argkw): 
     993def AUCWilcoxon(res, class_index= -1, ignore_weights=False, **argkw): 
    994994    """Compute the area under ROC (AUC) and its standard error using 
    995995    Wilcoxon's approach proposed by Hanley and McNeal (1982). If  
     
    10151015            highPos -= thisPos 
    10161016            W += thisNeg * (highPos + thisPos / 2.) 
    1017             Q2 += thisPos * (lowNeg**2  + lowNeg*thisNeg  + thisNeg**2 / 3.) 
    1018             Q1 += thisNeg * (highPos**2 + highPos*thisPos + thisPos**2 / 3.) 
     1017            Q2 += thisPos * (lowNeg ** 2 + lowNeg * thisNeg + thisNeg ** 2 / 3.) 
     1018            Q1 += thisNeg * (highPos ** 2 + highPos * thisPos + thisPos ** 2 / 3.) 
    10191019 
    10201020            lowNeg += thisNeg 
    10211021 
    1022         W  /= (totPos*totNeg) 
    1023         Q1 /= (totNeg*totPos**2) 
    1024         Q2 /= (totPos*totNeg**2) 
    1025  
    1026         SE = math.sqrt((W * (1 - W) + (totPos - 1) * (Q1 - W**2) + 
    1027                        (totNeg - 1) * (Q2 - W**2)) / (totPos * totNeg)) 
     1022        W /= (totPos * totNeg) 
     1023        Q1 /= (totNeg * totPos ** 2) 
     1024        Q2 /= (totPos * totNeg ** 2) 
     1025 
     1026        SE = math.sqrt((W * (1 - W) + (totPos - 1) * (Q1 - W ** 2) + 
     1027                       (totNeg - 1) * (Q2 - W ** 2)) / (totPos * totNeg)) 
    10281028        results.append((W, SE)) 
    10291029    return results 
     
    10341034@deprecated_keywords({"classIndex": "class_index", 
    10351035                      "unweighted": "ignore_weights"}) 
    1036 def compare_2_AUCs(res, lrn1, lrn2, class_index=-1, 
     1036def compare_2_AUCs(res, lrn1, lrn2, class_index= -1, 
    10371037                   ignore_weights=False, **argkw): 
    10381038    return corn.compare2ROCs(res, lrn1, lrn2, class_index, 
     
    10401040 
    10411041# for backward compatibility, compare_2_AROCs is obsolete 
    1042 compare_2_AROCs = compare_2_AUCs  
     1042compare_2_AROCs = compare_2_AUCs 
    10431043 
    10441044 
    10451045@deprecated_keywords({"classIndex": "class_index"}) 
    1046 def compute_ROC(res, class_index=-1): 
     1046def compute_ROC(res, class_index= -1): 
    10471047    """Compute a ROC curve as a list of (x, y) tuples, where x is  
    10481048    1-specificity and y is sensitivity. 
     
    10541054 
    10551055    for plist in problists: 
    1056         curve=[(1., 1.)] 
     1056        curve = [(1., 1.)] 
    10571057        TP, TN = totPos, 0. 
    10581058        FN, FP = 0., totNeg 
     
    10711071        results.append(curve) 
    10721072 
    1073     return results     
     1073    return results 
    10741074 
    10751075## TC's implementation of algorithms, taken from: 
     
    11031103@deprecated_keywords({"classIndex": "class_index", 
    11041104                      "keepConcavities": "keep_concavities"}) 
    1105 def TC_compute_ROC(res, class_index=-1, keep_concavities=1): 
     1105def TC_compute_ROC(res, class_index= -1, keep_concavities=1): 
    11061106    problists, tots = corn.computeROCCumulative(res, class_index) 
    11071107 
     
    11141114        TP = 0. 
    11151115        FP = 0. 
    1116         curve=[] 
     1116        curve = [] 
    11171117        fPrev = 10e300 # "infinity" score at 0., 0. 
    11181118        for prob in plist: 
     
    11701170        else: 
    11711171            if abs(d - mind) <= 0.0001: ## close enough 
    1172                 closestPoints.append( (x, y, fscore) ) 
    1173     return closestPoints           
     1172                closestPoints.append((x, y, fscore)) 
     1173    return closestPoints 
    11741174 
    11751175def frange(start, end=None, inc=None): 
     
    11931193            break 
    11941194        L.append(next) 
    1195          
     1195 
    11961196    return L 
    11971197 
     
    12031203## returns the average ROC curve and an array of (vertical) standard deviations 
    12041204@deprecated_keywords({"ROCcurves": "roc_curves"}) 
    1205 def TC_vertical_average_ROC(roc_curves, samples = 10): 
     1205def TC_vertical_average_ROC(roc_curves, samples=10): 
    12061206    def INTERPOLATE((P1x, P1y, P1fscore), (P2x, P2y, P2fscore), X): 
    12071207        if (P1x == P2x) or P1x < X > P2x or P1x > X < P2x: 
     
    13101310            else: 
    13111311                stdv = 0. 
    1312             TPstdV.append( stdv ) 
     1312            TPstdV.append(stdv) 
    13131313            ## horizontal standard deviation 
    13141314            if len(FPsum) > 1: 
     
    13161316            else: 
    13171317                stdh = 0. 
    1318             TPstdH.append( stdh ) 
     1318            TPstdH.append(stdh) 
    13191319 
    13201320        average.append(TPavg) 
     
    13311331##  - noClassRugPoints is an array of (x, 0) points 
    13321332@deprecated_keywords({"classIndex": "class_index"}) 
    1333 def compute_calibration_curve(res, class_index=-1): 
     1333def compute_calibration_curve(res, class_index= -1): 
    13341334    ## merge multiple iterations into one 
    13351335    mres = Orange.evaluation.testing.ExperimentResults(1, res.classifier_names, 
     
    13461346 
    13471347    for plist in problists: 
    1348         yesClassRugPoints = []  
     1348        yesClassRugPoints = [] 
    13491349        noClassRugPoints = [] 
    13501350 
     
    13551355            noClassRugPoints.append((f, thisNeg)) # 1. 
    13561356 
    1357             index = int(f * bins ) 
     1357            index = int(f * bins) 
    13581358            index = min(index, bins - 1) ## just in case for value 1. 
    13591359            yesBinsVals[index] += thisPos 
     
    13681368            if allVal == 0.: continue 
    13691369            y = float(yesVal) / float(allVal) 
    1370             curve.append((f,  y)) 
     1370            curve.append((f, y)) 
    13711371 
    13721372        ## smooth the curve 
     
    13971397##    on the Lift Curve 
    13981398@deprecated_keywords({"classIndex": "class_index"}) 
    1399 def compute_lift_curve(res, class_index=-1): 
     1399def compute_lift_curve(res, class_index= -1): 
    14001400    ## merge multiple iterations into one 
    14011401    mres = Orange.evaluation.testing.ExperimentResults(1, res.classifier_names, 
     
    14281428  def __init__(self, C=0., D=0., T=0.): 
    14291429    self.C, self.D, self.T = C, D, T 
    1430     
     1430 
    14311431def is_CDT_empty(cdt): 
    14321432    return cdt.C + cdt.D + cdt.T < 1e-20 
     
    14351435@deprecated_keywords({"classIndex": "class_index", 
    14361436                      "unweighted": "ignore_weights"}) 
    1437 def compute_CDT(res, class_index=-1, ignore_weights=False, **argkw): 
     1437def compute_CDT(res, class_index= -1, ignore_weights=False, **argkw): 
    14381438    """Obsolete, don't use.""" 
    14391439    if class_index < 0: 
    1440         if res.baseClass >= 0: 
    1441             class_index = res.baseClass 
     1440        if res.base_class >= 0: 
     1441            class_index = res.base_class 
    14421442        else: 
    14431443            class_index = 1 
    1444              
     1444 
    14451445    useweights = res.weights and not ignore_weights 
    14461446    weightByClasses = argkw.get("weightByClasses", True) 
    14471447 
    1448     if res.number_of_iterations>1: 
     1448    if res.number_of_iterations > 1: 
    14491449        CDTs = [CDT() for _ in range(res.number_of_learners)] 
    14501450        iterationExperiments = split_by_iterations(res) 
     
    14581458            if is_CDT_empty(CDTs[0]): 
    14591459                return corn.computeCDT(res, class_index, useweights) 
    1460          
     1460 
    14611461        return CDTs 
    14621462    else: 
     
    15261526        super(AUC, self).__init__() 
    15271527 
    1528         self.ignore_weights=ignore_weights 
    1529         self.method=multiclass 
     1528        self.ignore_weights = ignore_weights 
     1529        self.method = multiclass 
    15301530 
    15311531        if test_results is not None: 
     
    16001600 
    16011601        if usefulClassPairs > 0: 
    1602             sum_aucs = [x/usefulClassPairs for x in sum_aucs] 
     1602            sum_aucs = [x / usefulClassPairs for x in sum_aucs] 
    16031603 
    16041604        return sum_aucs 
     
    16141614        subsum_aucs = [0.] * iterations[0].number_of_learners 
    16151615        for ite in iterations: 
    1616             aucs, foldsUsed = auc_computer(*(ite, ) + computer_args) 
     1616            aucs, foldsUsed = auc_computer(*(ite,) + computer_args) 
    16171617            if not aucs: 
    16181618                import warnings 
     
    16861686        Compute AUC using a :obj:`cdt_computer`. 
    16871687        """ 
    1688         cdts = cdt_computer(*(ite, ) + computer_args) 
     1688        cdts = cdt_computer(*(ite,) + computer_args) 
    16891689        if not is_CDT_empty(cdts[0]): 
    16901690            return [(cdt.C + cdt.T / 2) / (cdt.C + cdt.D + cdt.T) / 
     
    16921692 
    16931693        if all_ite: 
    1694             cdts = cdt_computer(*(all_ite, ) + computer_args) 
     1694            cdts = cdt_computer(*(all_ite,) + computer_args) 
    16951695            if not is_CDT_empty(cdts[0]): 
    16961696                return [(cdt.C + cdt.T / 2) / (cdt.C + cdt.D + cdt.T) 
     
    17041704    out and all other classes are treated as a single class. 
    17051705    """ 
    1706     def __init__(self, test_results=None, class_index=-1, ignore_weights=False): 
     1706    def __init__(self, test_results=None, class_index= -1, ignore_weights=False): 
    17071707        if class_index < 0: 
    17081708            if test_results and test_results.base_class >= 0: 
     
    18581858            su = mcm[l1][l2] + mcm[l2][l1] 
    18591859            if su: 
    1860                 mcm[l2][l1] = (abs(mcm[l1][l2] - mcm[l2][l1]) - 1)**2 / su 
     1860                mcm[l2][l1] = (abs(mcm[l1][l2] - mcm[l2][l1]) - 1) ** 2 / su 
    18611861            else: 
    18621862                mcm[l2][l1] = 0 
    18631863 
    18641864    for l1 in range(nLearners): 
    1865         mcm[l1]=mcm[l1][:l1] 
     1865        mcm[l1] = mcm[l1][:l1] 
    18661866 
    18671867    return mcm 
     
    18931893    su = tf + ft 
    18941894    if su: 
    1895         return (abs(tf - ft) - 1)**2 / su 
     1895        return (abs(tf - ft) - 1) ** 2 / su 
    18961896    else: 
    18971897        return 0 
     
    19051905    res_split = split_by_iterations(res) 
    19061906    res = [stat(r) for r in res_split] 
    1907      
     1907 
    19081908    N = len(res) 
    19091909    k = len(res[0]) 
     
    19181918    sums = [x / N for x in sums] 
    19191919 
    1920     F = 12. / (N * k * (k + 1)) * T  - 3 * N * (k + 1) 
     1920    F = 12. / (N * k * (k + 1)) * T - 3 * N * (k + 1) 
    19211921 
    19221922    return F, statc.chisqprob(F, k - 1), sums 
     
    19411941        for m2 in range(m1 + 1, k): 
    19421942            t, p = statc.wilcoxont([r[m1] for r in res], [r[m2] for r in res]) 
    1943             if avgranks[m1]<avgranks[m2]: 
     1943            if avgranks[m1] < avgranks[m2]: 
    19441944                nl.append(p) 
    1945             elif avgranks[m2]<avgranks[m1]: 
     1945            elif avgranks[m2] < avgranks[m1]: 
    19461946                nl.append(-p) 
    19471947            else: 
     
    19691969        file = open(file, "wt") 
    19701970        fopened = 1 
    1971          
     1971 
    19721972    file.write("set yrange [0:1]\n") 
    19731973    file.write("set xrange [%f:%f]\n" % (proportions[0], proportions[-1])) 
     
    19781978    for i in range(len(legend) - 1): 
    19791979        if not no_confidence: 
    1980             file.write("'-' title '' with yerrorbars pointtype %i,\\\n" % (i+1)) 
    1981         file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i+1)) 
     1980            file.write("'-' title '' with yerrorbars pointtype %i,\\\n" % (i + 1)) 
     1981        file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i + 1)) 
    19821982    if not no_confidence: 
    19831983        file.write("'-' title '' with yerrorbars pointtype %i,\\\n" % (len(legend))) 
     
    19871987        if not no_confidence: 
    19881988            for p in range(len(proportions)): 
    1989                 file.write("%f\t%f\t%f\n" % (proportions[p], CAs[p][i][0], 1.96*CAs[p][i][1])) 
     1989                file.write("%f\t%f\t%f\n" % (proportions[p], CAs[p][i][0], 1.96 * CAs[p][i][1])) 
    19901990            file.write("e\n\n") 
    19911991 
     
    20002000def print_single_ROC_curve_coordinates(file, curve): 
    20012001    import types 
    2002     fopened=0 
    2003     if type(file)==types.StringType: 
    2004         file=open(file, "wt") 
    2005         fopened=1 
     2002    fopened = 0 
     2003    if type(file) == types.StringType: 
     2004        file = open(file, "wt") 
     2005        fopened = 1 
    20062006 
    20072007    for coord in curve: 
     
    20142014def plot_ROC_learners(file, curves, learners): 
    20152015    plot_ROC(file, curves, [Orange.misc.getobjectname(learners[i], "Learner %i" % i) for i in range(len(learners))]) 
    2016      
     2016 
    20172017def plot_ROC(file, curves, legend): 
    20182018    import types 
    2019     fopened=0 
    2020     if type(file)==types.StringType: 
    2021         file=open(file, "wt") 
    2022         fopened=1 
     2019    fopened = 0 
     2020    if type(file) == types.StringType: 
     2021        file = open(file, "wt") 
     2022        fopened = 1 
    20232023 
    20242024    file.write("set yrange [0:1]\n") 
     
    20362036        file.write("e\n\n") 
    20372037 
    2038     file.write("1.0\t1.0\n0.0\t0.0e\n\n")           
     2038    file.write("1.0\t1.0\n0.0\t0.0e\n\n") 
    20392039 
    20402040    if fopened: 
     
    20432043 
    20442044@deprecated_keywords({"allResults": "all_results"}) 
    2045 def plot_McNemar_curve_learners(file, all_results, proportions, learners, reference=-1): 
     2045def plot_McNemar_curve_learners(file, all_results, proportions, learners, reference= -1): 
    20462046    plot_McNemar_curve(file, all_results, proportions, [Orange.misc.getobjectname(learners[i], "Learner %i" % i) for i in range(len(learners))], reference) 
    20472047 
    20482048 
    20492049@deprecated_keywords({"allResults": "all_results"}) 
    2050 def plot_McNemar_curve(file, all_results, proportions, legend, reference=-1): 
    2051     if reference<0: 
    2052         reference=len(legend)-1 
    2053          
     2050def plot_McNemar_curve(file, all_results, proportions, legend, reference= -1): 
     2051    if reference < 0: 
     2052        reference = len(legend) - 1 
     2053 
    20542054    import types 
    2055     fopened=0 
    2056     if type(file)==types.StringType: 
    2057         file=open(file, "wt") 
    2058         fopened=1 
    2059          
     2055    fopened = 0 
     2056    if type(file) == types.StringType: 
     2057        file = open(file, "wt") 
     2058        fopened = 1 
     2059 
    20602060    #file.write("set yrange [0:1]\n") 
    20612061    #file.write("set xrange [%f:%f]\n" % (proportions[0], proportions[-1])) 
    20622062    file.write("set multiplot\n\n") 
    20632063    file.write("plot \\\n") 
    2064     tmap=range(reference)+range(reference+1, len(legend)) 
     2064    tmap = range(reference) + range(reference + 1, len(legend)) 
    20652065    for i in tmap[:-1]: 
    2066         file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i+1)) 
     2066        file.write("'-' title '%s' with linespoints pointtype %i,\\\n" % (legend[i], i + 1)) 
    20672067    file.write("'-' title '%s' with linespoints pointtype %i\n" % (legend[tmap[-1]], tmap[-1])) 
    20682068    file.write("\n") 
     
    20762076        file.close() 
    20772077 
    2078 default_point_types=("{$\\circ$}", "{$\\diamond$}", "{$+$}", "{$\\times$}", "{$|$}")+tuple([chr(x) for x in range(97, 122)]) 
    2079 default_line_types=("\\setsolid", "\\setdashpattern <4pt, 2pt>", "\\setdashpattern <8pt, 2pt>", "\\setdashes", "\\setdots") 
     2078default_point_types = ("{$\\circ$}", "{$\\diamond$}", "{$+$}", "{$\\times$}", "{$|$}") + tuple([chr(x) for x in range(97, 122)]) 
     2079default_line_types = ("\\setsolid", "\\setdashpattern <4pt, 2pt>", "\\setdashpattern <8pt, 2pt>", "\\setdashes", "\\setdots") 
    20802080 
    20812081@deprecated_keywords({"allResults": "all_results"}) 
     
    20872087def learning_curve_to_PiCTeX(file, all_results, proportions, **options): 
    20882088    import types 
    2089     fopened=0 
    2090     if type(file)==types.StringType: 
    2091         file=open(file, "wt") 
    2092         fopened=1 
    2093  
    2094     nexamples=len(all_results[0].results) 
     2089    fopened = 0 
     2090    if type(file) == types.StringType: 
     2091        file = open(file, "wt") 
     2092        fopened = 1 
     2093 
     2094    nexamples = len(all_results[0].results) 
    20952095    CAs = [CA(x, report_se=True) for x in all_results] 
    20962096 
    2097     graphsize=float(options.get("graphsize", 10.0)) #cm 
    2098     difprop=proportions[-1]-proportions[0] 
    2099     ntestexamples=nexamples*proportions[-1] 
    2100     xunit=graphsize/ntestexamples 
    2101  
    2102     yshift=float(options.get("yshift", -ntestexamples/20.)) 
    2103      
    2104     pointtypes=options.get("pointtypes", default_point_types) 
    2105     linetypes=options.get("linetypes", default_line_types) 
     2097    graphsize = float(options.get("graphsize", 10.0)) #cm 
     2098    difprop = proportions[-1] - proportions[0] 
     2099    ntestexamples = nexamples * proportions[-1] 
     2100    xunit = graphsize / ntestexamples 
     2101 
     2102    yshift = float(options.get("yshift", -ntestexamples / 20.)) 
     2103 
     2104    pointtypes = options.get("pointtypes", default_point_types) 
     2105    linetypes = options.get("linetypes", default_line_types) 
    21062106 
    21072107    if options.has_key("numberedx"): 
    2108         numberedx=options["numberedx"] 
    2109         if type(numberedx)==types.IntType: 
    2110             if numberedx>0: 
    2111                 numberedx=[nexamples*proportions[int(i/float(numberedx)*len(proportions))] for i in range(numberedx)]+[proportions[-1]*nexamples] 
    2112             elif numberedx<0: 
     2108        numberedx = options["numberedx"] 
     2109        if type(numberedx) == types.IntType: 
     2110            if numberedx > 0: 
     2111                numberedx = [nexamples * proportions[int(i / float(numberedx) * len(proportions))] for i in range(numberedx)] + [proportions[-1] * nexamples] 
     2112            elif numberedx < 0: 
    21132113                numberedx = -numberedx 
    2114                 newn=[] 
    2115                 for i in range(numberedx+1): 
    2116                     wanted=proportions[0]+float(i)/numberedx*difprop 
    2117                     best=(10, 0) 
     2114                newn = [] 
     2115                for i in range(numberedx + 1): 
     2116                    wanted = proportions[0] + float(i) / numberedx * difprop 
     2117                    best = (10, 0) 
    21182118                    for t in proportions: 
    2119                         td=abs(wanted-t) 
    2120                         if td<best[0]: 
    2121                             best=(td, t) 
     2119                        td = abs(wanted - t) 
     2120                        if td < best[0]: 
     2121                            best = (td, t) 
    21222122                    if not best[1] in newn: 
    21232123                        newn.append(best[1]) 
    21242124                newn.sort() 
    2125                 numberedx=[nexamples*x for x in newn] 
    2126         elif type(numberedx[0])==types.FloatType: 
    2127             numberedx=[nexamples*x for x in numberedx] 
     2125                numberedx = [nexamples * x for x in newn] 
     2126        elif type(numberedx[0]) == types.FloatType: 
     2127            numberedx = [nexamples * x for x in numberedx] 
    21282128    else: 
    2129         numberedx=[nexamples*x for x in proportions] 
     2129        numberedx = [nexamples * x for x in proportions] 
    21302130 
    21312131    file.write("\\mbox{\n") 
    21322132    file.write("  \\beginpicture\n") 
    2133     file.write("  \\setcoordinatesystem units <%10.8fcm, %5.3fcm>\n\n" % (xunit, graphsize))     
    2134     file.write("  \\setplotarea x from %5.3f to %5.3f, y from 0 to 1\n" % (0, ntestexamples))     
     2133    file.write("  \\setcoordinatesystem units <%10.8fcm, %5.3fcm>\n\n" % (xunit, graphsize)) 
     2134    file.write("  \\setplotarea x from %5.3f to %5.3f, y from 0 to 1\n" % (0, ntestexamples)) 
    21352135    file.write("  \\axis bottom invisible\n")# label {#examples}\n") 
    2136     file.write("      ticks short at %s /\n" % reduce(lambda x,y:x+" "+y, ["%i"%(x*nexamples+0.5) for x in proportions])) 
     2136    file.write("      ticks short at %s /\n" % reduce(lambda x, y:x + " " + y, ["%i" % (x * nexamples + 0.5) for x in proportions])) 
    21372137    if numberedx: 
    2138         file.write("            long numbered at %s /\n" % reduce(lambda x,y:x+y, ["%i " % int(x+0.5) for x in numberedx])) 
     2138        file.write("            long numbered at %s /\n" % reduce(lambda x, y:x + y, ["%i " % int(x + 0.5) for x in numberedx])) 
    21392139    file.write("  /\n") 
    21402140    file.write("  \\axis left invisible\n")# label {classification accuracy}\n") 
     
    21462146        file.write("  \\setdashpattern<1pt, 1pt>\n") 
    21472147        file.write("  \\plot %5.3f %5.3f %5.3f %5.3f /\n" % (0., options["default"], ntestexamples, options["default"])) 
    2148      
     2148 
    21492149    for i in range(len(CAs[0])): 
    2150         coordinates=reduce(lambda x,y:x+" "+y, ["%i %5.3f" % (proportions[p]*nexamples, CAs[p][i][0]) for p in range(len(proportions))]) 
     2150        coordinates = reduce(lambda x, y:x + " " + y, ["%i %5.3f" % (proportions[p] * nexamples, CAs[p][i][0]) for p in range(len(proportions))]) 
    21512151        if linetypes: 
    21522152            file.write("  %s\n" % linetypes[i]) 
     
    21642164def legend_learners_to_PiCTeX(file, learners, **options): 
    21652165  return apply(legend_to_PiCTeX, (file, [Orange.misc.getobjectname(learners[i], "Learner %i" % i) for i in range(len(learners))]), options) 
    2166      
     2166 
    21672167def legend_to_PiCTeX(file, legend, **options): 
    21682168    import types 
    2169     fopened=0 
    2170     if type(file)==types.StringType: 
    2171         file=open(file, "wt") 
    2172         fopened=1 
    2173  
    2174     pointtypes=options.get("pointtypes", default_point_types) 
    2175     linetypes=options.get("linetypes", default_line_types) 
     2169    fopened = 0 
     2170    if type(file) == types.StringType: 
     2171        file = open(file, "wt") 
     2172        fopened = 1 
     2173 
     2174    pointtypes = options.get("pointtypes", default_point_types) 
     2175    linetypes = options.get("linetypes", default_line_types) 
    21762176 
    21772177    file.write("\\mbox{\n") 
     
    21832183        if linetypes: 
    21842184            file.write("  %s\n" % linetypes[i]) 
    2185             file.write("  \\plot %5.3f 6 %5.3f 6 /\n" % (i, i+0.2)) 
     2185            file.write("  \\plot %5.3f 6 %5.3f 6 /\n" % (i, i + 0.2)) 
    21862186        if pointtypes: 
    2187             file.write("  \\put {%s} at %5.3f 6\n" % (pointtypes[i], i+0.1)) 
    2188         file.write("  \\put {%s} [lb] at %5.3f 0\n" % (legend[i], i+0.25)) 
     2187            file.write("  \\put {%s} at %5.3f 6\n" % (pointtypes[i], i + 0.1)) 
     2188        file.write("  \\put {%s} [lb] at %5.3f 0\n" % (legend[i], i + 0.25)) 
    21892189 
    21902190    file.write("  \\endpicture\n") 
     
    22052205 
    22062206    def friedman(N, k, ranks): 
    2207         return 12*N*(sum([rank**2.0 for rank in ranks]) - (k*(k+1)*(k+1)/4.0) )/(k*(k+1)) 
     2207        return 12 * N * (sum([rank ** 2.0 for rank in ranks]) - (k * (k + 1) * (k + 1) / 4.0)) / (k * (k + 1)) 
    22082208 
    22092209    def iman(fried, N, k): 
    2210         return (N-1)*fried/(N*(k-1) - fried) 
     2210        return (N - 1) * fried / (N * (k - 1) - fried) 
    22112211 
    22122212    f = friedman(N, k, avranks) 
    22132213    im = iman(f, N, k) 
    2214     fdistdof = (k-1, (k-1)*(N-1)) 
    2215  
    2216     return (f, k-1), (im, fdistdof) 
     2214    fdistdof = (k - 1, (k - 1) * (N - 1)) 
     2215 
     2216    return (f, k - 1), (im, fdistdof) 
    22172217 
    22182218def compute_CD(avranks, N, alpha="0.05", type="nemenyi"): 
     
    22242224 
    22252225    k = len(avranks) 
    2226     
     2226 
    22272227    d = {("nemenyi", "0.05"): [0, 0, 1.959964, 2.343701, 2.569032, 2.727774, 
    22282228                               2.849705, 2.94832, 3.030879, 3.101730, 3.163684, 
     
    22432243    q = d[(type, alpha)] 
    22442244 
    2245     cd = q[k]*(k*(k+1)/(6.0*N))**0.5 
     2245    cd = q[k] * (k * (k + 1) / (6.0 * N)) ** 0.5 
    22462246 
    22472247    return cd 
    2248   
     2248 
    22492249 
    22502250def graph_ranks(filename, avranks, names, cd=None, cdmethod=None, lowv=None, highv=None, width=6, textspace=1, reverse=False, **kwargs): 
     
    22822282    textspace = float(textspace) 
    22832283 
    2284     def nth(l,n): 
     2284    def nth(l, n): 
    22852285        """ 
    22862286        Returns only nth elemnt in a list. 
    22872287        """ 
    2288         n = lloc(l,n) 
     2288        n = lloc(l, n) 
    22892289        return [ a[n] for a in l ] 
    22902290 
    2291     def lloc(l,n): 
     2291    def lloc(l, n): 
    22922292        """ 
    22932293        List location in list of list structure. 
     
    22962296        """ 
    22972297        if n < 0: 
    2298             return len(l[0])+n 
    2299         else: 
    2300             return n  
     2298            return len(l[0]) + n 
     2299        else: 
     2300            return n 
    23012301 
    23022302    def mxrange(lr): 
     
    23342334    sums = avranks 
    23352335 
    2336     tempsort =  sorted([ (a,i) for i,a in  enumerate(sums) ], reverse=reverse) 
     2336    tempsort = sorted([ (a, i) for i, a in  enumerate(sums) ], reverse=reverse) 
    23372337    ssums = nth(tempsort, 0) 
    23382338    sortidx = nth(tempsort, 1) 
    23392339    nnames = [ names[x] for x in sortidx ] 
    2340      
     2340 
    23412341    if lowv is None: 
    23422342        lowv = min(1, int(math.floor(min(ssums)))) 
     
    23512351 
    23522352    linesblank = 0 
    2353     scalewidth = width - 2*textspace 
     2353    scalewidth = width - 2 * textspace 
    23542354 
    23552355    def rankpos(rank): 
     
    23582358        else: 
    23592359            a = highv - rank 
    2360         return textspace+scalewidth/(highv-lowv)*a 
     2360        return textspace + scalewidth / (highv - lowv) * a 
    23612361 
    23622362    distanceh = 0.25 
    23632363 
    23642364    if cd and cdmethod is None: 
    2365      
     2365 
    23662366        #get pairs of non significant methods 
    23672367 
     
    23702370            #get all pairs 
    23712371            lsums = len(sums) 
    2372             allpairs = [ (i,j) for i,j in mxrange([[lsums], [lsums]]) if j > i ] 
     2372            allpairs = [ (i, j) for i, j in mxrange([[lsums], [lsums]]) if j > i ] 
    23732373            #remove not significant 
    2374             notSig = [ (i,j) for i,j in allpairs if abs(sums[i]-sums[j]) <= hsd ] 
     2374            notSig = [ (i, j) for i, j in allpairs if abs(sums[i] - sums[j]) <= hsd ] 
    23752375            #keep only longest 
    2376              
    2377             def no_longer((i,j), notSig): 
    2378                 for i1,j1 in notSig: 
     2376 
     2377            def no_longer((i, j), notSig): 
     2378                for i1, j1 in notSig: 
    23792379                    if (i1 <= i and j1 > j) or (i1 < i and j1 >= j): 
    23802380                        return False 
    23812381                return True 
    23822382 
    2383             longest = [ (i,j) for i,j in notSig if no_longer((i,j),notSig) ] 
    2384              
     2383            longest = [ (i, j) for i, j in notSig if no_longer((i, j), notSig) ] 
     2384 
    23852385            return longest 
    23862386 
    23872387        lines = get_lines(ssums, cd) 
    2388         linesblank = 0.2 + 0.2 + (len(lines)-1)*0.1 
     2388        linesblank = 0.2 + 0.2 + (len(lines) - 1) * 0.1 
    23892389 
    23902390        #add scale 
     
    23932393 
    23942394    #calculate height needed height of an image 
    2395     minnotsignificant = max(2*0.2, linesblank) 
    2396     height = cline + ((k+1)/2)*0.2 + minnotsignificant 
     2395    minnotsignificant = max(2 * 0.2, linesblank) 
     2396    height = cline + ((k + 1) / 2) * 0.2 + minnotsignificant 
    23972397 
    23982398    fig = Figure(figsize=(width, height)) 
    2399     ax = fig.add_axes([0,0,1,1]) #reverse y axis 
     2399    ax = fig.add_axes([0, 0, 1, 1]) #reverse y axis 
    24002400    ax.set_axis_off() 
    24012401 
    2402     hf = 1./height # height factor 
    2403     wf = 1./width 
    2404  
    2405     def hfl(l):  
    2406         return [ a*hf for a in l ] 
    2407  
    2408     def wfl(l):  
    2409         return [ a*wf for a in l ] 
     2402    hf = 1. / height # height factor 
     2403    wf = 1. / width 
     2404 
     2405    def hfl(l): 
     2406        return [ a * hf for a in l ] 
     2407 
     2408    def wfl(l): 
     2409        return [ a * wf for a in l ] 
    24102410 
    24112411 
    24122412    # Upper left corner is (0,0). 
    24132413 
    2414     ax.plot([0,1], [0,1], c="w") 
     2414    ax.plot([0, 1], [0, 1], c="w") 
    24152415    ax.set_xlim(0, 1) 
    24162416    ax.set_ylim(1, 0) 
     
    24202420        Input is a list of pairs of points. 
    24212421        """ 
    2422         ax.plot(wfl(nth(l,0)), hfl(nth(l,1)), color=color, **kwargs) 
     2422        ax.plot(wfl(nth(l, 0)), hfl(nth(l, 1)), color=color, **kwargs) 
    24232423 
    24242424    def text(x, y, s, *args, **kwargs): 
    2425         ax.text(wf*x, hf*y, s, *args, **kwargs) 
    2426  
    2427     line([(textspace, cline), (width-textspace, cline)], linewidth=0.7) 
    2428      
     2425        ax.text(wf * x, hf * y, s, *args, **kwargs) 
     2426 
     2427    line([(textspace, cline), (width - textspace, cline)], linewidth=0.7) 
     2428 
    24292429    bigtick = 0.1 
    24302430    smalltick = 0.05 
     
    24362436        tick = smalltick 
    24372437        if a == int(a): tick = bigtick 
    2438         line([(rankpos(a), cline-tick/2),(rankpos(a), cline)], linewidth=0.7) 
    2439  
    2440     for a in range(lowv, highv+1): 
    2441         text(rankpos(a), cline-tick/2-0.05, str(a), ha="center", va="bottom") 
     2438        line([(rankpos(a), cline - tick / 2), (rankpos(a), cline)], linewidth=0.7) 
     2439 
     2440    for a in range(lowv, highv + 1): 
     2441        text(rankpos(a), cline - tick / 2 - 0.05, str(a), ha="center", va="bottom") 
    24422442 
    24432443    k = len(ssums) 
    24442444 
    2445     for i in range((k+1)/2): 
    2446         chei = cline+ minnotsignificant + i *0.2 
    2447         line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace-0.1, chei)], linewidth=0.7) 
    2448         text(textspace-0.2, chei, nnames[i], ha="right", va="center") 
    2449  
    2450     for i in range((k+1)/2, k): 
    2451         chei = cline + minnotsignificant + (k-i-1)*0.2 
    2452         line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace+scalewidth+0.1, chei)], linewidth=0.7) 
    2453         text(textspace+scalewidth+0.2, chei, nnames[i], ha="left", va="center") 
     2445    for i in range((k + 1) / 2): 
     2446        chei = cline + minnotsignificant + i * 0.2 
     2447        line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace - 0.1, chei)], linewidth=0.7) 
     2448        text(textspace - 0.2, chei, nnames[i], ha="right", va="center") 
     2449 
     2450    for i in range((k + 1) / 2, k): 
     2451        chei = cline + minnotsignificant + (k - i - 1) * 0.2 
     2452        line([(rankpos(ssums[i]), cline), (rankpos(ssums[i]), chei), (textspace + scalewidth + 0.1, chei)], linewidth=0.7) 
     2453        text(textspace + scalewidth + 0.2, chei, nnames[i], ha="left", va="center") 
    24542454 
    24552455    if cd and cdmethod is None: 
     
    24572457        #upper scale 
    24582458        if not reverse: 
    2459             begin, end = rankpos(lowv), rankpos(lowv+cd) 
     2459            begin, end = rankpos(lowv), rankpos(lowv + cd) 
    24602460        else: 
    24612461            begin, end = rankpos(highv), rankpos(highv - cd) 
    2462              
     2462 
    24632463        line([(begin, distanceh), (end, distanceh)], linewidth=0.7) 
    2464         line([(begin, distanceh + bigtick/2), (begin, distanceh - bigtick/2)], linewidth=0.7) 
    2465         line([(end, distanceh + bigtick/2), (end, distanceh - bigtick/2)], linewidth=0.7) 
    2466         text((begin+end)/2, distanceh - 0.05, "CD", ha="center", va="bottom") 
     2464        line([(begin, distanceh + bigtick / 2), (begin, distanceh - bigtick / 2)], linewidth=0.7) 
     2465        line([(end, distanceh + bigtick / 2), (end, distanceh - bigtick / 2)], linewidth=0.7) 
     2466        text((begin + end) / 2, distanceh - 0.05, "CD", ha="center", va="bottom") 
    24672467 
    24682468        #non significance lines     
    24692469        def draw_lines(lines, side=0.05, height=0.1): 
    24702470            start = cline + 0.2 
    2471             for l,r in lines:   
    2472                 line([(rankpos(ssums[l])-side, start), (rankpos(ssums[r])+side, start)], linewidth=2.5)  
     2471            for l, r in lines: 
     2472                line([(rankpos(ssums[l]) - side, start), (rankpos(ssums[r]) + side, start)], linewidth=2.5) 
    24732473                start += height 
    24742474 
     
    24762476 
    24772477    elif cd: 
    2478         begin = rankpos(avranks[cdmethod]-cd) 
    2479         end = rankpos(avranks[cdmethod]+cd) 
    2480         line([(begin, cline), (end, cline)], linewidth=2.5)  
    2481         line([(begin, cline + bigtick/2), (begin, cline - bigtick/2)], linewidth=2.5) 
    2482         line([(end, cline + bigtick/2), (end, cline - bigtick/2)], linewidth=2.5) 
    2483   
     2478        begin = rankpos(avranks[cdmethod] - cd) 
     2479        end = rankpos(avranks[cdmethod] + cd) 
     2480        line([(begin, cline), (end, cline)], linewidth=2.5) 
     2481        line([(begin, cline + bigtick / 2), (begin, cline - bigtick / 2)], linewidth=2.5) 
     2482        line([(end, cline + bigtick / 2), (end, cline - bigtick / 2)], linewidth=2.5) 
     2483 
    24842484    print_figure(fig, filename, **kwargs) 
    24852485 
     
    24902490    :math:`HammingLoss(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{Y_i \\vartriangle Z_i}{|L|}` 
    24912491    """ 
    2492     losses = [0]*res.number_of_learners 
     2492    losses = [0] * res.number_of_learners 
    24932493    label_num = len(res.labels) 
    24942494    example_num = gettotsize(res) 
     
    25032503                if labels[j] != aclass[j]: 
    25042504                    losses[i] += 1 
    2505              
    2506     return [float(x)/(label_num*example_num) for x in losses] 
    2507  
    2508 def mlc_accuracy(res, forgiveness_rate = 1.0): 
     2505 
     2506    return [float(x) / (label_num * example_num) for x in losses] 
     2507 
     2508def mlc_accuracy(res, forgiveness_rate=1.0): 
    25092509    """ 
    25102510    Godbole & Sarawagi, 2004 uses the metrics accuracy, precision, recall as follows: 
     
    25172517    :math:`Accuracy(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} (\\frac{|Y_i \\cap Z_i|}{|Y_i \\cup Z_i|})^{\\alpha}` 
    25182518    """ 
    2519     accuracies = [0.0]*res.number_of_learners 
     2519    accuracies = [0.0] * res.number_of_learners 
    25202520    example_num = gettotsize(res) 
    2521      
     2521 
    25222522    for e in res.results: 
    25232523        aclass = e.actual_class 
     
    25262526            if len(labels) <> len(aclass): 
    25272527                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    2528              
     2528 
    25292529            intersection = 0.0 
    25302530            union = 0.0 
     
    25372537            if union: 
    25382538                accuracies[i] += intersection / union 
    2539              
    2540     return [math.pow(x/example_num,forgiveness_rate) for x in accuracies] 
     2539 
     2540    return [math.pow(x / example_num, forgiveness_rate) for x in accuracies] 
    25412541 
    25422542def mlc_precision(res): 
     
    25442544    :math:`Precision(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{|Y_i \\cap Z_i|}{|Z_i|}` 
    25452545    """ 
    2546     precisions = [0.0]*res.number_of_learners 
     2546    precisions = [0.0] * res.number_of_learners 
    25472547    example_num = gettotsize(res) 
    2548      
     2548 
    25492549    for e in res.results: 
    25502550        aclass = e.actual_class 
     
    25532553            if len(labels) <> len(aclass): 
    25542554                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    2555              
     2555 
    25562556            intersection = 0.0 
    25572557            predicted = 0.0 
     
    25632563            if predicted: 
    25642564                precisions[i] += intersection / predicted 
    2565              
    2566     return [x/example_num for x in precisions] 
     2565 
     2566    return [x / example_num for x in precisions] 
    25672567 
    25682568def mlc_recall(res): 
     
    25702570    :math:`Recall(H,D)=\\frac{1}{|D|} \\sum_{i=1}^{|D|} \\frac{|Y_i \\cap Z_i|}{|Y_i|}` 
    25712571    """ 
    2572     recalls = [0.0]*res.number_of_learners 
     2572    recalls = [0.0] * res.number_of_learners 
    25732573    example_num = gettotsize(res) 
    2574      
     2574 
    25752575    for e in res.results: 
    25762576        aclass = e.actual_class 
     
    25792579            if len(labels) <> len(aclass): 
    25802580                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    2581              
     2581 
    25822582            intersection = 0.0 
    25832583            actual = 0.0 
     
    25892589            if actual: 
    25902590                recalls[i] += intersection / actual 
    2591              
    2592     return [x/example_num for x in recalls] 
     2591 
     2592    return [x / example_num for x in recalls] 
    25932593 
    25942594#def mlc_ranking_loss(res): 
     
    26712671################################################################################ 
    26722672if __name__ == "__main__": 
    2673     avranks =  [3.143, 2.000, 2.893, 1.964] 
     2673    avranks = [3.143, 2.000, 2.893, 1.964] 
    26742674    names = ["prva", "druga", "tretja", "cetrta" ] 
    26752675    cd = compute_CD(avranks, 14) 
  • Orange/optimization/__init__.py

    r10582 r10633  
    194194        import string 
    195195        names = string.split(name, ".") 
    196         lastobj = self.object 
     196        lastobj = self.learner 
    197197        for i in names[:-1]: 
    198198            lastobj = getattr(lastobj, i) 
     
    269269        compare = getattr(self, "compare", cmp) 
    270270        return_what = getattr(self, "return_what", 
    271                              Tune1Parameter.returnClassifier) 
     271                             Tune1Parameter.RETURN_CLASSIFIER) 
    272272 
    273273        if (type(self.parameter) == list) or (type(self.parameter) == tuple): 
     
    278278        cvind = Orange.core.MakeRandomIndicesCV(data, folds) 
    279279        findBest = Orange.misc.selection.BestOnTheFly(seed=data.checksum(), 
    280                                          callCompareOn1st=True) 
     280                                         call_compare_on_1st=True) 
    281281        tableAndWeight = weight and (data, weight) or data 
    282282        for par in self.values: 
     
    284284                setattr(i[0], i[1], par) 
    285285            res = evaluate(Orange.evaluation.testing.test_with_indices( 
    286                                         [self.object], tableAndWeight, cvind)) 
     286                                        [self.learner], tableAndWeight, cvind)) 
    287287            findBest.candidate((res, par)) 
    288288            if verbose == 2: 
     
    296296            print "*** Optimal parameter: %s = %s" % (self.parameter, bestpar) 
    297297 
    298         if return_what == Tune1Parameter.returnNone: 
     298        if return_what == Tune1Parameter.RETURN_NONE: 
    299299            return None 
    300         elif return_what == Tune1Parameter.returnParameters: 
     300        elif return_what == Tune1Parameter.RETURN_PARAMETERS: 
    301301            return bestpar 
    302         elif return_what == Tune1Parameter.returnLearner: 
    303             return self.object 
    304         else: 
    305             classifier = self.object(data) 
     302        elif return_what == Tune1Parameter.RETURN_LEARNER: 
     303            return self.learner 
     304        else: 
     305            classifier = self.learner(data) 
    306306            if not Orange.utils.environ.orange_no_deprecated_members: 
    307307                classifier.setattr("fittedParameter", bestpar) 
     
    334334        compare = getattr(self, "compare", cmp) 
    335335        verbose = verbose or getattr(self, "verbose", 0) 
    336         return_what = getattr(self, "return_what", Tune1Parameter.returnClassifier) 
     336        return_what = getattr(self, "return_what", Tune1Parameter.RETURN_CLASSIFIER) 
    337337        progress_callback = getattr(self, "progress_callback", lambda i: None) 
    338338 
     
    350350        cvind = Orange.core.MakeRandomIndicesCV(data, folds) 
    351351        findBest = Orange.misc.selection.BestOnTheFly(seed=data.checksum(), 
    352                                          callCompareOn1st=True) 
     352                                         call_compare_on_1st=True) 
    353353        tableAndWeight = weight and (data, weight) or data 
    354354        numOfTests = sum([len(x[1]) for x in self.parameters]) 
     
    365365 
    366366            res = evaluate(Orange.evaluation.testing.test_with_indices( 
    367                                         [self.object], tableAndWeight, cvind)) 
     367                                        [self.learner], tableAndWeight, cvind)) 
    368368            if itercount in milestones: 
    369369                progress_callback(100.0 * itercount / numOfTests) 
     
    384384            print 
    385385 
    386         if return_what == Tune1Parameter.returnNone: 
     386        if return_what == Tune1Parameter.RETURN_NONE: 
    387387            return None 
    388         elif return_what == Tune1Parameter.returnParameters: 
     388        elif return_what == Tune1Parameter.RETURN_PARAMETERS: 
    389389            return bestpar 
    390         elif return_what == Tune1Parameter.returnLearner: 
    391             return self.object 
    392         else: 
    393             classifier = self.object(data) 
     390        elif return_what == Tune1Parameter.RETURN_LEARNER: 
     391            return self.learner 
     392        else: 
     393            classifier = self.learner(data) 
    394394            if Orange.utils.environ.orange_no_deprecated_members: 
    395395                classifier.fittedParameters = bestpar 
  • Orange/orng/orngMisc.py

    r10632 r10633  
    33import os.path 
    44 
    5 from Orange.misc.environ import install_dir 
     5from Orange.utils.environ import install_dir 
    66## -> Orange.misc 
    77 
  • Orange/testing/regression/tests/test_auc.py

    r10175 r10633  
    1010        prob = [random.random() for _ in data.domain.class_var.values] 
    1111        sprob = sum(prob) 
    12         prob = [i/sprob for i in prob] 
     12        prob = [i / sprob for i in prob] 
    1313        distribution.Discrete(prob) 
    1414        return data.domain.class_var[0], prob 
     
    3838measures = ( 
    3939    (lambda x:auc(x), "AUC"), 
    40     (lambda x:auc(x, method=0), "AUC+M0"), 
    41     (lambda x:auc(x, method=1), "AUC+M1"), 
    42     (lambda x:auc(x, method=2), "AUC+M2"), 
    43     (lambda x:auc(x, method=3), "AUC+M3"), 
     40    (lambda x:auc(x, multiclass=0), "AUC+M0"), 
     41    (lambda x:auc(x, multiclass=1), "AUC+M1"), 
     42    (lambda x:auc(x, multiclass=2), "AUC+M2"), 
     43    (lambda x:auc(x, multiclass=3), "AUC+M3"), 
    4444) 
    4545 
    4646tests = ( 
    47     (lambda l, ds: testing.cross_validation([l],ds), "CV"), 
     47    (lambda l, ds: testing.cross_validation([l], ds), "CV"), 
    4848    (lambda l, ds: testing.proportion_test([l], ds, .7, 1), "Proportion test"), 
    4949) 
  • Orange/utils/render.py

    r10630 r10633  
    1616import os.path 
    1717 
    18 from Orange.misc.environ import install_dir 
     18from Orange.utils.environ import install_dir 
    1919 
    2020class GeneratorContextManager(object): 
  • docs/reference/rst/code/ensemble-forest.py

    r9823 r10633  
    88 
    99forest = Orange.ensemble.forest.RandomForestLearner(trees=50, name="forest") 
    10 tree = Orange.classification.tree.TreeLearner(minExamples=2, mForPrunning=2, \ 
    11                             sameMajorityPruning=True, name='tree') 
     10tree = Orange.classification.tree.TreeLearner(min_instances=2, m_pruning=2, \ 
     11                            same_majority_pruning=True, name='tree') 
    1212learners = [tree, forest] 
    1313 
     
    1818for i in range(len(learners)): 
    1919    print "%-8s %5.3f  %5.3f  %5.3f" % (learners[i].name, \ 
    20         Orange.evaluation.scoring.CA(results)[i],  
     20        Orange.evaluation.scoring.CA(results)[i], 
    2121        Orange.evaluation.scoring.Brier_score(results)[i], 
    2222        Orange.evaluation.scoring.AUC(results)[i]) 
  • docs/reference/rst/code/ensemble-forest2.py

    r9638 r10633  
    1010 
    1111tree = Orange.classification.tree.TreeLearner() 
    12 tree.minExamples = 5 
    13 tree.maxDepth = 5 
     12tree.min_instances = 5 
     13tree.max_depth = 5 
    1414 
    1515forest_learner = Orange.ensemble.forest.RandomForestLearner(base_learner=tree, trees=50, attributes=3) 
  • docs/reference/rst/code/imputation-complex.py

    r10071 r10633  
    7373 
    7474imputer = Orange.feature.imputation.ModelConstructor() 
    75 imputer.learner_continuous = imputer.learner_discrete = Orange.classification.tree.TreeLearner(minSubset=20) 
     75imputer.learner_continuous = imputer.learner_discrete = Orange.classification.tree.TreeLearner(min_subset=20) 
    7676imputer = imputer(bridges) 
    7777print "Example w/ missing values" 
     
    115115len_domain = Orange.data.Domain(["MATERIAL", "SPAN", "ERECTED", "LENGTH"], bridges.domain) 
    116116len_data = Orange.data.Table(len_domain, bridges) 
    117 len_tree = Orange.classification.tree.TreeLearner(len_data, minSubset=20) 
     117len_tree = Orange.classification.tree.TreeLearner(len_data, min_subset=20) 
    118118imputer.models[bridges.domain.index("LENGTH")] = len_tree 
    119119print len_tree 
     
    146146    print "%s: %s -> %s" % (original.domain[i].name, original[i], imputed[i.name]), 
    147147    if original.domain[i].var_type == Orange.feature.Type.Continuous: 
    148         print "(%s)" % imputed[i.name+"_def"] 
     148        print "(%s)" % imputed[i.name + "_def"] 
    149149    else: 
    150150        print 
  • docs/reference/rst/code/logreg-singularities.py

    r9823 r10633  
    22 
    33adult = Orange.data.Table("adult_sample") 
    4 lr = Orange.classification.logreg.LogRegLearner(adult, removeSingular=1) 
     4lr = Orange.classification.logreg.LogRegLearner(adult, remove_singular=1) 
    55 
    66for ex in adult[:5]: 
  • docs/reference/rst/code/mds-advanced.py

    r9946 r10633  
    1515matrix = Orange.misc.SymMatrix(len(iris)) 
    1616for i in range(len(iris)): 
    17    for j in range(i+1): 
     17   for j in range(i + 1): 
    1818       matrix[i, j] = dist(iris[i], iris[j]) 
    1919 
    2020# Run the Torgerson approximation and calculate stress 
    2121mds = Orange.projection.mds.MDS(matrix) 
    22 mds.Torgerson() 
     22mds.torgerson() 
    2323mds.calc_stress(Orange.projection.mds.KruskalStress) 
    2424 
     
    2727    old_stress = mds.avg_stress 
    2828    for j in range(10): 
    29         mds.SMACOFstep() 
     29        mds.smacof_step() 
    3030 
    3131    mds.calc_stress(Orange.projection.mds.KruskalStress) 
  • docs/reference/rst/code/mds-euclid-torgerson-3d.py

    r9891 r10633  
    2020# Run the MDS 
    2121mds = Orange.projection.mds.MDS(matrix, dim=3) 
    22 mds.Torgerson() 
     22mds.torgerson() 
    2323 
    2424# Print a few points 
  • docs/reference/rst/code/selection-filtered-learner.py

    r9823 r10633  
    1212 
    1313nb = Orange.classification.bayes.NaiveLearner() 
    14 fl = Orange.feature.selection.FilteredLearner(nb,  
     14fl = Orange.feature.selection.FilteredLearner(nb, 
    1515     filter=Orange.feature.selection.FilterBestNAtts(n=1), name='filtered') 
    1616learners = (Orange.classification.bayes.NaiveLearner(name='bayes'), fl) 
    17 results = orngTest.crossValidation(learners, voting, storeClassifiers=1) 
     17results = orngTest.crossValidation(learners, voting, store_classifiers=1) 
    1818 
    1919# output the results 
  • docs/reference/rst/code/som-mapping.py

    r10455 r10633  
    1515 
    1616print "Node    Instances" 
    17 print "\n".join(["%s  %d" % (str(n.pos), len(n.examples)) for n in map]) 
     17print "\n".join(["%s  %d" % (str(n.pos), len(n.instances)) for n in map]) 
    1818 
    1919i, j = 0, 1 
    2020print 
    2121print "Data instances in cell (%d, %d):" % (i, j) 
    22 for e in map[i, j].examples: 
     22for e in map[i, j].instances: 
    2323    print e 
  • docs/reference/rst/code/som-node.py

    r9372 r10633  
    1111 
    1212print "Node position: (%d, %d)" % node.pos 
    13 print "Data instances in the node:", len(node.examples) 
     13print "Data instances in the node:", len(node.instances) 
  • docs/reference/rst/code/statExamples.py

    r10429 r10633  
    66import Orange 
    77 
    8 learners = [ Orange.classification.bayes.NaiveLearner(name = "bayes"), 
     8learners = [ Orange.classification.bayes.NaiveLearner(name="bayes"), 
    99             Orange.classification.tree.TreeLearner(name="tree"), 
    1010             Orange.classification.majority.MajorityLearner(name="majrty")] 
     
    2929 
    3030 
    31 CAs = Orange.evaluation.scoring.CA(res, reportSE=True) 
    32 APs = Orange.evaluation.scoring.AP(res, reportSE=True) 
    33 Briers = Orange.evaluation.scoring.Brier_score(res, reportSE=True) 
    34 ISs = Orange.evaluation.scoring.IS(res, reportSE=True) 
     31CAs = Orange.evaluation.scoring.CA(res, report_se=True) 
     32APs = Orange.evaluation.scoring.AP(res, report_se=True) 
     33Briers = Orange.evaluation.scoring.Brier_score(res, report_se=True) 
     34ISs = Orange.evaluation.scoring.IS(res, report_se=True) 
    3535 
    3636print 
    3737print "method\tCA\tAP\tBrier\tIS" 
    3838for l in range(len(learners)): 
    39     print "%s\t%5.3f+-%5.3f\t%5.3f+-%5.3f\t%5.3f+-%5.3f\t%6.3f+-%5.3f" % ((learners[l].name, ) + CAs[l] + APs[l] + Briers[l] + ISs[l]) 
     39    print "%s\t%5.3f+-%5.3f\t%5.3f+-%5.3f\t%5.3f+-%5.3f\t%6.3f+-%5.3f" % ((learners[l].name,) + CAs[l] + APs[l] + Briers[l] + ISs[l]) 
    4040 
    4141 
     
    6363cm = Orange.evaluation.scoring.confusion_matrices(resVeh)[0] 
    6464classes = vehicle.domain.class_var.values 
    65 print "\t"+"\t".join(classes) 
     65print "\t" + "\t".join(classes) 
    6666for className, classConfusions in zip(classes, cm): 
    67     print ("%s" + ("\t%i" * len(classes))) % ((className, ) + tuple(classConfusions)) 
     67    print ("%s" + ("\t%i" * len(classes))) % ((className,) + tuple(classConfusions)) 
    6868 
    6969cm = Orange.evaluation.scoring.confusion_matrices(res) 
     
    105105for i in range(4): 
    106106    AUCs = Orange.evaluation.scoring.AUC(resVeh, i) 
    107     print "%25s: \t%5.3f\t%5.3f\t%5.3f" % ((methods[i], ) + tuple(AUCs)) 
     107    print "%25s: \t%5.3f\t%5.3f\t%5.3f" % ((methods[i],) + tuple(AUCs)) 
    108108 
    109109 
     
    113113print 
    114114print "AUC for detecting class 'van' in 'vehicle'" 
    115 AUCs = Orange.evaluation.scoring.AUC_single(resVeh, classIndex = vehicle.domain.class_var.values.index("van")) 
     115AUCs = Orange.evaluation.scoring.AUC_single(resVeh, class_index=vehicle.domain.class_var.values.index("van")) 
    116116print "%5.3f\t%5.3f\t%5.3f" % tuple(AUCs) 
    117117 
    118118print 
    119119print "AUCs for detecting various classes in 'vehicle'" 
    120 for c,s in enumerate(classes): 
    121     print "%s (%5.3f) vs others: \t%5.3f\t%5.3f\t%5.3f" % ((s, classDist[c] ) + tuple(Orange.evaluation.scoring.AUC_single(resVeh, c))) 
     120for c, s in enumerate(classes): 
     121    print "%s (%5.3f) vs others: \t%5.3f\t%5.3f\t%5.3f" % ((s, classDist[c]) + tuple(Orange.evaluation.scoring.AUC_for_single_class(resVeh, c))) 
    122122 
    123123print 
    124124classes = vehicle.domain.class_var.values 
    125125AUCmatrix = Orange.evaluation.scoring.AUC_matrix(resVeh)[0] 
    126 print "\t"+"\t".join(classes[:-1]) 
     126print "\t" + "\t".join(classes[:-1]) 
    127127for className, AUCrow in zip(classes[1:], AUCmatrix[1:]): 
    128     print ("%s" + ("\t%5.3f" * len(AUCrow))) % ((className, ) + tuple(AUCrow)) 
     128    print ("%s" + ("\t%5.3f" * len(AUCrow))) % ((className,) + tuple(AUCrow)) 
    129129 
    130130print 
     
    132132for c1, s1 in enumerate(classes): 
    133133    for c2 in range(c1): 
    134         print "%s vs %s: \t%5.3f\t%5.3f\t%5.3f" % ((s1, classes[c2]) + tuple(Orange.evaluation.scoring.AUC_pair(resVeh, c1, c2))) 
     134        print "%s vs %s: \t%5.3f\t%5.3f\t%5.3f" % ((s1, classes[c2]) + tuple(Orange.evaluation.scoring.AUC_for_pair_of_classes(resVeh, c1, c2))) 
    135135 
    136136 
  • docs/reference/rst/code/testing-test.py

    r9946 r10633  
    1313def printResults(res): 
    1414    CAs = Orange.evaluation.scoring.CA(res, report_se=1) 
    15     for name, ca in zip(res.classifierNames, CAs): 
     15    for name, ca in zip(res.classifier_names, CAs): 
    1616        print "%s: %5.3f+-%5.3f" % (name, ca[0], 1.96 * ca[1]), 
    1717    print 
     
    4141print "\nproportionsTest + storing classifiers" 
    4242res = Orange.evaluation.testing.proportion_test(learners, voting, 0.7, 100, 
    43     storeClassifiers=1) 
     43    store_classifiers=1) 
    4444print "#iter %i, #classifiers %i" % \ 
    4545    (len(res.classifiers), len(res.classifiers[0])) 
  • docs/reference/rst/code/tree_c45.py

    r9823 r10633  
    1919    print tree(i), i.getclass() 
    2020 
    21 print "\n\nC4.5 with minObjs=100" 
    22 tree = Orange.classification.tree.C45Learner(iris, minObjs=100) 
     21print "\n\nC4.5 with min_objs=100" 
     22tree = Orange.classification.tree.C45Learner(iris, min_objs=100) 
    2323for i in iris[:5]: 
    2424    print tree(i), i.getclass() 
     
    3737 
    3838 
    39 res = Orange.evaluation.testing.cross_validation([Orange.classification.tree.C45Learner(),  
     39res = Orange.evaluation.testing.cross_validation([Orange.classification.tree.C45Learner(), 
    4040    Orange.classification.tree.C45Learner(convertToOrange=1)], iris) 
    4141print "Classification accuracy: %5.3f (converted to tree: %5.3f)" % tuple(Orange.evaluation.scoring.CA(res)) 
Note: See TracChangeset for help on using the changeset viewer.