Commits

Miha Stajdohar committed 00f7801

Bugs, bugs, bugs...

Comments (0)

Files changed (5)

_modelmaps/__init__.py

 import numpy as np
 
 from orngScaleData import getVariableValuesSorted
-from OWDistanceFile import readMatrix
+#from OWDistanceFile import readMatrix
 
 from Orange import data, feature
 
 #OUT_FILE = ROOT + "dst/zoo"
 OUT_FILE = ROOT + "_astra_/fprdk"
 
-def saveSymMatrix(matrix, file, items=None, saveItems=False):
-    fn = open(file + ".dst", 'w')
-    fn.write("%d labeled\n" % matrix.dim)
-    items = items if items else matrix.items
-    for i in range(matrix.dim):
-        fn.write("%s" % items[i]['attributes'])
-        for j in range(i + 1):
-            fn.write("\t%.6f" % matrix[i, j])
-        fn.write("\n")
-
-    fn.close()
-    if saveItems:
-        items.save(file + ".tab")
-
-
-
-def loadModel(fn):
-    if os.path.exists('%s.npy' % fn):
-        matrix, _labels, data = readMatrix('%s.npy' % fn)
-    elif os.path.exists("%s-prob.dst" % fn):
-        matrix, _labels, data = readMatrix("%s-prob.dst" % fn)
-    elif os.path.exists("%s.dst" % fn):
-        matrix, _labels, data = readMatrix("%s.dst" % fn)
-    else:
-        return None
-
-    if os.path.exists("%s.tab" % fn):
-        data = data.Table("%s.tab" % fn)
-        matrix.items = data
-    else:
-        print "ExampleTable %s not found!\n" % ("%s.tab" % fn)
-    if os.path.exists("%s.res" % fn):
-        matrix.results = pickle.load(open("%s.res" % fn, 'rb'))
-    else:
-        print "Results pickle %s not found!\n" % ("%s.res" % fn)
-
-    return matrix
-
-def saveModel(smx, fn):
-    saveSymMatrix(smx, "%s" % fn, smx.items)
-    smx.items.save('%s.tab' % fn)
-    pickle.dump(smx.results, open('%s.res' % fn, "wb"))
+#def saveSymMatrix(matrix, file, items=None, saveItems=False):
+#    fn = open(file + ".dst", 'w')
+#    fn.write("%d labeled\n" % matrix.dim)
+#    items = items if items else matrix.items
+#    for i in range(matrix.dim):
+#        fn.write("%s" % items[i]['attributes'])
+#        for j in range(i + 1):
+#            fn.write("\t%.6f" % matrix[i, j])
+#        fn.write("\n")
+#
+#    fn.close()
+#    if saveItems:
+#        items.save(file + ".tab")
+#
+#
+#
+#def loadModel(fn):
+#    if os.path.exists('%s.npy' % fn):
+#        matrix, _labels, data = readMatrix('%s.npy' % fn)
+#    elif os.path.exists("%s-prob.dst" % fn):
+#        matrix, _labels, data = readMatrix("%s-prob.dst" % fn)
+#    elif os.path.exists("%s.dst" % fn):
+#        matrix, _labels, data = readMatrix("%s.dst" % fn)
+#    else:
+#        return None
+#
+#    if os.path.exists("%s.tab" % fn):
+#        data = data.Table("%s.tab" % fn)
+#        matrix.items = data
+#    else:
+#        print "ExampleTable %s not found!\n" % ("%s.tab" % fn)
+#    if os.path.exists("%s.res" % fn):
+#        matrix.results = pickle.load(open("%s.res" % fn, 'rb'))
+#    else:
+#        print "Results pickle %s not found!\n" % ("%s.res" % fn)
+#
+#    return matrix
+#
+#def saveModel(smx, fn):
+#    saveSymMatrix(smx, "%s" % fn, smx.items)
+#    smx.items.save('%s.tab' % fn)
+#    pickle.dump(smx.results, open('%s.res' % fn, "wb"))
 
 
 

_modelmaps/modelmap.py

 from orngScaleData import getVariableValuesSorted
 from model import Model
 
-from Orange import data, distance, feature, ensemble
+from Orange import data, distance, ensemble, feature, misc
 from Orange.classification.knn import kNNLearner
 from Orange.classification.tree import TreeLearner
 
     
     :param nsubsets:  number of attribute subsets
     :type nsubsets: int
