def testGraphDisplay(self): try: import networkx import matplotlib except ImportError as error: logging.debug(error) return #Show numFeatures = 1 numVertices = 20 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) ell = 2 m = 2 generator = BarabasiAlbertGenerator(ell, m) graph = generator.generate(graph) logging.debug((graph.degreeDistribution())) nxGraph = graph.toNetworkXGraph() nodePositions = networkx.spring_layout(nxGraph) nodesAndEdges = networkx.draw_networkx(nxGraph, pos=nodePositions)
def testGraphDisplay(self): try: import networkx import matplotlib except ImportError as error: logging.debug(error) return #Show numFeatures = 1 numVertices = 20 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) p = 0.2 generator = ErdosRenyiGenerator(p) graph = generator.generate(graph) logging.debug((graph.getNumEdges())) nxGraph = graph.toNetworkXGraph() nodePositions = networkx.spring_layout(nxGraph) nodesAndEdges = networkx.draw_networkx(nxGraph, pos=nodePositions) ax = matplotlib.pyplot.axes() ax.set_xticklabels([]) ax.set_yticklabels([])
def testWriteToFile3(self): """ We will test out writing out some random graphs to Pajek """ numVertices = 20 numFeatures = 0 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) p = 0.1 generator = ErdosRenyiGenerator(p) graph = generator.generate(graph) pw = PajekWriter() directory = PathDefaults.getOutputDir() + "test/" pw.writeToFile(directory + "erdosRenyi20", graph) #Now write a small world graph p = 0.2 k = 3 graph.removeAllEdges() generator = SmallWorldGenerator(p, k) graph = generator.generate(graph) pw.writeToFile(directory + "smallWorld20", graph)
def setUp(self): numpy.set_printoptions(suppress=True, precision=3) numpy.random.seed(21) numpy.set_printoptions(threshold=numpy.nan, linewidth=100) #Use the example in the document self.numVertices = 10 self.numFeatures = 2 self.graph1 = SparseGraph(VertexList(self.numVertices, self.numFeatures)) self.graph1.setVertices(range(self.numVertices), numpy.random.rand(self.numVertices, self.numFeatures)) edges = numpy.array([[0,1], [0, 2], [0,4], [0,5], [0,8], [0,9]]) self.graph1.addEdges(edges) edges = numpy.array([[1,3], [1, 5], [1,6], [1,8], [2,9], [3,4], [3,5], [3,6], [3,7], [3,8], [3,9]]) self.graph1.addEdges(edges) edges = numpy.array([[4,2], [4, 7], [4,9], [5,8], [6, 7]]) self.graph1.addEdges(edges) self.graph2 = SparseGraph(VertexList(self.numVertices, self.numFeatures)) self.graph2.setVertices(range(self.numVertices), numpy.random.rand(self.numVertices, self.numFeatures)) edges = numpy.array([[0,3], [0, 4], [0,5], [0,8], [0,9], [1,2]]) self.graph2.addEdges(edges) edges = numpy.array([[1,3], [1,5], [1, 7], [1,8], [1,9], [2,3], [2,5], [3,5], [4,5], [4,6]]) self.graph2.addEdges(edges) edges = numpy.array([[4,9], [6, 8], [7,8], [7,9], [8, 9]]) self.graph2.addEdges(edges)
def testNormalisedLaplacianRw(self): numVertices = 10 numFeatures = 0 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) ell = 2 m = 2 generator = BarabasiAlbertGenerator(ell, m) graph = generator.generate(graph) k = 10 W = graph.getSparseWeightMatrix() L = GraphUtils.normalisedLaplacianRw(W) L2 = graph.normalisedLaplacianRw() tol = 10**-6 self.assertTrue(numpy.linalg.norm(L - L2) < tol) #Test zero rows/cols W = scipy.sparse.csr_matrix((5, 5)) W[1, 0] = 1 W[0, 1] = 1 L = GraphUtils.normalisedLaplacianRw(W) for i in range(2, 5): self.assertEquals(L[i, i], 0)
def testGenerate2(self): numVertices = 20 graph = SparseGraph(GeneralVertexList(numVertices)) p = 0.2 generator = ErdosRenyiGenerator(p) graph = generator.generate(graph) self.assertTrue((graph.getNumEdges() - p*numVertices*numVertices/2) < 8)
def setUp(self): #Let's set up a very simple graph numVertices = 5 numFeatures = 1 edges = [] vList = VertexList(numVertices, numFeatures) #An undirected dense graph self.dGraph1 = DenseGraph(vList, True) self.dGraph1.addEdge(0, 1, 1) self.dGraph1.addEdge(0, 2, 1) self.dGraph1.addEdge(2, 4, 1) self.dGraph1.addEdge(2, 3, 1) self.dGraph1.addEdge(3, 4, 1) #A directed sparse graph self.dGraph2 = DenseGraph(vList, False) self.dGraph2.addEdge(0, 1, 1) self.dGraph2.addEdge(0, 2, 1) self.dGraph2.addEdge(2, 4, 1) self.dGraph2.addEdge(2, 3, 1) self.dGraph2.addEdge(3, 4, 1) #Now try sparse graphs vList = VertexList(numVertices, numFeatures) self.sGraph1 = SparseGraph(vList, True) self.sGraph1.addEdge(0, 1, 1) self.sGraph1.addEdge(0, 2, 1) self.sGraph1.addEdge(2, 4, 1) self.sGraph1.addEdge(2, 3, 1) self.sGraph1.addEdge(3, 4, 1) self.sGraph2 = SparseGraph(vList, False) self.sGraph2.addEdge(0, 1, 1) self.sGraph2.addEdge(0, 2, 1) self.sGraph2.addEdge(2, 4, 1) self.sGraph2.addEdge(2, 3, 1) self.sGraph2.addEdge(3, 4, 1) #Finally, try DictGraphs self.dctGraph1 = DictGraph(True) self.dctGraph1.addEdge(0, 1, 1) self.dctGraph1.addEdge(0, 2, 2) self.dctGraph1.addEdge(2, 4, 8) self.dctGraph1.addEdge(2, 3, 1) self.dctGraph1.addEdge(12, 4, 1) self.dctGraph2 = DictGraph(False) self.dctGraph2.addEdge(0, 1, 1) self.dctGraph2.addEdge(0, 2, 1) self.dctGraph2.addEdge(2, 4, 1) self.dctGraph2.addEdge(2, 3, 1) self.dctGraph2.addEdge(12, 4, 1)
def testSequenceVectorStats(self): numFeatures = 1 numVertices = 10 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) graph.addEdge(0, 2) graph.addEdge(0, 1) subgraphIndices = [[0, 1, 3], [0, 1, 2, 3]] growthStatistics = GraphStatistics() statsList = growthStatistics.sequenceVectorStats(graph, subgraphIndices)
def cvModelSelection(self, graph, paramList, paramFunc, folds, errorFunc): """ ParamList is a list of lists of parameters and paramFunc is a list of the corresponding functions to call with the parameters as arguments. Note that a parameter can also be a tuple which is expanded out before the function is called. e.g. paramList = [[1, 2], [2, 1], [12, 1]] paramFunc = [predictor.setC, predictor.setD] """ inds = Sampling.crossValidation(folds, graph.getNumEdges()) errors = numpy.zeros((len(paramList), folds)) allEdges = graph.getAllEdges() for i in range(len(paramList)): paramSet = paramList[i] logging.debug("Using paramSet=" + str(paramSet)) for j in range(len(paramSet)): if type(paramSet[j]) == tuple: paramFunc[j](*paramSet[j]) else: paramFunc[j](paramSet[j]) predY = numpy.zeros(0) y = numpy.zeros(0) j = 0 for (trainInds, testInds) in inds: trainEdges = allEdges[trainInds, :] testEdges = allEdges[testInds, :] trainGraph = SparseGraph(graph.getVertexList(), graph.isUndirected()) trainGraph.addEdges(trainEdges, graph.getEdgeValues(trainEdges)) testGraph = SparseGraph(graph.getVertexList(), graph.isUndirected()) testGraph.addEdges(testEdges, graph.getEdgeValues(testEdges)) self.learnModel(trainGraph) predY = self.predictEdges(testGraph, testGraph.getAllEdges()) y = testGraph.getEdgeValues(testGraph.getAllEdges()) #Note that the order the edges is different in testGraphs as #opposed to graph when calling getAllEdges() errors[i, j] = errorFunc(y, predY) j = j+1 logging.info("Error of current fold: " + str(numpy.mean(errors[i, :]))) meanErrors = numpy.mean(errors, 1) strErrors = numpy.std(errors, 1) return meanErrors, strErrors
def testGraphInfuence(self): #We test the influence using a real graph numVertices = 5 numFeatures = 0 vList = VertexList(numVertices, numFeatures) sGraph = SparseGraph(vList, False) sGraph.addEdge(0, 1, 0.1) sGraph.addEdge(0, 2, 0.5) sGraph.addEdge(1, 3, 0.9) sGraph.addEdge(2, 3, 0.7) sGraph.addEdge(2, 4, 0.8) P = sGraph.maxProductPaths() self.assertTrue((P[0, :] == numpy.array([0,0.1, 0.5, 0.35, 0.4])).all()) self.assertTrue((P[1, :] == numpy.array([0,0,0,0.9,0])).all()) self.assertTrue((P[2, :] == numpy.array([0,0,0,0.7,0.8])).all()) self.assertTrue((P[3, :] == numpy.array([0,0,0,0,0])).all()) self.assertTrue((P[4, :] == numpy.array([0,0,0,0,0])).all()) k = 5 influence = GreedyInfluence() inds = influence.maxInfluence(P, k)
def testDegreeDistribution(self): numFeatures = 0 numVertices = 100 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) alpha = 10.0 p = 0.01 dim = 2 generator = GeometricRandomGenerator(graph) graph = generator.generateGraph(alpha, p, dim) logging.debug((graph.degreeDistribution()))
def testGenerate2(self): """ Make sure that the generated degree is less than or equal to the given degree """ numVertices = 10 for i in range(10): degSequence = numpy.random.randint(0, 3, numVertices) generator = ConfigModelGenerator(degSequence) graph = SparseGraph(GeneralVertexList(numVertices)) graph = generator.generate(graph) self.assertTrue((graph.outDegreeSequence()<=degSequence).all()) #We try to match an evolving degree sequence degSequence1 = numpy.array([0,0,1,1,1,2,2,2,3, 4]) degSequence2 = numpy.array([2,0,3,1,2,2,2,2,3, 4]) degSequence3 = numpy.array([2,1,4,1,2,2,2,2,3, 6]) generator = ConfigModelGenerator(degSequence1) graph = SparseGraph(GeneralVertexList(numVertices)) graph = generator.generate(graph) self.assertTrue((degSequence1>= graph.outDegreeSequence()).all()) deltaSequence = degSequence2 - graph.outDegreeSequence() generator = ConfigModelGenerator(deltaSequence) graph = generator.generate(graph, False) self.assertTrue((degSequence2>= graph.outDegreeSequence()).all()) deltaSequence = degSequence3 - graph.outDegreeSequence() generator = ConfigModelGenerator(deltaSequence) graph = generator.generate(graph, False) self.assertTrue((degSequence3>= graph.outDegreeSequence()).all())
def findInfoDecayGraph(self, egoTestFileName, alterTestFileName, egoIndicesR, alterIndices, egoIndicesNR, alterIndicesNR, egoFileName, alterFileName, missing=0): (egoTestArray, egoTitles) = self.readFile(egoTestFileName, self.egoTestIds, missing=0) (alterTestArray, alterTitles) = self.readFile(alterTestFileName, self.alterTestIds, missing=0) egoMarks = numpy.zeros(egoTestArray.shape[0]) alterMarks = numpy.zeros(alterTestArray.shape[0]) decays = numpy.zeros(egoIndicesR.shape[0]) correctAnswers = numpy.array([1,2,4,5,8,9,10,12]) wrongAnswers = numpy.array([3, 6, 7, 11]) for i in range(egoTestArray.shape[0]): egoMarks[i] = numpy.intersect1d(egoTestArray[i], correctAnswers).shape[0] egoMarks[i] += wrongAnswers.shape[0] - numpy.intersect1d(egoTestArray[i], wrongAnswers).shape[0] for i in range(alterMarks.shape[0]): alterMarks[i] = numpy.intersect1d(alterTestArray[i], correctAnswers).shape[0] alterMarks[i] += wrongAnswers.shape[0] - numpy.intersect1d(alterTestArray[i], wrongAnswers).shape[0] """ We just return how much the alter understood, since this represents the decay in understanding of the ego and transmission. """ for i in range(decays.shape[0]): decays[i] = alterMarks[alterIndices[i]] #A lot of people could not be bothered to fill the questions and hence #get 4 correct by default decays = (decays) / float(self.numTestQuestions) defaultDecay = 10**-6 #Finally, put the data into a graph (egoArray, egoTitles) = self.readFile(egoFileName, self.egoQuestionIds, missing) (alterArray, alterTitles) = self.readFile(alterFileName, self.alterQuestionIds, missing) V = egoArray V = numpy.r_[V, alterArray[alterIndices, :]] V = numpy.r_[V, egoArray[alterIndicesNR, :]] vList = VertexList(V.shape[0], V.shape[1]) vList.setVertices(V) graph = SparseGraph(vList, False) edgesR = numpy.c_[egoIndicesR, egoArray.shape[0]+numpy.arange(alterIndices.shape[0])] graph.addEdges(edgesR, decays) edgesNR = numpy.c_[egoIndicesNR, egoArray.shape[0]+alterIndices.shape[0]+numpy.arange(alterIndicesNR.shape[0])] graph.addEdges(edgesNR, numpy.ones(edgesNR.shape[0]) * defaultDecay) return graph
def readFromFile(self, fileName): """ Read vertices and edges of the graph from the given file name. The file must have as its first line "Vertices" followed by a list of vertex indices (one per line). Then the lines following "Arcs" or "Edges" have a list of pairs of vertex indices represented directed or undirected edges. """ infile = open(fileName, "r") line = infile.readline() line = infile.readline() ind = 0 vertexIdDict = {} while infile and line != "Edges" and line != "Arcs": vertexIdDict[int(line)] = ind line = infile.readline().strip() ind += 1 if line == "Edges": undirected = True elif line == "Arcs": undirected = False else: raise ValueError("Unknown edge types: " + line) numVertices = len(vertexIdDict) numFeatures = 0 vList = VertexList(numVertices, numFeatures) sGraph = SparseGraph(vList, undirected) line = infile.readline() while line: s = line.split() try: i = vertexIdDict[int(s[0].strip(',').strip())] j = vertexIdDict[int(s[1].strip(',').strip())] k = float(s[2].strip(',').strip()) except KeyError: print("Vertex not found in list of vertices.") raise sGraph.addEdge(i, j, k) line = infile.readline() logging.info("Read graph with " + str(numVertices) + " vertices and " + str(sGraph.getNumEdges()) + " edges") return sGraph
def testGenerate(self): k = 2 numVertices = 1000 numFeatures = 0 vList = VertexList(numVertices, numFeatures) initialGraph = SparseGraph(vList) initialGraph.addEdge(0, 1) initialGraph.addEdge(1, 2) for i in range(numVertices): initialGraph.addEdge(i, i) generator = KroneckerGenerator(initialGraph, k) graph = generator.generate() print (graph.size)
def generate(self): """ Generate a Kronecker graph using the adjacency matrix of the input graph. :returns: The generate graph as a SparseGraph object. """ W = self.initialGraph.adjacencyMatrix() Wi = W for i in range(1, self.k): Wi = np.kron(Wi, W) vList = VertexList(Wi.shape[0], 0) graph = SparseGraph(vList, self.initialGraph.isUndirected()) graph.setWeightMatrix(Wi) return graph
def testDegreeDistribution(self): #We want to see how the degree distribution changes with kronecker powers numVertices = 3 numFeatures = 0 vList = VertexList(numVertices, numFeatures) initialGraph = SparseGraph(vList) initialGraph.addEdge(0, 1) initialGraph.addEdge(1, 2) for i in range(numVertices): initialGraph.addEdge(i, i) logging.debug((initialGraph.outDegreeSequence())) logging.debug((initialGraph.degreeDistribution())) k = 2 generator = StochasticKroneckerGenerator(initialGraph, k) graph = generator.generateGraph() logging.debug((graph.outDegreeSequence())) logging.debug((graph.degreeDistribution())) k = 3 generator = StochasticKroneckerGenerator(initialGraph, k) graph = generator.generateGraph() logging.debug((graph.degreeDistribution()))
def testSequenceScalarStats(self): numFeatures = 1 numVertices = 10 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) graph.addEdge(0, 2) graph.addEdge(0, 1) subgraphIndices = [[0, 1, 3], [0, 1, 2, 3]] growthStatistics = GraphStatistics() statsArray = growthStatistics.sequenceScalarStats(graph, subgraphIndices) self.assertTrue(statsArray[0, 0] == 3.0) self.assertTrue(statsArray[1, 0] == 4.0) self.assertTrue(statsArray[0, 1] == 1.0) self.assertTrue(statsArray[1, 1] == 2.0)
def generateGraph(self): """ Generate a Kronecker graph """ W = self.initialGraph.getWeightMatrix() Wi = W for i in range(1, self.k): Wi = numpy.kron(Wi, W) P = numpy.random.rand(Wi.shape[0], Wi.shape[0]) Wi = numpy.array(P < Wi, numpy.float64) vList = VertexList(Wi.shape[0], 0) graph = SparseGraph(vList, self.initialGraph.isUndirected()) graph.setWeightMatrix(Wi) return graph
def setUp(self): numpy.set_printoptions(suppress=True, linewidth=200, precision=5) self.numVertices = 10; self.numFeatures = 2; self.vList = VertexList(self.numVertices, self.numFeatures) self.graph = SparseGraph(self.vList) self.p = 0.1 self.erg = ErdosRenyiGenerator(self.p)
def testFullTransGraph(self): transGraph = self.egoSimulator.fullTransGraph() #Create a simple graph and deterministic classifier numExamples = 10 numFeatures = 3 #Here, the first element is gender (say) with female = 0, male = 1 vList = VertexList(numExamples, numFeatures) vList.setVertex(0, numpy.array([0,0,1])) vList.setVertex(1, numpy.array([1,0,0])) vList.setVertex(2, numpy.array([1,0,0])) vList.setVertex(3, numpy.array([1,0,0])) vList.setVertex(4, numpy.array([0,0,1])) vList.setVertex(5, numpy.array([0,0,1])) vList.setVertex(6, numpy.array([0,0,0])) vList.setVertex(7, numpy.array([1,0,0])) vList.setVertex(8, numpy.array([0,0,1])) vList.setVertex(9, numpy.array([1,0,0])) sGraph = SparseGraph(vList) sGraph.addEdge(0, 1, 1) sGraph.addEdge(0, 2, 1) sGraph.addEdge(0, 3, 1) sGraph.addEdge(4, 5, 1) sGraph.addEdge(4, 6, 1) sGraph.addEdge(6, 7, 1) sGraph.addEdge(6, 8, 1) sGraph.addEdge(6, 9, 1) simulator = EgoSimulator(sGraph, self.dc) logging.debug("Writing out full transmission graph") transGraph = simulator.fullTransGraph() self.assertEquals(transGraph.isUndirected(), False) self.assertEquals(transGraph.getNumEdges(), 11) self.assertEquals(transGraph.getEdge(0,1), 1) self.assertEquals(transGraph.getEdge(0,2), 1) self.assertEquals(transGraph.getEdge(0,3), 1) self.assertEquals(transGraph.getEdge(4,5), 1) self.assertEquals(transGraph.getEdge(4,6), 1) self.assertEquals(transGraph.getEdge(5,4), 1) self.assertEquals(transGraph.getEdge(6,4), 1) self.assertEquals(transGraph.getEdge(6,7), 1) self.assertEquals(transGraph.getEdge(6,8), 1) self.assertEquals(transGraph.getEdge(6,9), 1) self.assertEquals(transGraph.getEdge(8,6), 1) self.assertEquals(transGraph.getVertexList(), vList)
def testTreeDepth(self): numVertices = 4 numFeatures = 1 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList, False) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(2, 3) self.assertEquals(GraphUtils.treeDepth(graph), 2) numVertices = 5 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList, False) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(2, 3) graph.addEdge(3, 4) self.assertEquals(GraphUtils.treeDepth(graph), 3)
def readFromFile(self, fileName): inFile = open(fileName,"r") numFeatures = 1 graphList = [] line = inFile.readline() while line != "": #First 3 lines are useless inFile.readline() inFile.readline() #4th line has edge information line = inFile.readline() valueList = line.split(None) numVertices = int(valueList[0]) #Not strictly the number of edges, as molecules can have multiple edges #between a pair of atoms numEdges = int(valueList[1]) vList = VertexList(numVertices, numFeatures) for i in range(numVertices): line = inFile.readline() valueList = line.split(None) vList.setVertex(i, numpy.array([self.atomDict[valueList[3]]])) graph = SparseGraph(vList) for i in range(numEdges): line = inFile.readline() valueList = line.split(None) graph.addEdge(int(valueList[0])-1, int(valueList[1])-1) graphList.append(graph) #Ignore next two lines inFile.readline() inFile.readline() line = inFile.readline() return graphList
def fullTransGraph(self): """ This function will return a new graph which contains a directed edge if a transmission will occur between two vertices. """ if self.iteration != 0: raise ValueError("Must run fullTransGraph before advanceGraph") #First, find all the edges in the graph and create an ExampleList numEdges = self.edges.shape[0] X = numpy.zeros((numEdges*2, self.numPersonFeatures*2)) ind = 0 for i in range(numEdges): vertex1 = self.graph.getVertex(self.edges[i,0]) vertex2 = self.graph.getVertex(self.edges[i,1]) X[ind, :] = numpy.r_[vertex1[0:self.numPersonFeatures], vertex2[0:self.numPersonFeatures]] X[ind+numEdges, :] = numpy.r_[vertex2[0:self.numPersonFeatures], vertex1[0:self.numPersonFeatures]] ind = ind + 1 name = "X" examplesList = ExamplesList(X.shape[0]) examplesList.addDataField(name, X) examplesList.setDefaultExamplesName(name) if self.preprocessor != None: X = self.preprocessor.process(examplesList.getDataField(examplesList.getDefaultExamplesName())) examplesList.overwriteDataField(examplesList.getDefaultExamplesName(), X) y = self.egoPairClassifier.classify(examplesList.getSampledDataField(name)) fullTransmissionGraph = SparseGraph(self.graph.getVertexList(), False) transIndices = numpy.nonzero(y==1)[0] #Now, write out the transmission graph for i in range(len(transIndices)): if transIndices[i] < numEdges: fullTransmissionGraph.addEdge(self.edges[transIndices[i],0], self.edges[transIndices[i],1]) else: fullTransmissionGraph.addEdge(self.edges[transIndices[i]-numEdges,1], self.edges[transIndices[i]-numEdges,0]) return fullTransmissionGraph
def testShiftLaplacian(self): numVertices = 10 numFeatures = 0 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) ell = 2 m = 2 generator = BarabasiAlbertGenerator(ell, m) graph = generator.generate(graph) k = 10 W = graph.getSparseWeightMatrix() L = GraphUtils.shiftLaplacian(W) L2 = 2*numpy.eye(numVertices) - graph.normalisedLaplacianSym() tol = 10**-6 self.assertTrue(numpy.linalg.norm(L - L2) < tol)
def testFitDiscretePowerLaw2(self): try: import networkx except ImportError: logging.debug("Networkx not found, can't run test") return nxGraph = networkx.barabasi_albert_graph(1000, 2) graph = SparseGraph.fromNetworkXGraph(nxGraph) degreeSeq = graph.outDegreeSequence() output = Util.fitDiscretePowerLaw(degreeSeq)
def testLearnModel(self): numVertices = 100 numFeatures = 1 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) p = 0.2 generator = ErdosRenyiGenerator(p) graph = generator.generate(graph) vertexIndices = list(range(0, numVertices)) k = 2 learner = GrowthLearner(k) tol = 10**-1 #Lets test the values of alpha on a series of Erdos-Renyi graphs for i in range(1, 6): p = float(i)/10 graph.removeAllEdges() graph = generator.generate(graph) alpha = learner.learnModel(graph, vertexIndices) logging.debug((numpy.linalg.norm(alpha - numpy.array([p, 0])))) #self.assertTrue(numpy.linalg.norm(alpha - numpy.array([p, 0])) < tol) #Now test the learning on some preferencial attachment graphs ell = 10 m = 8 vertexIndices = list(range(ell, numVertices)) graph.removeAllEdges() generator = BarabasiAlbertGenerator(ell, m) graph = generator.generate(graph) alpha = learner.learnModel(graph, vertexIndices) logging.debug(alpha)
def clusterFromIterator(self, graphListIterator, timeIter=False): """ Find a set of clusters for the graphs given by the iterator. """ clustersList = [] timeList = [] for subW in graphListIterator: logging.debug("Clustering graph of size " + str(subW.shape)) #Create a SparseGraph startTime = time.time() graph = SparseGraph(GeneralVertexList(subW.shape[0])) graph.setWeightMatrixSparse(subW) iGraph = graph.toIGraph() vertexCluster = iGraph.community_leading_eigenvector(self.k) clustersList.append(vertexCluster.membership) timeList.append(time.time()-startTime) if timeIter: return clustersList, timeList else: return clustersList
def readFromFile(self, fileName): X = numpy.loadtxt(fileName, skiprows=1, converters=self.converters) vertexIds = numpy.zeros(X.shape[0]*2) #First, we will map the vertex Ids to a set of numbers for i in range(0, X.shape[0]): vertexIds[2*i] = X[i, self.vertex1IdIndex] vertexIds[2*i+1] = X[i, self.vertex2IdIndex] vertexIds = numpy.unique(vertexIds) numVertices = vertexIds.shape[0] numFeatures = len(self.vertex1Indices) vList = VertexList(numVertices, numFeatures) sGraph = SparseGraph(vList, self.undirected) for i in range(0, X.shape[0]): vertex1Id = X[i, self.vertex1IdIndex] vertex2Id = X[i, self.vertex2IdIndex] vertex1 = X[i, self.vertex1Indices] vertex2 = X[i, self.vertex2Indices] vertex1VListId = numpy.nonzero(vertexIds==vertex1Id)[0] vertex2VListId = numpy.nonzero(vertexIds==vertex2Id)[0] vertex1VListId = int(vertex1VListId) vertex2VListId = int(vertex2VListId) vList.setVertex(vertex1VListId, vertex1) vList.setVertex(vertex2VListId, vertex2) sGraph.addEdge(vertex1VListId, vertex2VListId, self.edgeWeight) logging.info("Read " + fileName + " with " + str(sGraph.getNumVertices()) + " vertices and " + str(sGraph.getNumEdges()) + " edges") return sGraph
def testGenerateGraph(self): k = 2 numVertices = 3 numFeatures = 0 vList = VertexList(numVertices, numFeatures) initialGraph = SparseGraph(vList) initialGraph.addEdge(0, 1) initialGraph.addEdge(1, 2) for i in range(numVertices): initialGraph.addEdge(i, i) d = initialGraph.diameter() degreeSequence = initialGraph.outDegreeSequence() generator = StochasticKroneckerGenerator(initialGraph, k) graph = generator.generateGraph() d2 = graph.diameter() degreeSequence2 = graph.outDegreeSequence() self.assertTrue((numpy.kron(degreeSequence, degreeSequence) == degreeSequence2).all()) self.assertTrue(graph.getNumVertices() == numVertices**k) self.assertTrue(graph.getNumDirEdges() == initialGraph.getNumDirEdges()**k) self.assertEquals(d, d2) #Try different k k = 3 generator.setK(k) graph = generator.generateGraph() d3 = graph.diameter() degreeSequence3 = graph.outDegreeSequence() self.assertTrue((numpy.kron(degreeSequence, degreeSequence2) == degreeSequence3).all()) self.assertTrue(graph.getNumVertices() == numVertices**k) self.assertTrue(graph.getNumDirEdges() == initialGraph.getNumDirEdges()**k) self.assertEquals(d, d3) #Test the multinomial degree distribution logging.debug(degreeSequence) logging.debug(degreeSequence2) logging.debug(degreeSequence3)
def readFromFile(self, fileName): X = numpy.loadtxt(fileName, skiprows=1, converters=self.converters) vertexIds = numpy.zeros(X.shape[0] * 2) #First, we will map the vertex Ids to a set of numbers for i in range(0, X.shape[0]): vertexIds[2 * i] = X[i, self.vertex1IdIndex] vertexIds[2 * i + 1] = X[i, self.vertex2IdIndex] vertexIds = numpy.unique(vertexIds) numVertices = vertexIds.shape[0] numFeatures = len(self.vertex1Indices) vList = VertexList(numVertices, numFeatures) sGraph = SparseGraph(vList, self.undirected) for i in range(0, X.shape[0]): vertex1Id = X[i, self.vertex1IdIndex] vertex2Id = X[i, self.vertex2IdIndex] vertex1 = X[i, self.vertex1Indices] vertex2 = X[i, self.vertex2Indices] vertex1VListId = numpy.nonzero(vertexIds == vertex1Id)[0] vertex2VListId = numpy.nonzero(vertexIds == vertex2Id)[0] vertex1VListId = int(vertex1VListId) vertex2VListId = int(vertex2VListId) vList.setVertex(vertex1VListId, vertex1) vList.setVertex(vertex2VListId, vertex2) sGraph.addEdge(vertex1VListId, vertex2VListId, self.edgeWeight) logging.info("Read " + fileName + " with " + str(sGraph.getNumVertices()) + " vertices and " + str(sGraph.getNumEdges()) + " edges") return sGraph
def setUp(self): self.tol = 10**-4 self.numVertices = 5 self.numFeatures = 2 vertexList1 = VertexList(self.numVertices, self.numFeatures) vertexList1.setVertex(0, numpy.array([1, 1])) vertexList1.setVertex(1, numpy.array([1, 2])) vertexList1.setVertex(2, numpy.array([3, 2])) vertexList1.setVertex(3, numpy.array([4, 2])) vertexList1.setVertex(4, numpy.array([2, 6])) vertexList2 = VertexList(self.numVertices, self.numFeatures) vertexList2.setVertex(0, numpy.array([1, 3])) vertexList2.setVertex(1, numpy.array([7, 2])) vertexList2.setVertex(2, numpy.array([3, 22])) vertexList2.setVertex(3, numpy.array([54, 2])) vertexList2.setVertex(4, numpy.array([2, 34])) self.sGraph1 = SparseGraph(vertexList1) self.sGraph1.addEdge(0, 1) self.sGraph1.addEdge(0, 2) self.sGraph1.addEdge(1, 2) self.sGraph1.addEdge(2, 3) self.sGraph2 = SparseGraph(vertexList2) self.sGraph2.addEdge(0, 1) self.sGraph2.addEdge(0, 2) self.sGraph2.addEdge(1, 2) self.sGraph2.addEdge(2, 3) self.sGraph2.addEdge(3, 4) self.sGraph3 = SparseGraph(vertexList2) self.sGraph3.addEdge(4, 1) self.sGraph3.addEdge(4, 2) self.sGraph3.addEdge(1, 2) self.sGraph3.addEdge(1, 0)
return dia_matrix( (np.array( [np.array([2]*5),np.array([1]*5), np.array([1]*5)] ),np.array([0,1,-1]) ),shape=(5,5)) dx = np.linspace(0,1,5) x = populatematrix1(len(dx)) print (x.shape, type(x)) y = populatematrix2(len(dx)) print (y.shape, type(y)) z = kron(x,y) print (z.shape) # Generating simple graph numVertices = 5000 weightMatrix = scipy.sparse.lil_matrix((numVertices, numVertices)) graph = SparseGraph(numVertices, W=weightMatrix) graph[0, 1] = 1 graph[0, 2] = 1 #Output the number of vertices print(graph.size) # PLotting Graph a = np.reshape(np.random.random_integers(0,1,size=100),(10,10)) G= nx.DiGraph(a) nx.draw(G) # Computing Matrix Exponetaial Mat_Exp = scipy.linalg.expm(a, q=None)
def testModularity(self): numVertices = 6 graph = SparseGraph(GeneralVertexList(numVertices)) graph.addEdge(0, 0) graph.addEdge(1, 1) graph.addEdge(2, 2) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(2, 1) graph.addEdge(3, 4, 2) graph.addEdge(3, 5, 2) graph.addEdge(4, 5, 2) graph.addEdge(3, 3, 2) graph.addEdge(4, 4, 2) graph.addEdge(5, 5, 2) W = graph.getWeightMatrix() clustering = numpy.array([0, 0, 0, 1, 1, 1]) #This is the same as the igraph result Q = GraphUtils.modularity(W, clustering) self.assertEquals(Q, 4.0 / 9.0) Ws = scipy.sparse.csr_matrix(W) Q = GraphUtils.modularity(Ws, clustering) self.assertEquals(Q, 4.0 / 9.0) W = numpy.ones((numVertices, numVertices)) Q = GraphUtils.modularity(W, clustering) self.assertEquals(Q, 0.0) Ws = scipy.sparse.csr_matrix(W) Q = GraphUtils.modularity(Ws, clustering) self.assertEquals(Q, 0.0)
""" Name: Generate Graph: Author: Jia_qiu Wang(王佳秋) Data: December, 2016 function: """ import numpy import scipy.sparse as sps from apgl.graph.GeneralVertexList import GeneralVertexList from apgl.graph.SparseGraph import SparseGraph numVertices = 10 vList = GeneralVertexList(numVertices) wght = sps.csc_matrix(numVertices, numVertices) graph = SparseGraph(vList, W=wght, undirected=False) graph[0, 1] = 1 graph[0, 2] = 1 graph.setVertex(0, "abc") graph.setVertex(1, 123) print(graph)
def cvModelSelection(self, graph, paramList, paramFunc, folds, errorFunc): """ ParamList is a list of lists of parameters and paramFunc is a list of the corresponding functions to call with the parameters as arguments. Note that a parameter can also be a tuple which is expanded out before the function is called. e.g. paramList = [[1, 2], [2, 1], [12, 1]] paramFunc = [predictor.setC, predictor.setD] """ inds = Sampling.crossValidation(folds, graph.getNumEdges()) errors = numpy.zeros((len(paramList), folds)) allEdges = graph.getAllEdges() for i in range(len(paramList)): paramSet = paramList[i] logging.debug("Using paramSet=" + str(paramSet)) for j in range(len(paramSet)): if type(paramSet[j]) == tuple: paramFunc[j](*paramSet[j]) else: paramFunc[j](paramSet[j]) predY = numpy.zeros(0) y = numpy.zeros(0) j = 0 for (trainInds, testInds) in inds: trainEdges = allEdges[trainInds, :] testEdges = allEdges[testInds, :] trainGraph = SparseGraph(graph.getVertexList(), graph.isUndirected()) trainGraph.addEdges(trainEdges, graph.getEdgeValues(trainEdges)) testGraph = SparseGraph(graph.getVertexList(), graph.isUndirected()) testGraph.addEdges(testEdges, graph.getEdgeValues(testEdges)) self.learnModel(trainGraph) predY = self.predictEdges(testGraph, testGraph.getAllEdges()) y = testGraph.getEdgeValues(testGraph.getAllEdges()) #Note that the order the edges is different in testGraphs as #opposed to graph when calling getAllEdges() errors[i, j] = errorFunc(y, predY) j = j + 1 logging.info("Error of current fold: " + str(numpy.mean(errors[i, :]))) meanErrors = numpy.mean(errors, 1) strErrors = numpy.std(errors, 1) return meanErrors, strErrors
def testKwayNormalisedCut(self): numVertices = 6 graph = SparseGraph(GeneralVertexList(numVertices)) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(2, 1) graph.addEdge(3, 4) graph.addEdge(3, 5) graph.addEdge(5, 4) W = graph.getWeightMatrix() clustering = numpy.array([0, 0, 0, 1, 1, 1]) self.assertEquals(GraphUtils.kwayNormalisedCut(W, clustering), 0.0) #Try sparse W Ws = scipy.sparse.csr_matrix(W) self.assertEquals(GraphUtils.kwayNormalisedCut(Ws, clustering), 0.0) graph.addEdge(2, 3) W = graph.getWeightMatrix() self.assertEquals(GraphUtils.kwayNormalisedCut(W, clustering), 1.0 / 7) Ws = scipy.sparse.csr_matrix(W) self.assertEquals(GraphUtils.kwayNormalisedCut(Ws, clustering), 1.0 / 7) clustering = numpy.array([0, 0, 0, 1, 1, 2]) self.assertEquals(GraphUtils.kwayNormalisedCut(W, clustering), 61.0 / 105) self.assertEquals(GraphUtils.kwayNormalisedCut(Ws, clustering), 61.0 / 105) #Test two vertices without any edges W = numpy.zeros((2, 2)) clustering = numpy.array([0, 1]) self.assertEquals(GraphUtils.kwayNormalisedCut(W, clustering), 0.0) Ws = scipy.sparse.csr_matrix(W) self.assertEquals(GraphUtils.kwayNormalisedCut(Ws, clustering), 0.0)
from apgl.graph.SparseGraph import SparseGraph from apgl.graph.VertexList import VertexList from apgl.generator.SmallWorldGenerator import SmallWorldGenerator from apgl.io.PajekWriter import PajekWriter import unittest import cProfile import pstats profileFileName = "profile.cprof" p = 0.5 k = 15 numVertices = 200 numFeatures = 5 vList = VertexList(numVertices, numFeatures) sGraph = SparseGraph(vList) swg = SmallWorldGenerator(p, k) cProfile.runctx('swg.generate(sGraph)', globals(), locals(), profileFileName) stats = pstats.Stats(profileFileName) stats.strip_dirs().sort_stats("cumulative").print_stats(20)
""" Name: Generate Graph: Author: Jia_qiu Wang(王佳秋) Data: December, 2016 function: """ from apgl.graph.GeneralVertexList import GeneralVertexList from apgl.graph.SparseGraph import SparseGraph numVertices = 10 graph = SparseGraph(GeneralVertexList(numVertices)) graph[0, 1] = 1 graph[0, 2] = 1 P = graph.floydWarshall() print("geodesicDistance:", graph.geodesicDistance(P=P)) print("harmonicGeodesicDistance:", graph.harmonicGeodesicDistance(P=P))
def testConcat(self): numVertices = 5 graph = SparseGraph(GeneralVertexList(numVertices)) graph.addEdge(1, 1, 0.1) graph.addEdge(1, 3, 0.5) graph.addEdge(2, 4, 1) graph.addEdge(2, 3, 2) graph.setVertex(0, "abc") graph2 = SparseGraph(GeneralVertexList(numVertices)) graph2.addEdge(1, 1) graph2.addEdge(1, 4) graph2.setVertex(1, "def") graph3 = graph.concat(graph2) self.assertTrue(graph3.getNumVertices, 10) self.assertEquals(graph3.getVertex(0), "abc") self.assertEquals(graph3.getVertex(6), "def") self.assertEquals(graph3.getEdge(1, 1), 0.1) self.assertEquals(graph3.getEdge(1, 3), 0.5) self.assertEquals(graph3.getEdge(2, 4), 1) self.assertEquals(graph3.getEdge(2, 3), 2) self.assertEquals(graph3.getEdge(6, 6), 1) self.assertEquals(graph3.getEdge(6, 9), 1)
def testGenerate(self): degSequence = numpy.array([2, 1, 3, 0, 0, 0, 0, 0, 0, 1]) generator = ConfigModelGenerator(degSequence) numVertices = 10 graph = SparseGraph(GeneralVertexList(numVertices)) graph = generator.generate(graph) tol = 3 self.assertTrue( numpy.linalg.norm(degSequence - graph.degreeSequence()) < tol) degSequence = numpy.array([2, 1, 3, 0, 2, 1, 4, 0, 0, 1]) generator.setOutDegSequence(degSequence) graph.removeAllEdges() graph = generator.generate(graph) self.assertTrue( numpy.linalg.norm(degSequence - graph.degreeSequence()) < tol) #Test using a non-empty graph degSequence = numpy.array([0, 0, 0, 2, 0, 0, 0, 1, 1, 0]) generator.setOutDegSequence(degSequence) oldDegSequence = graph.degreeSequence() self.assertRaises(ValueError, generator.generate, graph, True) graph = generator.generate(graph, False) diffSequence = graph.degreeSequence() - oldDegSequence self.assertTrue(numpy.linalg.norm(degSequence - diffSequence) < tol) #Test the case where we also have an in-degree sequence degSequence = numpy.array([2, 1, 3, 0, 0, 0, 0, 0, 0, 1]) inDegSequence = numpy.array([1, 1, 1, 1, 1, 1, 1, 0, 0, 0]) generator = ConfigModelGenerator(degSequence, inDegSequence) graph = SparseGraph(GeneralVertexList(numVertices)) self.assertRaises(ValueError, generator.generate, graph) graph = SparseGraph(GeneralVertexList(numVertices), False) graph = generator.generate(graph) self.assertTrue( numpy.linalg.norm(degSequence - graph.outDegreeSequence()) < tol) self.assertTrue( numpy.linalg.norm(inDegSequence - graph.inDegreeSequence()) < tol) outDegSequence = numpy.array([2, 1, 3, 0, 2, 1, 4, 0, 0, 1]) inDegSequence = numpy.array([1, 2, 1, 1, 2, 1, 2, 1, 2, 1]) generator.setOutDegSequence(outDegSequence) generator.setInDegSequence(inDegSequence) graph.removeAllEdges() graph = generator.generate(graph) self.assertTrue( numpy.linalg.norm(outDegSequence - graph.outDegreeSequence()) < tol) self.assertTrue( numpy.linalg.norm(inDegSequence - graph.inDegreeSequence()) < tol) #In the case that the in-degree sequence sum larger than that of the out-degree it is #not satisfied, but the out-degree should be. inDegSequence = numpy.array([1, 2, 1, 1, 2, 1, 2, 1, 5, 6]) generator.setInDegSequence(inDegSequence) graph.removeAllEdges() graph = generator.generate(graph) self.assertTrue( numpy.linalg.norm(outDegSequence - graph.outDegreeSequence()) < tol) #Now try the other way around generator.setOutDegSequence(inDegSequence) generator.setInDegSequence(outDegSequence) graph.removeAllEdges() graph = generator.generate(graph) self.assertTrue( numpy.linalg.norm(outDegSequence - graph.inDegreeSequence()) < tol) #Test growing graph outDegSequence = numpy.array([2, 1, 3, 0, 2, 1, 4, 0, 0, 1]) inDegSequence = numpy.array([1, 2, 1, 1, 2, 1, 2, 1, 2, 1]) generator.setOutDegSequence(outDegSequence) generator.setInDegSequence(inDegSequence) graph.removeAllEdges() graph = generator.generate(graph) newOutDegreeSequence = numpy.array([2, 1, 3, 5, 2, 1, 4, 0, 0, 1]) newInDegreeSequence = numpy.array([2, 3, 2, 2, 3, 1, 2, 1, 2, 1]) diffOutSequence = newOutDegreeSequence - graph.outDegreeSequence() diffInSequence = newInDegreeSequence - graph.inDegreeSequence() generator.setOutDegSequence(diffOutSequence) generator.setInDegSequence(diffInSequence) graph = generator.generate(graph, False) self.assertTrue( numpy.linalg.norm(newOutDegreeSequence - graph.outDegreeSequence()) < tol) self.assertTrue( numpy.linalg.norm(newInDegreeSequence - graph.inDegreeSequence()) < tol)
class PajekWriterTest(unittest.TestCase): def setUp(self): #Let's set up a very simple graph numVertices = 5 numFeatures = 1 edges = [] vList = VertexList(numVertices, numFeatures) #An undirected dense graph self.dGraph1 = DenseGraph(vList, True) self.dGraph1.addEdge(0, 1, 1) self.dGraph1.addEdge(0, 2, 1) self.dGraph1.addEdge(2, 4, 1) self.dGraph1.addEdge(2, 3, 1) self.dGraph1.addEdge(3, 4, 1) #A directed sparse graph self.dGraph2 = DenseGraph(vList, False) self.dGraph2.addEdge(0, 1, 1) self.dGraph2.addEdge(0, 2, 1) self.dGraph2.addEdge(2, 4, 1) self.dGraph2.addEdge(2, 3, 1) self.dGraph2.addEdge(3, 4, 1) #Now try sparse graphs vList = VertexList(numVertices, numFeatures) self.sGraph1 = SparseGraph(vList, True) self.sGraph1.addEdge(0, 1, 1) self.sGraph1.addEdge(0, 2, 1) self.sGraph1.addEdge(2, 4, 1) self.sGraph1.addEdge(2, 3, 1) self.sGraph1.addEdge(3, 4, 1) self.sGraph2 = SparseGraph(vList, False) self.sGraph2.addEdge(0, 1, 1) self.sGraph2.addEdge(0, 2, 1) self.sGraph2.addEdge(2, 4, 1) self.sGraph2.addEdge(2, 3, 1) self.sGraph2.addEdge(3, 4, 1) #Finally, try DictGraphs self.dctGraph1 = DictGraph(True) self.dctGraph1.addEdge(0, 1, 1) self.dctGraph1.addEdge(0, 2, 2) self.dctGraph1.addEdge(2, 4, 8) self.dctGraph1.addEdge(2, 3, 1) self.dctGraph1.addEdge(12, 4, 1) self.dctGraph2 = DictGraph(False) self.dctGraph2.addEdge(0, 1, 1) self.dctGraph2.addEdge(0, 2, 1) self.dctGraph2.addEdge(2, 4, 1) self.dctGraph2.addEdge(2, 3, 1) self.dctGraph2.addEdge(12, 4, 1) def tearDown(self): pass def testInit(self): pass def testWriteToFile(self): pw = PajekWriter() directory = PathDefaults.getOutputDir() + "test/" #Have to check the files fileName1 = directory + "denseTestUndirected" pw.writeToFile(fileName1, self.dGraph1) fileName2 = directory + "denseTestDirected" pw.writeToFile(fileName2, self.dGraph2) fileName3 = directory + "sparseTestUndirected" pw.writeToFile(fileName3, self.sGraph1) fileName4 = directory + "sparseTestDirected" pw.writeToFile(fileName4, self.sGraph2) fileName5 = directory + "dictTestUndirected" pw.writeToFile(fileName5, self.dctGraph1) fileName6 = directory + "dictTestDirected" pw.writeToFile(fileName6, self.dctGraph2) def testWriteToFile2(self): pw = PajekWriter() directory = PathDefaults.getOutputDir() + "test/" def setVertexColour(vertexIndex, graph): colours = ["grey05", "grey10", "grey15", "grey20", "grey25"] return colours[vertexIndex] def setVertexSize(vertexIndex, graph): return vertexIndex def setEdgeColour(vertexIndex1, vertexIndex2, graph): colours = ["grey05", "grey10", "grey15", "grey20", "grey25"] return colours[vertexIndex1] def setEdgeSize(vertexIndex1, vertexIndex2, graph): return vertexIndex1 + vertexIndex2 pw.setVertexColourFunction(setVertexColour) fileName1 = directory + "vertexColourTest" pw.writeToFile(fileName1, self.dGraph1) pw.setVertexColourFunction(None) pw.setVertexSizeFunction(setVertexSize) fileName1 = directory + "vertexSizeTest" pw.writeToFile(fileName1, self.dGraph1) pw.setVertexSizeFunction(None) pw.setEdgeColourFunction(setEdgeColour) fileName1 = directory + "edgeColourTest" pw.writeToFile(fileName1, self.dGraph1) pw.setEdgeColourFunction(None) pw.setEdgeSizeFunction(setEdgeSize) fileName1 = directory + "edgeSizeTest" pw.writeToFile(fileName1, self.dGraph1) pw.setEdgeColourFunction(None) def testWriteToFile3(self): """ We will test out writing out some random graphs to Pajek """ numVertices = 20 numFeatures = 0 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) p = 0.1 generator = ErdosRenyiGenerator(p) graph = generator.generate(graph) pw = PajekWriter() directory = PathDefaults.getOutputDir() + "test/" pw.writeToFile(directory + "erdosRenyi20", graph) #Now write a small world graph p = 0.2 k = 3 graph.removeAllEdges() generator = SmallWorldGenerator(p, k) graph = generator.generate(graph) pw.writeToFile(directory + "smallWorld20", graph)
def testMatch(self): matcher = GraphMatch(algorithm="U", alpha=0.3) permutation, distance, time = matcher.match(self.graph1, self.graph2) #Checked output file - seems correct distance2 = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(distance[0], distance2) #Now test case in which alpha is different matcher = GraphMatch(algorithm="U", alpha=0.5) permutation, distance, time = matcher.match(self.graph1, self.graph2) distance2 = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(distance[0], distance2) #Test normalised distance alpha = 0.0 permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, self.graph2) distance2 = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, True) self.assertAlmostEquals(distance[1], distance2) alpha = 1.0 permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, self.graph2) distance2 = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, True) self.assertAlmostEquals(distance[1], distance2, 5) #Test empty graph alpha = 0.0 graph1 = SparseGraph(VertexList(0, 0)) graph2 = SparseGraph(VertexList(0, 0)) permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( graph1, graph2) nptst.assert_array_equal(permutation, numpy.array([], numpy.int)) self.assertEquals(distance, [0, 0, 0]) #Test where 1 graph is empty permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( graph1, self.graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) self.assertEquals(distance[1], 1) self.assertEquals(distance[2], 1) permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) self.assertEquals(distance[1], 1) self.assertEquals(distance[2], 1) alpha = 1.0 permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( graph1, self.graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) V2 = self.graph1.vlist.getVertices() V1 = numpy.zeros(V2.shape) C = GraphMatch(algorithm="U", alpha=alpha).matrixSimilarity(V1, V2) dist = numpy.trace(C) / numpy.linalg.norm(C) self.assertAlmostEquals(distance[1], -dist, 4) self.assertAlmostEquals(distance[2], -dist, 4) permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) self.assertAlmostEquals(distance[1], -dist, 4) self.assertAlmostEquals(distance[2], -dist, 4) #Test one graph which is a subgraph of another p = 0.2 k = 10 numVertices = 20 generator = SmallWorldGenerator(p, k) graph = SparseGraph(VertexList(numVertices, 2)) graph = generator.generate(graph) subgraphInds = numpy.random.permutation(numVertices)[0:10] subgraph = graph.subgraph(subgraphInds) matcher = GraphMatch(algorithm="U", alpha=0.0) permutation, distance, time = matcher.match(graph, subgraph) distance = matcher.distance(graph, subgraph, permutation, True, True) self.assertTrue(distance < 1)
def testCvModelSelection(self): numVertices = 10 numFeatures = 1 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(0, 3) graph.addEdge(1, 2) graph.addEdge(3, 4) graph.addEdge(5, 6) graph.addEdge(4, 6) graph.addEdge(9, 8) graph.addEdge(9, 7) graph.addEdge(9, 6) windowSize = 3 predictor = RandomEdgePredictor(windowSize) folds = 5 paramList = [[1, 2], [2, 1], [12, 1]] paramFunc = [predictor.setC, predictor.setD] errors = predictor.cvModelSelection(graph, paramList, paramFunc, folds) self.assertTrue(errors.shape[0] == len(paramList)) for i in range(errors.shape[0]): self.assertTrue(errors[i]>= 0 and errors[i]<= 1)
""" Name: Generate Graph: Author: Jia_qiu Wang(王佳秋) Data: December, 2016 function: """ from apgl.graph.DictGraph import DictGraph from apgl.graph.SparseGraph import SparseGraph from apgl.graph.GeneralVertexList import GeneralVertexList graph = DictGraph() graph.addEdge("a", "b") graph.addEdge("a", "c") graph.addEdge("a", "d") edgeIndices = graph.getAllEdgeIndices() graph2 = SparseGraph(GeneralVertexList(graph.getNumVertices())) graph2.addEdges(edgeIndices)
def testNativeAdjacencyMatrix(self): numVertices = 10 graph = SparseGraph(GeneralVertexList(numVertices)) graph.addEdge(1, 1, 0.1) graph.addEdge(1, 3, 0.5) graph.addEdge(2, 5, 1) graph.addEdge(7, 0, 2) A = graph.nativeAdjacencyMatrix() self.assertEquals(A[0, 7], 1) self.assertEquals(A[7, 0], 1) self.assertEquals(A[1, 3], 1) self.assertEquals(A[3, 1], 1) self.assertEquals(A[1, 1], 1) self.assertEquals(A[2, 5], 1) self.assertEquals(A[5, 2], 1) self.assertEquals(A.getnnz(), 7) graph = SparseGraph(GeneralVertexList(numVertices), False) graph.addEdge(1, 1, 0.1) graph.addEdge(1, 3, 0.5) graph.addEdge(2, 5, 1) A = graph.nativeAdjacencyMatrix() self.assertEquals(A[1, 3], 1) self.assertEquals(A[1, 1], 1) self.assertEquals(A[2, 5], 1) self.assertEquals(A.getnnz(), 3)
def testUnNormSpectralClusterer(self): numVertices = 10 numFeatures = 0 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) #We form two cliques with an edge between then graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(0, 3) graph.addEdge(1, 2) graph.addEdge(1, 3) graph.addEdge(2, 3) graph.addEdge(2, 4) graph.addEdge(4, 5) graph.addEdge(4, 6) graph.addEdge(4, 7) graph.addEdge(5, 6) graph.addEdge(5, 7) graph.addEdge(6, 7) graph.addEdge(7, 8) graph.addEdge(7, 9) #graph.addEdge(0, 4) k = 3 clusterer = SpectralClusterer(k) clusters = clusterer.cluster(graph) self.assertEquals(clusters.shape[0], numVertices) self.assertEquals(numpy.unique(clusters).shape[0], k) logging.debug(clusters) realClusters = numpy.array([1,1,1,1, 0,0,0,0, 2,2]) similarityMatrix1 = numpy.zeros((numVertices, numVertices)) similarityMatrix2 = numpy.zeros((numVertices, numVertices)) for i in range(numVertices): for j in range(numVertices): if clusters[i] == clusters[j]: similarityMatrix1[i, j] = 1 if realClusters[i] == realClusters[j]: similarityMatrix2[i, j] = 1 self.assertTrue((similarityMatrix1 == similarityMatrix2).all())
def setUp(self): numpy.random.seed(21) numVertices = 10 numFeatures = 5 vList = VertexList(numVertices, numFeatures) vList.setVertices(numpy.random.rand(numVertices, numFeatures)) graph = SparseGraph(vList, False) graph.addEdge(0, 1, 1) graph.addEdge(0, 2, 1) graph.addEdge(0, 3, 1) graph.addEdge(0, 4, -1) graph.addEdge(0, 5, -1) graph.addEdge(1, 2, 1) graph.addEdge(1, 3, -1) graph.addEdge(1, 8, 1) graph.addEdge(2, 3, -1) graph.addEdge(2, 4, -1) graph.addEdge(2, 5, -1) graph.addEdge(2, 6, 1) self.graph = graph
def testDistance(self): permutation = numpy.arange(self.numVertices) dist = GraphMatch(alpha=0.0).distance(self.graph1, self.graph1, permutation) self.assertEquals(dist, 0.0) dist = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(dist, 50.0) permutation = numpy.arange(self.numVertices) permutation[8] = 9 permutation[9] = 8 dist = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(dist, 54.0) #Try graphs of unequal size graph3 = self.graph1.subgraph(range(8)) permutation = numpy.arange(self.numVertices) dist1 = GraphMatch(alpha=0.0).distance(self.graph1, graph3, permutation) dist1a = GraphMatch(alpha=0.0).distance(graph3, self.graph1, permutation) self.assertEquals(dist1, dist1a) graph3 = self.graph1.subgraph(range(5)) dist2 = GraphMatch(alpha=0.0).distance(self.graph1, graph3, permutation) dist2a = GraphMatch(alpha=0.0).distance(graph3, self.graph1, permutation) self.assertEquals(dist2, dist2a) self.assertTrue(dist1 < dist2) #Test case where alpha!=0 alpha = 1.0 permutation = numpy.arange(self.numVertices) distance = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, False) C = GraphMatch(alpha=alpha).vertexSimilarities(self.graph1, self.graph2) distance2 = -numpy.trace(C) self.assertEquals(distance, distance2) #Check case where we want non negativve distance even when alpha!=0 distance = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, True, True) self.assertTrue(distance >= 0) permutation = numpy.arange(self.numVertices) distance = GraphMatch(alpha=alpha).distance(self.graph1, self.graph1, permutation, True, True) self.assertEquals(distance, 0) #Check case where both graphs are empty graph1 = SparseGraph(VertexList(0, 0)) graph2 = SparseGraph(VertexList(0, 0)) permutation = numpy.array([], numpy.int) distance = GraphMatch(alpha=alpha).distance(graph1, graph1, permutation, True, True) self.assertEquals(distance, 0) #Now, just one graph is empty #Distance is always 1 due to normalisations alpha = 0.0 permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph1, graph1, permutation, True, True) self.assertEquals(distance, 1.0) permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) #distance = GraphMatch(alpha=alpha).distance(self.graph1, graph1, permutation, False, False) #self.assertEquals(distance, numpy.linalg.norm(self.graph1.getWeightMatrix())**2) alpha = 0.9 matcher = GraphMatch("U", alpha=alpha) permutation, distanceVector, time = matcher.match(self.graph2, graph1) distance = matcher.distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) alpha = 1.0 permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph1, graph1, permutation, True, True) self.assertEquals(distance, 1.0) permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) alpha = 0.5 permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) #Test on unequal graphs and compare against distance from graphm alpha = 0.5 matcher = GraphMatch(alpha=alpha) permutation, distanceVector, time = matcher.match( self.graph1, self.graph2) distance = matcher.distance(self.graph1, self.graph2, permutation, True, False) self.assertAlmostEquals(distanceVector[1], distance, 3)
import time import numpy import scipy.sparse.linalg from scipy.sparse import csr_matrix from pyamg import smoothed_aggregation_solver from apgl.generator.ErdosRenyiGenerator import ErdosRenyiGenerator from apgl.graph.SparseGraph import SparseGraph from apgl.graph.GeneralVertexList import GeneralVertexList numpy.set_printoptions(suppress=True, precision=4, linewidth=100) numpy.random.seed(21) p = 0.001 numVertices = 10000 generator = ErdosRenyiGenerator(p) graph = SparseGraph(GeneralVertexList(numVertices)) graph = generator.generate(graph) print("Num vertices = " + str(graph.getNumVertices())) print("Num edges = " + str(graph.getNumEdges())) L = graph.normalisedLaplacianSym(sparse=True) #L = csr_matrix(L) print("Created Laplacian") #ml = smoothed_aggregation_solver(L) #M = ml.aspreconditioner() start = time.clock() w, V = scipy.sparse.linalg.eigsh(L, k=20) totalTime = time.clock() - start
class GraphMatchTest(unittest.TestCase): def setUp(self): numpy.set_printoptions(suppress=True, precision=3) numpy.random.seed(21) numpy.set_printoptions(threshold=numpy.nan, linewidth=100) #Use the example in the document self.numVertices = 10 self.numFeatures = 2 self.graph1 = SparseGraph( VertexList(self.numVertices, self.numFeatures)) self.graph1.setVertices( range(self.numVertices), numpy.random.rand(self.numVertices, self.numFeatures)) edges = numpy.array([[0, 1], [0, 2], [0, 4], [0, 5], [0, 8], [0, 9]]) self.graph1.addEdges(edges) edges = numpy.array([[1, 3], [1, 5], [1, 6], [1, 8], [2, 9], [3, 4], [3, 5], [3, 6], [3, 7], [3, 8], [3, 9]]) self.graph1.addEdges(edges) edges = numpy.array([[4, 2], [4, 7], [4, 9], [5, 8], [6, 7]]) self.graph1.addEdges(edges) self.graph2 = SparseGraph( VertexList(self.numVertices, self.numFeatures)) self.graph2.setVertices( range(self.numVertices), numpy.random.rand(self.numVertices, self.numFeatures)) edges = numpy.array([[0, 3], [0, 4], [0, 5], [0, 8], [0, 9], [1, 2]]) self.graph2.addEdges(edges) edges = numpy.array([[1, 3], [1, 5], [1, 7], [1, 8], [1, 9], [2, 3], [2, 5], [3, 5], [4, 5], [4, 6]]) self.graph2.addEdges(edges) edges = numpy.array([[4, 9], [6, 8], [7, 8], [7, 9], [8, 9]]) self.graph2.addEdges(edges) def testMatch(self): matcher = GraphMatch(algorithm="U", alpha=0.3) permutation, distance, time = matcher.match(self.graph1, self.graph2) #Checked output file - seems correct distance2 = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(distance[0], distance2) #Now test case in which alpha is different matcher = GraphMatch(algorithm="U", alpha=0.5) permutation, distance, time = matcher.match(self.graph1, self.graph2) distance2 = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(distance[0], distance2) #Test normalised distance alpha = 0.0 permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, self.graph2) distance2 = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, True) self.assertAlmostEquals(distance[1], distance2) alpha = 1.0 permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, self.graph2) distance2 = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, True) self.assertAlmostEquals(distance[1], distance2, 5) #Test empty graph alpha = 0.0 graph1 = SparseGraph(VertexList(0, 0)) graph2 = SparseGraph(VertexList(0, 0)) permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( graph1, graph2) nptst.assert_array_equal(permutation, numpy.array([], numpy.int)) self.assertEquals(distance, [0, 0, 0]) #Test where 1 graph is empty permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( graph1, self.graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) self.assertEquals(distance[1], 1) self.assertEquals(distance[2], 1) permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) self.assertEquals(distance[1], 1) self.assertEquals(distance[2], 1) alpha = 1.0 permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( graph1, self.graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) V2 = self.graph1.vlist.getVertices() V1 = numpy.zeros(V2.shape) C = GraphMatch(algorithm="U", alpha=alpha).matrixSimilarity(V1, V2) dist = numpy.trace(C) / numpy.linalg.norm(C) self.assertAlmostEquals(distance[1], -dist, 4) self.assertAlmostEquals(distance[2], -dist, 4) permutation, distance, time = GraphMatch(algorithm="U", alpha=alpha).match( self.graph1, graph1) self.assertEquals( numpy.linalg.norm(self.graph1.getWeightMatrix())**2, distance[0]) self.assertAlmostEquals(distance[1], -dist, 4) self.assertAlmostEquals(distance[2], -dist, 4) #Test one graph which is a subgraph of another p = 0.2 k = 10 numVertices = 20 generator = SmallWorldGenerator(p, k) graph = SparseGraph(VertexList(numVertices, 2)) graph = generator.generate(graph) subgraphInds = numpy.random.permutation(numVertices)[0:10] subgraph = graph.subgraph(subgraphInds) matcher = GraphMatch(algorithm="U", alpha=0.0) permutation, distance, time = matcher.match(graph, subgraph) distance = matcher.distance(graph, subgraph, permutation, True, True) self.assertTrue(distance < 1) def testDistance(self): permutation = numpy.arange(self.numVertices) dist = GraphMatch(alpha=0.0).distance(self.graph1, self.graph1, permutation) self.assertEquals(dist, 0.0) dist = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(dist, 50.0) permutation = numpy.arange(self.numVertices) permutation[8] = 9 permutation[9] = 8 dist = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation) self.assertAlmostEquals(dist, 54.0) #Try graphs of unequal size graph3 = self.graph1.subgraph(range(8)) permutation = numpy.arange(self.numVertices) dist1 = GraphMatch(alpha=0.0).distance(self.graph1, graph3, permutation) dist1a = GraphMatch(alpha=0.0).distance(graph3, self.graph1, permutation) self.assertEquals(dist1, dist1a) graph3 = self.graph1.subgraph(range(5)) dist2 = GraphMatch(alpha=0.0).distance(self.graph1, graph3, permutation) dist2a = GraphMatch(alpha=0.0).distance(graph3, self.graph1, permutation) self.assertEquals(dist2, dist2a) self.assertTrue(dist1 < dist2) #Test case where alpha!=0 alpha = 1.0 permutation = numpy.arange(self.numVertices) distance = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, False) C = GraphMatch(alpha=alpha).vertexSimilarities(self.graph1, self.graph2) distance2 = -numpy.trace(C) self.assertEquals(distance, distance2) #Check case where we want non negativve distance even when alpha!=0 distance = GraphMatch(alpha=alpha).distance(self.graph1, self.graph2, permutation, True, True) self.assertTrue(distance >= 0) permutation = numpy.arange(self.numVertices) distance = GraphMatch(alpha=alpha).distance(self.graph1, self.graph1, permutation, True, True) self.assertEquals(distance, 0) #Check case where both graphs are empty graph1 = SparseGraph(VertexList(0, 0)) graph2 = SparseGraph(VertexList(0, 0)) permutation = numpy.array([], numpy.int) distance = GraphMatch(alpha=alpha).distance(graph1, graph1, permutation, True, True) self.assertEquals(distance, 0) #Now, just one graph is empty #Distance is always 1 due to normalisations alpha = 0.0 permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph1, graph1, permutation, True, True) self.assertEquals(distance, 1.0) permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) #distance = GraphMatch(alpha=alpha).distance(self.graph1, graph1, permutation, False, False) #self.assertEquals(distance, numpy.linalg.norm(self.graph1.getWeightMatrix())**2) alpha = 0.9 matcher = GraphMatch("U", alpha=alpha) permutation, distanceVector, time = matcher.match(self.graph2, graph1) distance = matcher.distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) alpha = 1.0 permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph1, graph1, permutation, True, True) self.assertEquals(distance, 1.0) permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) alpha = 0.5 permutation = numpy.arange(10, dtype=numpy.int) distance = GraphMatch(alpha=alpha).distance(self.graph2, graph1, permutation, True, True) self.assertEquals(distance, 1.0) #Test on unequal graphs and compare against distance from graphm alpha = 0.5 matcher = GraphMatch(alpha=alpha) permutation, distanceVector, time = matcher.match( self.graph1, self.graph2) distance = matcher.distance(self.graph1, self.graph2, permutation, True, False) self.assertAlmostEquals(distanceVector[1], distance, 3) def testDistance2(self): permutation = numpy.arange(self.numVertices) dist = GraphMatch(alpha=0.0).distance2(self.graph1, self.graph1, permutation) self.assertEquals(dist, 0.0) dist = GraphMatch(alpha=0.0).distance2(self.graph1, self.graph2, permutation) dist2 = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation, True) self.assertAlmostEquals(dist, dist2) permutation = numpy.arange(self.numVertices) permutation[8] = 9 permutation[9] = 8 dist = GraphMatch(alpha=0.0).distance2(self.graph1, self.graph2, permutation) dist2 = GraphMatch(alpha=0.0).distance(self.graph1, self.graph2, permutation, True) self.assertAlmostEquals(dist, dist2) #Try graphs of unequal size graph3 = self.graph1.subgraph(range(8)) permutation = numpy.arange(self.numVertices) dist1 = GraphMatch(alpha=0.0).distance2(self.graph1, graph3, permutation) dist1a = GraphMatch(alpha=0.0).distance2(graph3, self.graph1, permutation) self.assertEquals(dist1, dist1a) graph3 = self.graph1.subgraph(range(5)) dist2 = GraphMatch(alpha=0.0).distance2(self.graph1, graph3, permutation) dist2a = GraphMatch(alpha=0.0).distance2(graph3, self.graph1, permutation) self.assertEquals(dist2, dist2a) self.assertTrue(dist1 < dist2) #Test case where alpha!=0 alpha = 1.0 permutation = numpy.arange(self.numVertices) distance = GraphMatch(alpha=alpha).distance2(self.graph1, self.graph1, permutation) self.assertEquals(distance, 0.0) #Check distances are between 0 and 1 for i in range(100): alpha = numpy.random.rand() permutation = numpy.random.permutation(self.numVertices) distance = GraphMatch(alpha=alpha).distance2( self.graph1, self.graph1, permutation) self.assertTrue(0 <= distance <= 1) def testVertexSimilarities(self): matcher = GraphMatch(alpha=0.0) C = matcher.vertexSimilarities(self.graph1, self.graph1) Cdiag = numpy.diag(C) nptst.assert_array_almost_equal(Cdiag, numpy.ones(Cdiag.shape[0])) #Now compute trace(C)/||C|| #print(numpy.trace(C)/numpy.linalg.norm(C)) #Test use of feature inds matcher = GraphMatch(alpha=0.0, featureInds=numpy.array([0])) C = matcher.vertexSimilarities(self.graph1, self.graph2) #Now, let's vary the non-used feature self.graph1.vlist[:, 1] = 0 C2 = matcher.vertexSimilarities(self.graph1, self.graph2) nptst.assert_array_equal(C, C2) self.graph2.vlist[:, 1] = 0 C2 = matcher.vertexSimilarities(self.graph1, self.graph2) nptst.assert_array_equal(C, C2) #Vary used feature self.graph1.vlist[:, 0] = 0 C2 = matcher.vertexSimilarities(self.graph1, self.graph2) self.assertTrue((C != C2).any()) def testMatrixSimilarity(self): numExamples = 5 numFeatures = 3 V1 = numpy.random.rand(numExamples, numFeatures) matcher = GraphMatch(alpha=0.0) C = matcher.matrixSimilarity(V1, V1) Cdiag = numpy.diag(C) nptst.assert_array_almost_equal(Cdiag, numpy.ones(Cdiag.shape[0])) V1[:, 2] *= 10 C2 = matcher.matrixSimilarity(V1, V1) Cdiag = numpy.diag(C2) nptst.assert_array_almost_equal(Cdiag, numpy.ones(Cdiag.shape[0])) nptst.assert_array_almost_equal(C, C2) #print("Running match") J = numpy.ones((numExamples, numFeatures)) Z = numpy.zeros((numExamples, numFeatures)) C2 = matcher.matrixSimilarity(J, Z) #This should be 1 ideally nptst.assert_array_almost_equal(C2, numpy.ones(C2.shape)) C2 = matcher.matrixSimilarity(J, J) nptst.assert_array_almost_equal(C2, numpy.ones(C2.shape))
def testIndicesFromScores(self): numVertices = 10 numFeatures = 1 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(0, 3) graph.addEdge(1, 2) graph.addEdge(3, 4) graph.addEdge(5, 6) graph.addEdge(4, 6) graph.addEdge(9, 8) graph.addEdge(9, 7) graph.addEdge(9, 6) windowSize = 10 predictor = RandomEdgePredictor(windowSize) predictor.learnModel(graph) scores = numpy.random.randn(numVertices) ind = 0 p, s = predictor.indicesFromScores(ind , scores) self.assertTrue(p.shape[0] == windowSize) self.assertTrue(s.shape[0] == windowSize) infIndices = p[numpy.nonzero(s==-float('Inf'))] self.assertTrue((numpy.sort(infIndices) == numpy.sort(graph.neighbours(ind))).all())
class PermutationGraphKernelTest(unittest.TestCase): def setUp(self): self.tol = 10**-4 self.numVertices = 5 self.numFeatures = 2 vertexList1 = VertexList(self.numVertices, self.numFeatures) vertexList1.setVertex(0, numpy.array([1, 1])) vertexList1.setVertex(1, numpy.array([1, 2])) vertexList1.setVertex(2, numpy.array([3, 2])) vertexList1.setVertex(3, numpy.array([4, 2])) vertexList1.setVertex(4, numpy.array([2, 6])) vertexList2 = VertexList(self.numVertices, self.numFeatures) vertexList2.setVertex(0, numpy.array([1, 3])) vertexList2.setVertex(1, numpy.array([7, 2])) vertexList2.setVertex(2, numpy.array([3, 22])) vertexList2.setVertex(3, numpy.array([54, 2])) vertexList2.setVertex(4, numpy.array([2, 34])) self.sGraph1 = SparseGraph(vertexList1) self.sGraph1.addEdge(0, 1) self.sGraph1.addEdge(0, 2) self.sGraph1.addEdge(1, 2) self.sGraph1.addEdge(2, 3) self.sGraph2 = SparseGraph(vertexList2) self.sGraph2.addEdge(0, 1) self.sGraph2.addEdge(0, 2) self.sGraph2.addEdge(1, 2) self.sGraph2.addEdge(2, 3) self.sGraph2.addEdge(3, 4) self.sGraph3 = SparseGraph(vertexList2) self.sGraph3.addEdge(4, 1) self.sGraph3.addEdge(4, 2) self.sGraph3.addEdge(1, 2) self.sGraph3.addEdge(1, 0) def testEvaluate(self): tau = 1.0 linearKernel = LinearKernel() graphKernel = PermutationGraphKernel(tau, linearKernel) """ First tests - if the graphs have identical edges then permutation is identity matrix provided that tau = 1. """ (evaluation, f, P, SW1, SW2, SK1, SK2) = graphKernel.evaluate(self.sGraph1, self.sGraph1, True) self.assertTrue( numpy.linalg.norm(P - numpy.eye(self.numVertices)) <= self.tol) S1, U = numpy.linalg.eigh(self.sGraph1.getWeightMatrix()) S2, U = numpy.linalg.eigh(self.sGraph2.getWeightMatrix()) evaluation2 = numpy.dot(S1, S1) self.assertTrue(numpy.linalg.norm(SW1 - S1) <= self.tol) self.assertTrue(numpy.linalg.norm(SW2 - S1) <= self.tol) self.assertTrue(abs(evaluation - evaluation2) <= self.tol) (evaluation, f, P, SW1, SW2, SK1, SK2) = graphKernel.evaluate(self.sGraph2, self.sGraph2, True) self.assertTrue( numpy.linalg.norm(P - numpy.eye(self.numVertices)) <= self.tol) evaluation2 = numpy.dot(S2, S2) self.assertTrue(numpy.linalg.norm(SW1 - S2) <= self.tol) self.assertTrue(numpy.linalg.norm(SW2 - S2) <= self.tol) self.assertTrue(abs(evaluation - evaluation2) <= self.tol) #Test symmetry self.assertEquals(graphKernel.evaluate(self.sGraph1, self.sGraph2), graphKernel.evaluate(self.sGraph2, self.sGraph1)) #Now we choose tau != 1 tau = 0.5 graphKernel = PermutationGraphKernel(tau, linearKernel) (evaluation, f, P, SW1, SW2, SK1, SK2) = graphKernel.evaluate(self.sGraph1, self.sGraph1, True) self.assertTrue( numpy.linalg.norm(P - numpy.eye(self.numVertices)) <= self.tol) self.assertTrue(graphKernel.evaluate(self.sGraph1, self.sGraph1) >= 0) self.assertTrue(graphKernel.evaluate(self.sGraph2, self.sGraph2) >= 0) self.assertTrue( (graphKernel.evaluate(self.sGraph1, self.sGraph2) - graphKernel.evaluate(self.sGraph2, self.sGraph1)) <= self.tol) (evaluation, f, P, SW1, SW2, SK1, SK2) = graphKernel.evaluate(self.sGraph1, self.sGraph2, True) self.assertTrue( numpy.linalg.norm(numpy.dot(P.T, P) - numpy.eye(self.numVertices)) <= self.tol) #Choose tau=0 tau = 0.0 graphKernel = PermutationGraphKernel(tau, linearKernel) (evaluation, f, P, SW1, SW2, SK1, SK2) = graphKernel.evaluate(self.sGraph1, self.sGraph1, True) self.assertTrue( numpy.linalg.norm(P - numpy.eye(self.numVertices)) <= self.tol) self.assertTrue( numpy.linalg.norm(numpy.dot(P.T, P) - numpy.eye(self.numVertices)) <= self.tol) X1 = self.sGraph1.getVertexList().getVertices( list(range(0, (self.sGraph1.getNumVertices())))) X2 = self.sGraph2.getVertexList().getVertices( list(range(0, (self.sGraph2.getNumVertices())))) S1, U = numpy.linalg.eigh(numpy.dot(X1, X1.T)) S2, V = numpy.linalg.eigh(numpy.dot(X2, X2.T)) evaluation2 = numpy.dot(S1, S1) self.assertTrue(numpy.linalg.norm(SK1 - S1) <= self.tol) self.assertTrue(numpy.linalg.norm(SK2 - S1) <= self.tol) self.assertTrue(abs(evaluation - evaluation2) <= self.tol) self.assertTrue( (graphKernel.evaluate(self.sGraph1, self.sGraph2) - graphKernel.evaluate(self.sGraph2, self.sGraph1)) <= self.tol) #Test value is zero when we have a graph which is a permutation of the next def testEvaluate2(self): tau = 1.0 linearKernel = LinearKernel() graphKernel = PermutationGraphKernel(tau, linearKernel) (evaluation, f, P, SW1, SW2, SK1, SK2) = graphKernel.evaluate(self.sGraph1, self.sGraph3, True) W1 = self.sGraph1.getWeightMatrix() W2 = self.sGraph3.getWeightMatrix() self.assertTrue( numpy.linalg.norm(Util.mdot(P, W1, P.T) - W2) <= self.tol) self.assertAlmostEquals(f, 0, 7)
""" Name: Generate Graph: Author: Jia_qiu Wang(王佳秋) Data: December, 2016 function: """ import numpy from apgl.graph.VertexList import VertexList from apgl.graph.SparseGraph import SparseGraph numVertex = 5 numFeature = 2 # vector labels of size 2 graph = SparseGraph(VertexList(numVertex, numFeature)) # Add some edges to the graph(method 1) # Vertices are indexed starting from 0 # graph[0, 1] = 0.1 # graph[1, 2] = 1 # Add some edges to the graph(method 2 is identity to method 1) edges = numpy.array([[0, 1], [1, 2]], numpy.int) edgeValues = numpy.array([0.1, 1]) graph.addEdges(edges, edgeValues) # Set the label of 0th vertex to [2, 3] graph.setVertex(0, numpy.array([2, 3])) # Displays edge weights print(graph[1, 2])
def testInit(self): numVertices = 0 numFeatures = 1 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) numVertices = 10 numFeatures = 1 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) self.assertEquals(graph.weightMatrixType(), scipy.sparse.csr_matrix) self.assertRaises(ValueError, SparseGraph, []) self.assertRaises(ValueError, SparseGraph, vList, 1) self.assertRaises(ValueError, SparseGraph, vList, True, 1) #Now test invalid values of W W = numpy.zeros((numVertices, numVertices)) self.assertRaises(ValueError, SparseGraph, vList, True, W) W = scipy.sparse.lil_matrix((numVertices + 1, numVertices)) self.assertRaises(ValueError, SparseGraph, vList, True, W) W = scipy.sparse.lil_matrix((numVertices, numVertices)) W[0, 1] = 1 self.assertRaises(ValueError, SparseGraph, vList, True, W) W = scipy.sparse.lil_matrix((numVertices, numVertices)) graph = SparseGraph(vList, W=W) self.assertEquals(graph.weightMatrixType(), scipy.sparse.lil_matrix) #Test intialising with non-empty graph numVertices = 10 W = scipy.sparse.csr_matrix((numVertices, numVertices)) W[1, 0] = 1.1 W[0, 1] = 1.1 graph = SparseGraph(numVertices, W=W) self.assertEquals(graph[1, 0], 1.1) #Test just specifying number of vertices graph = SparseGraph(numVertices) self.assertEquals(graph.size, numVertices) #Try creating a sparse matrix of dtype int graph = SparseGraph(numVertices, dtype=numpy.int) self.assertEquals(graph.W.dtype, numpy.int) graph[0, 0] = 1.2 self.assertEquals(graph[0, 0], 1) #Test the different sparse matrix formats graph = SparseGraph(numVertices, frmt="lil") self.assertEquals(type(graph.W), scipy.sparse.lil_matrix) graph = SparseGraph(numVertices, frmt="csr") self.assertEquals(type(graph.W), scipy.sparse.csr_matrix) graph = SparseGraph(numVertices, frmt="csc") self.assertEquals(type(graph.W), scipy.sparse.csc_matrix)
def testVectorStatistics(self): numFeatures = 1 numVertices = 10 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) graph.addEdge(0, 2) graph.addEdge(0, 1) growthStatistics = GraphStatistics() statsDict = growthStatistics.vectorStatistics(graph) self.assertTrue((statsDict["outDegreeDist"] == numpy.array([7,2,1])).all()) self.assertTrue((statsDict["inDegreeDist"] == numpy.array([7,2,1])).all()) self.assertTrue((statsDict["hopCount"] == numpy.array([10,14,16])).all()) self.assertTrue((statsDict["triangleDist"] == numpy.array([10])).all()) W = graph.getWeightMatrix() W = (W + W.T)/2 lmbda, V = numpy.linalg.eig(W) maxEigVector = V[:, numpy.argmax(lmbda)] lmbda = numpy.flipud(numpy.sort(lmbda[lmbda>0])) self.assertTrue((statsDict["maxEigVector"] == maxEigVector).all()) self.assertTrue((statsDict["eigenDist"] == lmbda).all()) self.assertTrue((statsDict["componentsDist"] == numpy.array([0, 7, 0, 1])).all()) graph.addEdge(0, 3) graph.addEdge(0, 4) graph.addEdge(1, 4) growthStatistics = GraphStatistics() statsDict = growthStatistics.vectorStatistics(graph) self.assertTrue((statsDict["outDegreeDist"] == numpy.array([5,2,2,0,1])).all()) self.assertTrue((statsDict["inDegreeDist"] == numpy.array([5,2,2,0,1])).all()) self.assertTrue((statsDict["hopCount"] == numpy.array([10,20,30])).all()) self.assertTrue((statsDict["triangleDist"] == numpy.array([7, 0, 3])).all()) W = graph.getWeightMatrix() W = (W + W.T)/2 lmbda, V = numpy.linalg.eig(W) maxEigVector = V[:, numpy.argmax(lmbda)] lmbda = numpy.flipud(numpy.sort(lmbda[lmbda>0])) self.assertTrue((statsDict["maxEigVector"] == maxEigVector).all()) self.assertTrue((statsDict["eigenDist"] == lmbda).all()) self.assertTrue((statsDict["componentsDist"] == numpy.array([0, 5, 0, 0, 0, 1])).all()) #Test on a directed graph and generating tree statistics vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList, False) graph.addEdge(0, 1) graph.addEdge(0, 2) graph.addEdge(2, 3) graph.addEdge(4, 5) statsDict = growthStatistics.vectorStatistics(graph, treeStats=True) self.assertTrue(( statsDict["inDegreeDist"] == numpy.array([6, 4]) ).all()) self.assertTrue(( statsDict["outDegreeDist"] == numpy.array([7, 2, 1]) ).all()) self.assertTrue(( statsDict["triangleDist"] == numpy.array([10]) ).all()) self.assertTrue(( statsDict["treeSizesDist"] == numpy.array([0, 4, 1, 0, 1]) ).all()) self.assertTrue(( statsDict["treeDepthsDist"] == numpy.array([4, 1, 1]) ).all())
def testScalarStatistics(self): numFeatures = 1 numVertices = 10 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) graph.addEdge(0, 1) growthStatistics = GraphStatistics() statsArray = growthStatistics.scalarStatistics(graph) #logging.debug(statsArray) self.assertTrue(statsArray[growthStatistics.numVerticesIndex] == 10.0) self.assertTrue(statsArray[growthStatistics.numEdgesIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.maxComponentSizeIndex] == 2.0) self.assertTrue(statsArray[growthStatistics.maxComponentEdgesIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.numComponentsIndex] == 9.0) self.assertEquals(statsArray[growthStatistics.meanComponentSizeIndex], 10.0/9.0) self.assertTrue(statsArray[growthStatistics.meanDegreeIndex] == 0.2) self.assertTrue(statsArray[growthStatistics.diameterIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.effectiveDiameterIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.densityIndex] == 1.0/45) self.assertEquals(statsArray[growthStatistics.geodesicDistanceIndex], 1.0/55) self.assertEquals(statsArray[growthStatistics.harmonicGeoDistanceIndex], 55.0) self.assertEquals(statsArray[growthStatistics.geodesicDistMaxCompIndex], 1.0/3) self.assertEquals(statsArray[growthStatistics.numNonSingletonComponentsIndex], 1.0) self.assertEquals(statsArray[growthStatistics.numTriOrMoreComponentsIndex], 0.0) self.assertEquals(statsArray[growthStatistics.secondComponentSizeIndex], 1.0) self.assertEquals(statsArray[growthStatistics.maxCompMeanDegreeIndex], 1.0) graph.addEdge(0, 2) graph.addEdge(3,4) graph.addEdge(3,5) graph.addEdge(3,6) graph.addEdge(7,8) statsArray = growthStatistics.scalarStatistics(graph) self.assertEquals(statsArray[growthStatistics.numNonSingletonComponentsIndex], 3.0) self.assertEquals(statsArray[growthStatistics.numTriOrMoreComponentsIndex], 2.0) self.assertEquals(statsArray[growthStatistics.secondComponentSizeIndex], 3.0) self.assertEquals(statsArray[growthStatistics.maxCompMeanDegreeIndex], 1.5) #Test on a directed graph graph = SparseGraph(vList, False) graph.addEdge(0, 1) statsArray = growthStatistics.scalarStatistics(graph, treeStats=True) self.assertTrue(statsArray[growthStatistics.numVerticesIndex] == 10.0) self.assertTrue(statsArray[growthStatistics.numEdgesIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.maxComponentSizeIndex] == -1) self.assertTrue(statsArray[growthStatistics.maxComponentEdgesIndex] == -1) self.assertTrue(statsArray[growthStatistics.numComponentsIndex] == -1) self.assertTrue(statsArray[growthStatistics.meanComponentSizeIndex] == -1) self.assertEquals(statsArray[growthStatistics.meanDegreeIndex], 0.1) self.assertTrue(statsArray[growthStatistics.diameterIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.effectiveDiameterIndex] == 1.0) self.assertTrue(statsArray[growthStatistics.densityIndex] == 1.0/90) self.assertEquals(statsArray[growthStatistics.geodesicDistanceIndex], 1.0/100) self.assertEquals(statsArray[growthStatistics.harmonicGeoDistanceIndex], 100) self.assertEquals(statsArray[growthStatistics.meanTreeSizeIndex], 10.0/9) self.assertEquals(statsArray[growthStatistics.meanTreeDepthIndex], 1.0/9) self.assertEquals(statsArray[growthStatistics.maxTreeSizeIndex], 2.0) self.assertEquals(statsArray[growthStatistics.maxTreeDepthIndex], 1.0) self.assertEquals(statsArray[growthStatistics.numTreesIndex], 9.0) self.assertEquals(statsArray[growthStatistics.numNonSingletonTreesIndex], 1.0) #Test that the max tree is decribed correctly graph.addEdge(2, 3) graph.addEdge(2, 4) graph.addEdge(3, 5) graph.addEdge(3, 6) statsArray = growthStatistics.scalarStatistics(graph, treeStats=True) self.assertEquals(statsArray[growthStatistics.maxTreeSizeIndex], 5.0) self.assertEquals(statsArray[growthStatistics.maxTreeDepthIndex], 2.0) self.assertEquals(statsArray[growthStatistics.secondTreeSizeIndex], 2.0) self.assertEquals(statsArray[growthStatistics.secondTreeDepthIndex], 1.0) self.assertEquals(statsArray[growthStatistics.numTreesIndex], 5.0) self.assertEquals(statsArray[growthStatistics.numNonSingletonTreesIndex], 2.0) #Try a zero size graph numFeatures = 0 numVertices = 0 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) statsArray = growthStatistics.scalarStatistics(graph) self.assertEquals(statsArray[growthStatistics.numVerticesIndex], 0) self.assertEquals(statsArray[growthStatistics.numEdgesIndex], 0) self.assertEquals(statsArray[growthStatistics.maxComponentSizeIndex], 0) self.assertTrue(statsArray[growthStatistics.maxComponentEdgesIndex] == 0) self.assertEquals(statsArray[growthStatistics.numComponentsIndex], 0) self.assertEquals(statsArray[growthStatistics.meanComponentSizeIndex], 0) self.assertEquals(statsArray[growthStatistics.meanDegreeIndex], 0) self.assertEquals(statsArray[growthStatistics.diameterIndex], 0) self.assertEquals(statsArray[growthStatistics.effectiveDiameterIndex], 0) self.assertEquals(statsArray[growthStatistics.densityIndex], 0) self.assertEquals(statsArray[growthStatistics.geodesicDistanceIndex], 0.0) self.assertEquals(statsArray[growthStatistics.harmonicGeoDistanceIndex], 0.0) self.assertEquals(statsArray[growthStatistics.geodesicDistMaxCompIndex], 0.0) self.assertEquals(statsArray[growthStatistics.numNonSingletonComponentsIndex], 0.0) graph = SparseGraph(vList, False) statsArray = growthStatistics.scalarStatistics(graph) self.assertEquals(statsArray[growthStatistics.numVerticesIndex], 0) self.assertEquals(statsArray[growthStatistics.numEdgesIndex], 0) self.assertEquals(statsArray[growthStatistics.maxComponentSizeIndex], -1) self.assertEquals(statsArray[growthStatistics.numComponentsIndex], -1) self.assertEquals(statsArray[growthStatistics.meanComponentSizeIndex], -1) self.assertEquals(statsArray[growthStatistics.maxComponentEdgesIndex], -1) self.assertEquals(statsArray[growthStatistics.meanDegreeIndex], 0) self.assertEquals(statsArray[growthStatistics.diameterIndex], 0) self.assertEquals(statsArray[growthStatistics.effectiveDiameterIndex], 0) self.assertEquals(statsArray[growthStatistics.densityIndex], 0) self.assertEquals(statsArray[growthStatistics.geodesicDistanceIndex], 0.0) self.assertEquals(statsArray[growthStatistics.harmonicGeoDistanceIndex], 0.0) self.assertEquals(statsArray[growthStatistics.geodesicDistMaxCompIndex], -1) self.assertEquals(statsArray[growthStatistics.meanTreeSizeIndex], -1) self.assertEquals(statsArray[growthStatistics.meanTreeDepthIndex], -1) self.assertEquals(statsArray[growthStatistics.numNonSingletonComponentsIndex], -1) self.assertEquals(statsArray[growthStatistics.numTreesIndex], -1) self.assertEquals(statsArray[growthStatistics.numNonSingletonTreesIndex], -1)
def testGenerate(self): numFeatures = 1 numVertices = 20 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) ell = 2 m = 0 generator = BarabasiAlbertGenerator(ell, m) graph = generator.generate(graph) self.assertEquals(graph.getNumEdges(), 0) ell = 5 graph.removeAllEdges() generator.setEll(ell) graph = generator.generate(graph) self.assertEquals(graph.getNumEdges(), 0) #Now test case where we m != 0 ell = 2 m = 1 graph.removeAllEdges() generator.setEll(ell) generator.setM(m) graph = generator.generate(graph) self.assertEquals(graph.getNumEdges(), (numVertices - ell) * m) m = 2 graph.removeAllEdges() generator.setM(m) graph = generator.generate(graph) self.assertEquals(graph.getNumEdges(), (numVertices - ell) * m)
def testGenerateGraph(self): numFeatures = 0 numVertices = 20 vList = VertexList(numVertices, numFeatures) graph = SparseGraph(vList) alpha1 = 10.0 alpha2 = 20.0 p = 0.001 dim = 2 generator = GeometricRandomGenerator(graph) graph = generator.generateGraph(alpha1, p, dim) numEdges1 = graph.getNumEdges() #Check no self edges for i in range(numVertices): self.assertTrue(graph.getEdge(i, i) == None) graph.removeAllEdges() graph = generator.generateGraph(alpha2, p, dim) numEdges2 = graph.getNumEdges() #self.assertTrue(numEdges1 >= numEdges2) logging.debug(numEdges1) logging.debug(numEdges2) for i in range(numVertices): self.assertTrue(graph.getEdge(i, i) == None) #Test case with p=0 and alpha huge p = 0.0 alpha = 100.0 graph.removeAllEdges() graph = generator.generateGraph(alpha, p, dim) self.assertEquals(graph.getNumEdges(), 0) #When alpha=0, should get max edges alpha = 0.0 graph.removeAllEdges() graph = generator.generateGraph(alpha, p, dim) #self.assertEquals(graph.getNumEdges(), int(0.5*(numVertices + numVertices**2) - numVertices)) #TODO: Test variations in dimension """