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 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 setUp(self):
self.numVertices = 10
self.numFeatures = 3
self.maxEdgeTypes = 3
self.vList = VertexList(self.numVertices, self.numFeatures)
self.sMultiGraph = SparseMultiGraph(self.vList, self.maxEdgeTypes)
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 testMeanSeqScalarStats(self):
numFeatures = 1
numVertices = 10
vList = VertexList(numVertices, numFeatures)
p = 0.1
generator = ErdosRenyiGenerator(p)
numGraphs = 50
graphList = []
subgraphIndices = [list(range(3)), list(range(6)), list(range(10))]
for i in range(numGraphs):
graph = generator.generate(SparseGraph(vList))
graphList.append((graph, subgraphIndices))
growthStatistics = GraphStatistics()
meanStats, stdStats = growthStatistics.meanSeqScalarStats(graphList)
#Check some of the stats
for i in range(len(subgraphIndices)):
self.assertEquals(meanStats[i, growthStatistics.numVerticesIndex], len(subgraphIndices[i]))
self.assertEquals(stdStats[i, growthStatistics.numVerticesIndex], 0)
self.assertAlmostEquals(meanStats[i, growthStatistics.numEdgesIndex], 0.5*(len(subgraphIndices[i])*(len(subgraphIndices[i])-1))*p, places=0)
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 = KroneckerGenerator(initialGraph, k)
graph = generator.generate()
logging.debug((graph.outDegreeSequence()))
logging.debug((graph.degreeDistribution()))
k = 3
generator = KroneckerGenerator(initialGraph, k)
graph = generator.generate()
logging.debug((graph.degreeDistribution()))
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)
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())
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 testNormalisedLaplacianSym2(self):
numVertices = 10
numFeatures = 0
vList = VertexList(numVertices, numFeatures)
graph = self.GraphType(vList)
graph.addEdge(0, 1)
graph.addEdge(0, 2)
graph.addEdge(0, 9)
graph.addEdge(1, 1)
graph.addEdge(1, 5)
L = graph.normalisedLaplacianSym(sparse=True)
W = graph.getWeightMatrix()
L2 = numpy.zeros((numVertices, numVertices))
d = graph.outDegreeSequence()
for i in range(numVertices):
for j in range(numVertices):
if d[i] != 0 and d[j] != 0:
Wij = W[i, j] / (numpy.sqrt(d[i] * d[j]))
else:
Wij = 0
if i == j:
L2[i, j] = 1 - Wij
else:
L2[i, j] = -Wij
self.assertAlmostEquals(L[i, j], L2[i, j])
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 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 testEvaluate(self):
numVertices = 6
numFeatures = 1
vList = VertexList(numVertices, numFeatures)
g1 = DenseGraph(vList)
g1.addEdge(0, 1)
g1.addEdge(2, 1)
g1.addEdge(3, 1)
g1.addEdge(4, 1)
g1.addEdge(5, 2)
g2 = DenseGraph(vList)
g2.addEdge(0, 2)
g2.addEdge(1, 2)
g2.addEdge(3, 2)
g2.addEdge(4, 2)
g2.addEdge(5, 1)
g3 = DenseGraph(vList)
g3.addEdge(0, 1)
g4 = SparseGraph(vList)
g4.addEdge(0, 1)
g4.addEdge(2, 1)
g4.addEdge(3, 1)
g4.addEdge(4, 1)
g4.addEdge(5, 2)
lmbda = 0.01
pgk = RandWalkGraphKernel(lmbda)
logging.debug((pgk.evaluate(g1, g1)))
logging.debug((pgk.evaluate(g1, g2)))
logging.debug((pgk.evaluate(g2, g1)))
logging.debug((pgk.evaluate(g2, g2)))
logging.debug((pgk.evaluate(g1, g3)))
logging.debug((pgk.evaluate(g3, g3)))
#Tests - graph kernel is symmetric, permutations of indices are identical
self.assertAlmostEquals(pgk.evaluate(g1, g2),
pgk.evaluate(g2, g1),
places=6)
self.assertAlmostEquals(pgk.evaluate(g1, g3),
pgk.evaluate(g3, g1),
places=6)
self.assertAlmostEquals(pgk.evaluate(g1, g1),
pgk.evaluate(g1, g2),
places=6)
self.assertAlmostEquals(pgk.evaluate(g2, g4),
pgk.evaluate(g1, g2),
places=6)
#All evaluation of themselves are above zero
self.assertTrue(pgk.evaluate(g1, g1) >= 0)
self.assertTrue(pgk.evaluate(g2, g2) >= 0)
self.assertTrue(pgk.evaluate(g3, g3) >= 0)
def testInit(self):
numVertices = 0
numFeatures = 1
vList = VertexList(numVertices, numFeatures)
graph = PySparseGraph(vList)
numVertices = 10
numFeatures = 1
vList = VertexList(numVertices, numFeatures)
graph = PySparseGraph(vList)
self.assertRaises(ValueError, PySparseGraph, [])
self.assertRaises(ValueError, PySparseGraph, vList, 1)
self.assertRaises(ValueError, PySparseGraph, vList, True, 1)
#Now test invalid values of W
W = scipy.sparse.csr_matrix((numVertices, numVertices))
self.assertRaises(ValueError, PySparseGraph, vList, True, W)
W = numpy.zeros((numVertices + 1, numVertices))
self.assertRaises(ValueError, PySparseGraph, vList, True, W)
W = numpy.zeros((numVertices, numVertices))
W[0, 1] = 1
self.assertRaises(ValueError, PySparseGraph, vList, True, W)
W = spmatrix.ll_mat(numVertices, numVertices)
graph = PySparseGraph(vList, W=W)
self.assertTrue(isinstance(W, spmatrix.LLMatType))
#Test intialising with non-empty graph
numVertices = 10
W = spmatrix.ll_mat(numVertices, numVertices)
W[1, 0] = 1.1
W[0, 1] = 1.1
graph = PySparseGraph(numVertices, W=W)
self.assertEquals(graph[1, 0], 1.1)
#Test just specifying number of vertices
graph = PySparseGraph(numVertices)
self.assertEquals(graph.size, numVertices)
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 setUp(self):
self.numVertices = 100
self.numFeatures = 2
p = 0.1
k = 10
self.vList = VertexList(self.numVertices, self.numFeatures)
self.graph = SparseGraph(self.vList)
self.swg = SmallWorldGenerator(p, k)
def testAddVertices(self):
numFeatures = 5
vList = VertexList(10, numFeatures)
vList.setVertex(1, numpy.ones(numFeatures) * 0.1)
self.assertEquals(vList.getNumVertices(), 10)
nptst.assert_array_equal(vList[1], numpy.ones(numFeatures) * 0.1)
vList.addVertices(5)
self.assertEquals(vList.getNumVertices(), 15)
vList.setVertex(11, numpy.ones(numFeatures) * 2)
nptst.assert_array_equal(vList[1], numpy.ones(numFeatures) * 0.1)
nptst.assert_array_equal(vList[11], numpy.ones(numFeatures) * 2)
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 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 testInit(self):
numVertices = 0
numFeatures = 1
vList = VertexList(numVertices, numFeatures)
graph = CsArrayGraph(vList)
self.assertEquals(graph.weightMatrixDType(), numpy.float)
graph = CsArrayGraph(vList, dtype=numpy.int16)
self.assertEquals(graph.weightMatrixDType(), numpy.int16)
#Test just specifying number of vertices
graph = CsArrayGraph(numVertices)
self.assertEquals(graph.size, numVertices)
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):
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 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
"""
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 readGraph(self,
vertexFileName,
edgeFileNames,
undirected=True,
delimiter=None):
"""
Read a MultiGraph from at least 2 files: one is the information about
vertices and the other(s) are lists of edges. For the list of vertices
the first column must be the ID of the vertex.
"""
X = numpy.loadtxt(vertexFileName,
skiprows=1,
converters=self.converters,
usecols=self.vertexIndices,
delimiter=delimiter)
numVertices = X.shape[0]
numFeatures = X.shape[1] - 1
vertexIds = X[:, 0]
vertexIdsDict = {}
for i in range(0, numVertices):
vertexIdsDict[vertexIds[i]] = i
if self.nanProcessor != None:
X[:, 1:numFeatures + 1] = self.nanProcessor(X[:,
1:numFeatures + 1])
vertexList = VertexList(numVertices, numFeatures)
vertexList.setVertices(X[:, 1:numFeatures + 1])
maxEdgeTypes = len(edgeFileNames)
sparseMultiGraph = SparseMultiGraph(vertexList, maxEdgeTypes,
undirected)
for i in range(0, maxEdgeTypes):
self.__readEdgeFile(vertexIdsDict, edgeFileNames[i],
sparseMultiGraph, i)
logging.info("MultiGraph read with " +
str(sparseMultiGraph.getNumVertices()) +
" vertices and " + str(sparseMultiGraph.getNumEdges()) +
" edges")
return sparseMultiGraph
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 testGenerate(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 = KroneckerGenerator(initialGraph, k)
graph = generator.generate()
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.generate()
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 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