+    
     """
 
     def binomial(n, k):
 
         dim = len(models)
         print "%d models to matrix -- rank" % dim
-        smx = np.zeros(shape=(dim, dim))
+#        smx = np.zeros(shape=(dim, dim))
+#        counter = 0
+#        time_start = time.time()
+#        for i in range(dim):
+#            for j in range(i):
+#                smx[i, j] = dist(models[i], models[j])
+#                counter += 1
+#                self._print_time(time_start, counter, dim)
 
-        counter = 0
-        time_start = time.time()
-        for i in range(dim):
-            for j in range(i):
-                smx[i, j] = dist(models[i], models[j])
-                counter += 1
-                self._print_time(time_start, counter, dim)
-
+        smx = misc.SymMatrix([[dist(models[i], models[j]) for j in range(i)] for i in range(dim)])
         return smx
 
     def build_model_data(self, models):

_modelmaps/widgets/OWModelFile.py

         self.model_data = None
         self.original_data = None
         pb = OWGUI.ProgressBar(self, 100)
-
+        pb.advance()
         self.error()
         try:
             matrix, self.model_data, self.original_data = pickle.load(bz2.BZ2File('%s' % fn, "r"))
-
-            self.matrix = misc.SymMatrix(len(matrix))
-            milestones = orngMisc.progressBarMilestones(self.matrix.dim, 100)
-            for i in range(self.matrix.dim):
-                for j in range(i + 1):
-                    self.matrix[j, i] = matrix[i, j]
-
-                if i in milestones:
-                    pb.advance()
-            pb.finish()
+            if type(matrix) == type(misc.SymMatrix(1)):
+                self.matrix = matrix
+            else:
+                try:
+                    self.matrix = misc.SymMatrix(matrix)
+                except TypeError:
+                    self.matrix = misc.SymMatrix(matrix + matrix.T)
 
         except Exception, ex:
             self.error("Error while reading the file: '%s'" % str(ex))
             return
+
+        pb.finish()
         self.relabel()
 
     def relabel(self):

_modelmaps/widgets/OWModelMap.py

 <contact>Miha Stajdohar (miha.stajdohar(@at@)gmail.com)</contact> 
 <priority>6520</priority>
 """
-import os.path
+import os.path, itertools
 from operator import itemgetter
 
-import OWToolbars
-import OWColorPalette
+#import OWToolbars
+#import OWColorPalette
 
-from Orange import classification, data, feature, misc, modelmaps
+from Orange import classification, data, feature, misc, modelmaps, network
+from Orange.network.community import CommunityDetection
 from OWNxCanvasQt import OWNxCanvas
 
 from orngScaleLinProjData import *
     def __init__(self, parent=None, pen=QPen(Qt.black), xData=None, yData=None):
         NetworkCurve.__init__(self, parent, pen=QPen(Qt.black), xData=None, yData=None)
 
-    def draw(self, painter, xMap, yMap, rect):
-        for edge in self.edges:
-            if edge.u.show and edge.v.show:
-                painter.setPen(edge.pen)
-
-                px1 = xMap.transform(self.coors[0][edge.u.index])   #ali pa tudi self.x1, itd
-                py1 = yMap.transform(self.coors[1][edge.u.index])
-                px2 = xMap.transform(self.coors[0][edge.v.index])
-                py2 = yMap.transform(self.coors[1][edge.v.index])
-
-                painter.drawLine(px1, py1, px2, py2)
-
-                d = 12
-                #painter.setPen(QPen(Qt.lightGray, 1))
-                painter.setBrush(Qt.lightGray)
-                if edge.arrowu:
-                    x = px1 - px2
-                    y = py1 - py2
-
-                    fi = math.atan2(y, x) * 180 * 16 / math.pi
-
-                    if not fi is None:
-                        # (180*16) - fi - (20*16), (40*16)
-                        painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640)
-
-                if edge.arrowv:
-                    x = px1 - px2
-                    y = py1 - py2
-
-                    fi = math.atan2(y, x) * 180 * 16 / math.pi
-                    if not fi is None:
-                        # (180*16) - fi - (20*16), (40*16)
-                        painter.drawPie(px1 - d, py1 - d, 2 * d, 2 * d, 2560 - fi, 640)
-
-                if self.showEdgeLabels and len(edge.label) > 0:
-                    lbl = ', '.join(edge.label)
-                    x = (px1 + px2) / 2
-                    y = (py1 + py2) / 2
-
-                    th = painter.fontMetrics().height()
-                    tw = painter.fontMetrics().width(lbl)
-                    r = QRect(x - tw / 2, y - th / 2, tw, th)
-                    painter.fillRect(r, QBrush(Qt.white))
-                    painter.drawText(r, Qt.AlignHCenter + Qt.AlignVCenter, lbl)
-
-        for vertex in self.vertices:
-            if vertex.show:
-                pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer)
-                pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa
-                style = (1 - vertex.style) * 2 * 100
-                #print style
-                #style=-50
-                #if vertex.highlight:
-                #    painter.setPen(QPen(QBrush(QColor(255,   0,   0, 192)), 1, Qt.SolidLine, Qt.RoundCap))
-                #else:
-                #    #oldcolor = QColor(125, 162, 206, 192)
-                painter.setPen(QPen(QBrush(vertex.color), 1, Qt.SolidLine, Qt.RoundCap))
-
-                if vertex.selected:
-                    size = int(vertex.size) + 5
-                    brushColor = QColor(Qt.yellow)
-                    brushColor.setAlpha(150)
-                    gradient = QRadialGradient(QPointF(pX, pY), size)
-                    gradient.setColorAt(0., brushColor)
-                    gradient.setColorAt(1., QColor(255, 255, 255, 0))
-                    painter.setBrush(QBrush(gradient))
-                    painter.drawRoundedRect(pX - size / 2, pY - size / 2, size, size, style, style, Qt.RelativeSize)
-                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size)
-                elif vertex.marked:
-                    size = int(vertex.size) + 5
-                    brushColor = QColor(Qt.cyan)
-                    brushColor.setAlpha(80)
-                    gradient = QRadialGradient(QPointF(pX, pY), size)
-                    gradient.setColorAt(0., brushColor)
-                    gradient.setColorAt(1., QColor(255, 255, 255, 0))
-                    painter.setBrush(QBrush(gradient))
-                    painter.drawRoundedRect(pX - size / 2, pY - size / 2, size, size, style, style, Qt.RelativeSize)
-                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size)
-                else:
-                    size = int(vertex.size) + 5
-                    gradient = QRadialGradient(QPointF(pX, pY), size)
-                    #gradient.setColorAt(0., QColor(217, 232, 252, 192))
-                    gradient.setColorAt(0., vertex.color)
-                    gradient.setColorAt(1., QColor(255, 255, 255, 0))
-                    painter.setBrush(QBrush(gradient))
-                    painter.drawRoundedRect(pX - size / 2, pY - size / 2, size, size, style, style, Qt.RelativeSize)
-                    #painter.drawEllipse(pX - size/2, pY - size/2, size, size)
-
-        for vertex in self.vertices:
-            if vertex.show:
-                pX = xMap.transform(self.coors[0][vertex.index])   #dobimo koordinati v pikslih (tipa integer)
-                pY = yMap.transform(self.coors[1][vertex.index])   #ki se stejeta od zgornjega levega kota canvasa
-#               
-                if vertex.image:
-                    size = vertex.image.size().width()
-                    painter.drawImage(QRect(pX - size / 2, pY - size / 2, size, size), vertex.image)
-
 class OWModelMapCanvas(OWNxCanvas):
 
     def __init__(self, master, parent=None, name="None"):
                                                         for node in self.graph))
 
     def loadIcons(self):
-        items = self.graph.items()
+        items = self.items
         maxsize = str(max(map(int, ICON_SIZES)))
         minsize = min(map(int, ICON_SIZES))
         for v in self.networkCurve.nodes().itervalues():
                 PIXMAP_CACHE[fn] = QPixmap(fn)
             v.set_image(PIXMAP_CACHE[fn])
 
+    def set_representatives(self, node_keys):
+        nodes = self.networkCurve.nodes()
+        map(ModelItem.set_representative, [nodes[i] for i in node_keys])
+
+
+class ModelClusterView(network.NxView):
+    """A network view expanding and contracting nodes that represent model 
+    communities. 
+    
+    """
+
+    def __init__(self, community_detection):
+        network.NxView.__init__(self)
+
+        self._community_detection = community_detection
+        self._representatives = None
+        self._expanded_nodes = set()
+
+    def __del__(self):
+        if self._nx_explorer is not None:
+            QObject.disconnect(self._nx_explorer.networkCanvas, SIGNAL('point_rightclicked(Point*)'), self.hierarchical_expand)
+
+    def set_nx_explorer(self, _nx_explorer):
+        network.NxView.set_nx_explorer(self, _nx_explorer)
+
+        if self._nx_explorer is not None:
+            QObject.connect(self._nx_explorer.networkCanvas, SIGNAL('point_rightclicked(Point*)'), self.hierarchical_expand)
+
+    def update_network(self):
+        if self._nx_explorer is not None and self._network is not None:
+            subnet = self._network
+            self._nx_explorer.change_graph(subnet)
+
+    def init_network(self, graph):
+        self._network = graph
+
+        if graph is None or self._community_detection is None:
+            return None
+
+        return self.hierarchical_subgraph()
+
+    def set_representatives(self):
+        if self._nx_explorer is None or self._representatives is None:
+            return
+
+        self._nx_explorer.networkCanvas.set_representatives(key for key, val in self._representatives.iteritems() if len(val) > 1)
+
+    def hierarchical_subgraph(self):
+        if self._network is None:
+            return
+
+        labels = self._community_detection(self._network)
+        clusters = {}
+        for key, val in labels.iteritems():
+            clusters[val] = clusters.get(val, []) + [key]
+
+        items = self._network.items()
+        self._representatives = {max(val, key=lambda x, items=items: items[x]["CA"].value): val for val in clusters.itervalues()}
+        #for key, val in clusters.items():
+        #    representatives.append(max(val, key=lambda x, items=items: items[x]["CA"].value))
+        # find neighbors for all representatives
+        repr_neighbors = {key: set(itertools.chain.from_iterable(self._network.adj[n].keys() for n in cluster)) for key, cluster in self._representatives.iteritems()}
+
+        repr_keys = repr_neighbors.keys()
+        edges = list(itertools.chain.from_iterable([(repr_keys[i], repr_keys[j]) for j in range(i) if repr_keys[i] in repr_neighbors[repr_keys[j]]] for i in range(len(repr_keys))))
+
+        # add meta-edges between representatives
+        subgraph = network.nx.Graph.subgraph(self._network, self._representatives.iterkeys())
+        subgraph.add_edges_from(edges)
+
+        return subgraph
+
+    def hierarchical_expand(self, node):
+
+        if not node.is_representative():
+            return
+
+        self._nx_explorer.networkCanvas.unselect_all_points()
+
+        nodes = set(self._representatives[node.index()])
+        nodes.remove(node.index())
+        graph_nodes = set(self._nx_explorer.graph.nodes_iter())
+        if len(nodes & graph_nodes) > 0: # contract nodes
+            nodes = graph_nodes - nodes
+            self._expanded_nodes.remove(node)
+        else: # expand nodes
+            nodes = graph_nodes | nodes
+            self._expanded_nodes.add(node)
+
+        subgraph = network.nx.Graph.subgraph(self._network, nodes)
+        map(lambda n: ModelItem.set_selected(n, True), self._expanded_nodes)
+        qApp.processEvents()
+        self._nx_explorer.change_graph(subgraph)
+        self.set_representatives()
+
 class OWModelMap(OWNxExplorer, OWNxHist):
 
     settingsList = ["autoSendSelection", "spinExplicit", "spinPercentage",
         "mdsFromCurrentPos", "labelsOnMarkedOnly", "tabIndex",
         "networkCanvas.trim_label_words", "opt_from_curr", "networkCanvas.explore_distances",
         "networkCanvas.show_component_distances", "fontWeight", "networkCanvas.state",
-        "networkCanvas.selection_behavior"]
+        "networkCanvas.selection_behavior", "kNN", "spinLowerThreshold",
+        "spinUpperThreshold"]
 
     def __init__(self, parent=None, signalManager=None, name="Model Map"):
         OWNxExplorer.__init__(self, parent, signalManager, name,
                                NetworkCanvas=OWModelMapCanvas)
 
-        self.inputs = [("Distances", misc.SymMatrix, self.setMatrix, Default),
-                       ("Model Subset", data.Table, self.setSubsetModels)]
+        OWNxHist.__init__(self, parent)
+
+        self.inputs = [("Community Detection", CommunityDetection, self.set_community),
+                       ("Distances", misc.SymMatrix, self.set_matrix, Default),
+                       ("Model Subset", data.Table, self.set_models_subset)]
 
         self.outputs = [("Model", modelmaps.Model),
                         ("Classifier", classification.Classifier),
         self.attrIntersectionList = []
         self.attrDifference = []
         self.attrDifferenceList = []
+        self.kNN = 1
 
         self.colorSettings = self.edgeColorSettings
 
 
         # MARTIX CONTROLS
         self.addHistogramControls(self.matrixTab)
-        self.kNN = 1
         boxHistogram = OWGUI.widgetBox(self.matrixTab, box="Distance histogram")
         self.histogram = OWHist(self, boxHistogram)
         boxHistogram.layout().addWidget(self.histogram)
 
         # VISUALIZATION CONTROLS
         vizPredAcc = OWGUI.widgetBox(self.modelTab, "Prediction Accuracy", orientation="vertical")
-        OWGUI.checkBox(vizPredAcc, self, "vizAccurancy", "Visualize prediction accurancy", callback=self.visualizeInfo)
-        OWGUI.spin(vizPredAcc, self, "radius", 10, 1000, 1, label="Radius: ", callback=self.visualizeInfo)
+        OWGUI.checkBox(vizPredAcc, self, "vizAccurancy", "Visualize prediction accurancy", callback=self.visualize_info)
+        OWGUI.spin(vizPredAcc, self, "radius", 10, 1000, 1, label="Radius: ", callback=self.visualize_info)
         self.predGraph = OWDistributionGraph(self, vizPredAcc)
         self.predGraph.setMaximumSize(QSize(300, 300))
         self.predGraph.setYRlabels(None)
         vizPredAcc.layout().addWidget(self.predGraph)
 
         vizPredAcc = OWGUI.widgetBox(self.modelTab, "Attribute lists", orientation="vertical")
-        OWGUI.checkBox(vizPredAcc, self, "vizAttributes", "Display attribute lists", callback=self.visualizeInfo)
+        OWGUI.checkBox(vizPredAcc, self, "vizAttributes", "Display attribute lists", callback=self.visualize_info)
         self.attrIntersectionBox = OWGUI.listBox(vizPredAcc, self, "attrIntersection", "attrIntersectionList", "Attribute intersection", selectionMode=QListWidget.NoSelection)
         self.attrDifferenceBox = OWGUI.listBox(vizPredAcc, self, "attrDifference", "attrDifferenceList", "Attribute difference", selectionMode=QListWidget.NoSelection)
 
         self.attBox.hide()
-        self.visualizeInfo()
+        self.visualize_info()
 
         QObject.connect(self.networkCanvas, SIGNAL('selection_changed()'), self.node_selection_changed)
 
         self.matrixTab.layout().addStretch(1)
         self.modelTab.layout().addStretch(1)
 
+    def set_community(self, community_detection):
+        if community_detection is None:
+            self.set_network_view(None)
+        else:
+            mc_view = ModelClusterView(community_detection)
+            self.set_network_view(mc_view)
+            mc_view.set_representatives()
+
     def plotAccuracy(self, vertices=None):
         self.predGraph.tips.removeAll()
         self.predGraph.clear()
 
         self.predGraph.replot()
 
-    def displayAttributeInfo(self, vertices=None):
+    def display_attribute_info(self, vertices=None):
         self.attrIntersectionList = []
         self.attrDifferenceList = []
 
         self.attrIntersectionList = attrIntersection
         self.attrDifferenceList = attrUnion.difference(attrIntersection)
 
-    def visualizeInfo(self):
+    def visualize_info(self):
         self.networkCanvas.radius = self.radius
 
         if self.vizAccurancy:
             self.plotAccuracy(None)
 
         if self.vizAttributes:
-            self.networkCanvas.vizAttributes = self.displayAttributeInfo
+            self.networkCanvas.vizAttributes = self.display_attribute_info
         else:
             self.networkCanvas.vizAttributes = None
-            self.displayAttributeInfo(None)
+            self.display_attribute_info(None)
 
-    def setSubsetModels(self, subsetData):
+    def set_models_subset(self, subsetData):
         self.info()
 
         if "uuid" not in subsetData.domain:
         for v in self.vertices:
             v.highlight = 1 if v.uuid in uuids else 0
 
-    def setMatrix(self, matrix):
+    def set_matrix(self, matrix):
         self.warning()
 
         if matrix is None:
-            self.warning("Data matrix is None.")
+            OWNxHist.setMatrix(self, None)
             return
 
         if not hasattr(matrix, "items") or not hasattr(matrix, "original_data"):
             self.send('Model', None)
             self.send('Selected Models', None)
 
-    def setColors(self):
-        dlg = self.createColorDialog(self.colorSettings, self.selectedSchemaIndex)
-        if dlg.exec_():
-            self.colorSettings = dlg.getColorSchemas()
-            self.selectedSchemaIndex = dlg.selectedSchemaIndex
-            self.networkCanvas.contPalette = dlg.getContinuousPalette("contPalette")
-            self.networkCanvas.discPalette = dlg.getDiscretePalette("discPalette")
-
-            self.set_node_colors()
-
     def sendSignals(self):
         if self.graph is None or self.graph_matrix is None:
+            self.set_graph_none()
             return
 
         self.set_graph(self.graph, ModelCurve)
+
+        if self._network_view:
+            self._network_view.set_representatives()
+
         self.set_items_distance_matrix(self.graph_matrix)
+        #self.hierarchical_view()
         # TODO clickedAttLstBox -> setLabelText(["attributes"]
 
-        nodes = self.networkCanvas.networkCurve.nodes()
-        for i, ex in enumerate(self.graph.items()):
-            nodes[i].uuid = ex["uuid"].value
+        for node in self.networkCanvas.networkCurve.nodes().itervalues():
+            node.uuid = self.graph_base.items()[node.index()]["uuid"].value
 
         self.set_node_sizes()
         self.set_node_styles()
         self.predGraph.setShowXaxisTitle(True)
         self.predGraph.replot()
 
-        self.visualizeInfo()
+        self.visualize_info()
 
 if __name__ == "__main__":
     import OWModelFile
               ('%s%s.res' % (mroot, modelName))
 
     matrix.originalData = data.Table('%stab\\zoo.tab' % root)
-    ow.setMatrix(matrix)
+    ow.set_matrix(matrix)
     appl.exec_()
 

examples/projections.py

-import orngVizRank as vr
+from Orange.orng import orngVizRank as vr
 
-import Orange.modelmaps as mm
+import _modelmaps as mm
+import time
 
+starttime = time.time()
 ROOT = "/home/miha/work/res/modelmaps/"
+#ROOT = "/Network/Servers/xgridcontroller.private/lab/mihas/modelmaps/"
 
 build_map = mm.BuildModelMap(ROOT + "tab/zoo.tab")
 
 nfeatures = len(build_map.data_d.domain.features)
-features = mm.get_feature_subsets(build_map.data_d.domain, 120)
+features = mm.get_feature_subsets(build_map.data_d.domain, 100)
 
 max_nfeatures_scatterplot = (nfeatures ** 2 - nfeatures) / 2
 features_scatterplot = mm.get_feature_subsets_scatterplot(build_map.data_d.domain, max_nfeatures_scatterplot)
 
 models = []
 models.extend([build_map.build_projection_model(f, vr.LINEAR_PROJECTION) for f in features])
+models.extend([build_map.build_projection_model(f, vr.RADVIZ) for f in features])
+models.extend([build_map.build_projection_model(f, vr.KNN_IN_ORIGINAL_SPACE) for f in features])
+models.extend([build_map.build_projection_model(f, vr.POLYVIZ) for f in features])
 models.extend([build_map.build_projection_model(attrs, vr.SCATTERPLOT) for attrs in features_scatterplot])
 
 smx = build_map.build_model_matrix(models)
 table = build_map.build_model_data(models)
 
-build_map.save("%s/_projections_/proj" % ROOT, smx=smx, table=table)
+build_map.save("%s/_projections_/proj_100_" % ROOT, smx=smx, table=table)
+print (time.time() - starttime) / 60
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.