Example #1
0
    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 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 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)
Example #4
0
    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 generateGraph(self, alpha, p, dim):
        Parameter.checkFloat(alpha, 0.0, float('inf'))
        Parameter.checkFloat(p, 0.0, 1.0)
        Parameter.checkInt(dim, 0, float('inf'))

        numVertices = self.graph.getNumVertices()
        self.X = numpy.random.rand(numVertices, dim)

        D = KernelUtils.computeDistanceMatrix(numpy.dot(self.X, self.X.T))
        P = numpy.exp(-alpha * D)
        diagIndices = numpy.array(list(range(0, numVertices)))
        P[(diagIndices, diagIndices)] = numpy.zeros(numVertices)

        B = numpy.random.rand(numVertices, numVertices) <= P

        #Note that B is symmetric - could just go through e.g. upper triangle
        for i in range(numpy.nonzero(B)[0].shape[0]):
            v1 = numpy.nonzero(B)[0][i]
            v2 = numpy.nonzero(B)[1][i]

            self.graph.addEdge(v1, v2)

        erdosRenyiGenerator = ErdosRenyiGenerator(p)
        self.graph = erdosRenyiGenerator.generate(self.graph, False)

        return self.graph
    def generateGraph(self, alpha, p, dim):
        Parameter.checkFloat(alpha, 0.0, float('inf'))
        Parameter.checkFloat(p, 0.0, 1.0)
        Parameter.checkInt(dim, 0, float('inf'))
        
        numVertices = self.graph.getNumVertices()
        self.X = numpy.random.rand(numVertices, dim)

        D = KernelUtils.computeDistanceMatrix(numpy.dot(self.X, self.X.T))
        P = numpy.exp(-alpha * D)
        diagIndices = numpy.array(list(range(0, numVertices)))
        P[(diagIndices, diagIndices)] = numpy.zeros(numVertices)

        B = numpy.random.rand(numVertices, numVertices) <= P 

        #Note that B is symmetric - could just go through e.g. upper triangle 
        for i in range(numpy.nonzero(B)[0].shape[0]):
            v1 = numpy.nonzero(B)[0][i]
            v2 = numpy.nonzero(B)[1][i]
            
            self.graph.addEdge(v1, v2)

        erdosRenyiGenerator = ErdosRenyiGenerator(p)
        self.graph = erdosRenyiGenerator.generate(self.graph, False)

        return self.graph
 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 __init__(self):
        numVertices = 1000
        graph = SparseGraph(GeneralVertexList(numVertices))

        p = 0.1
        generator = ErdosRenyiGenerator(p)
        graph = generator.generate(graph)

        subgraphIndicesList = []
        for i in range(100, numVertices, 10):
            subgraphIndicesList.append(range(i))

        k1 = 5
        k2 = 100 

        self.graph = graph
        self.subgraphIndicesList = subgraphIndicesList
        self.clusterer = IterativeSpectralClustering(k1, k2, T=10, alg="IASC")
Example #9
0
    def __init__(self):
        numVertices = 1000
        graph = SparseGraph(GeneralVertexList(numVertices))

        p = 0.1
        generator = ErdosRenyiGenerator(p)
        graph = generator.generate(graph)

        subgraphIndicesList = []
        for i in range(100, numVertices, 10):
            subgraphIndicesList.append(range(i))

        k1 = 5
        k2 = 100

        self.graph = graph
        self.subgraphIndicesList = subgraphIndicesList
        self.clusterer = IterativeSpectralClustering(k1, k2, T=10, alg="IASC")
 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)
Example #11
0
    def __init__(self, changeEdges=10, numGraphs=100, numClusterVertices=50, numClusters=3, p=0.3): 
        self.changeEdges = changeEdges 
        self.numGraphs = numGraphs
        self.graphInd = 0
        self.numClusters = numClusters 
        self.realClustering = numpy.zeros(numClusterVertices*numClusters)
        generator = ErdosRenyiGenerator(p)
        
        clusterList = []
        for i in range(numClusters):  
            cluster = SparseGraph(GeneralVertexList(numClusterVertices))
            cluster = generator.generate2(cluster)
            clusterList.append(cluster)
            
            self.realClustering[numClusterVertices*i:(i+1)*numClusterVertices] = i

        self.graph = clusterList[0]
        for i in range(1, len(clusterList)): 
            self.graph = self.graph.concat(clusterList[i])
Example #12
0
def print_Eros(vertex, p):
    graph = SparseGraph(VertexList(vertex, 0))
    #graph = AbstractMatrixGraph()
    generator = ErdosRenyiGenerator(p)
    graphER = generator.generate2(graph)
    result = graphER.adjacencyList()
    print graphER

    newdic = {}
    cnt = 0
    for i in result[0]:
        #print "I value = ", i
        newdic[cnt] = set(i)
        cnt+=1
 
    newgra = dergee(newdic) 
    #print "NEWGRA = ", newgra
    #plt.subplot(212)
    #plt.loglog(newgra[0], newgra[1], 'ro', markersize=3, basex=2)
    return newdic
Example #13
0
    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)
Example #14
0
import sys
import struct
#from apgl.graph import *
from apgl.graph.DenseGraph import DenseGraph
from apgl.graph.VertexList import VertexList
from apgl.generator.ErdosRenyiGenerator import ErdosRenyiGenerator
import numpy

if len(sys.argv) != 2:
    print('Usage {} <num-vertices>'.format(sys.argv[0]))
    sys.exit(1)

# Generate a random graph
p = 0.2
graph = DenseGraph(VertexList(int(sys.argv[1]), 1))
generator = ErdosRenyiGenerator(p)
graph = generator.generate(graph)

numVertices = graph.getNumVertices()
numEdges = graph.getNumEdges()
print("{} vertices {} edges".format(numVertices, numEdges))

# Write packed adjacency list to a binary file
outfile = 'graph'
f = open(outfile, "wb")
try:
    f.write(struct.pack('i', numVertices))
    f.write(struct.pack('i', numEdges))
    index = 0
    # Vertices
    for i in range(numVertices):
Example #15
0
"""
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()
    def testGenerate(self):
        #undirected = True 
        p = 0.0
             
        self.graph.removeAllEdges()
        self.erg.setP(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), 0)
        
        undirected = False
        self.graph = SparseGraph(self.vList, undirected)
        self.graph.removeAllEdges()
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), 0)
        
        p = 1.0
        undirected = True
        self.graph = SparseGraph(self.vList, undirected)
        self.graph.removeAllEdges()
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), (self.numVertices*self.numVertices-self.numVertices)/2)
        
        p = 1.0
        undirected = False
        self.graph = SparseGraph(self.vList, undirected)
        self.graph.removeAllEdges()
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), self.numVertices*self.numVertices-self.numVertices)
        
        self.assertEquals(graph.getEdge(1, 2), 1)
        self.assertEquals(graph.getEdge(1, 1), None)

        p = 0.5
        numVertices = 1000
        numFeatures = 0

        vList = VertexList(numVertices, numFeatures)
        undirected = False
        self.graph = SparseGraph(vList, undirected)
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)

        self.assertAlmostEquals(graph.getNumEdges()/float(numVertices**2 - numVertices), p, places=2)

        p = 0.1
        self.graph = SparseGraph(vList, undirected)
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)

        self.assertAlmostEquals(graph.getNumEdges()/float(numVertices**2 - numVertices), p, places=2)

        #Test the case in which we have a graph with edges
        p = 0.5
        numVertices = 10 
        vList = VertexList(numVertices, numFeatures)
        graph = SparseGraph(vList, undirected)
        graph.addEdge(0, 1, 5)
        graph.addEdge(0, 2)
        graph.addEdge(0, 5, 0.7)
        graph.addEdge(1, 8)
        graph.addEdge(2, 9)
        numEdges = graph.getNumEdges()

        graph = self.erg.generate(graph, False)
        self.assertTrue(graph.getNumEdges() > numEdges)
 def testErdosRenyiGenerations(self):
     numVertices = 20
     graph = DenseGraph(GeneralVertexList(numVertices))
     p = 0.2
     generator = ErdosRenyiGenerator(p)
     graph = generator.generate(graph)
class ErdoRenyiGeneratorTest(unittest.TestCase):
    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 testGenerate(self):
        #undirected = True 
        p = 0.0
             
        self.graph.removeAllEdges()
        self.erg.setP(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), 0)
        
        undirected = False
        self.graph = SparseGraph(self.vList, undirected)
        self.graph.removeAllEdges()
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), 0)
        
        p = 1.0
        undirected = True
        self.graph = SparseGraph(self.vList, undirected)
        self.graph.removeAllEdges()
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), (self.numVertices*self.numVertices-self.numVertices)/2)
        
        p = 1.0
        undirected = False
        self.graph = SparseGraph(self.vList, undirected)
        self.graph.removeAllEdges()
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)
        self.assertEquals(graph.getNumEdges(), self.numVertices*self.numVertices-self.numVertices)
        
        self.assertEquals(graph.getEdge(1, 2), 1)
        self.assertEquals(graph.getEdge(1, 1), None)

        p = 0.5
        numVertices = 1000
        numFeatures = 0

        vList = VertexList(numVertices, numFeatures)
        undirected = False
        self.graph = SparseGraph(vList, undirected)
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)

        self.assertAlmostEquals(graph.getNumEdges()/float(numVertices**2 - numVertices), p, places=2)

        p = 0.1
        self.graph = SparseGraph(vList, undirected)
        self.erg = ErdosRenyiGenerator(p)
        graph = self.erg.generate(self.graph)

        self.assertAlmostEquals(graph.getNumEdges()/float(numVertices**2 - numVertices), p, places=2)

        #Test the case in which we have a graph with edges
        p = 0.5
        numVertices = 10 
        vList = VertexList(numVertices, numFeatures)
        graph = SparseGraph(vList, undirected)
        graph.addEdge(0, 1, 5)
        graph.addEdge(0, 2)
        graph.addEdge(0, 5, 0.7)
        graph.addEdge(1, 8)
        graph.addEdge(2, 9)
        numEdges = graph.getNumEdges()

        graph = self.erg.generate(graph, False)
        self.assertTrue(graph.getNumEdges() > numEdges)


    @apgl.skip("")
    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([])
        #matplotlib.pyplot.show()

    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 testErdosRenyiGenerations(self):
        numVertices = 20
        graph = DenseGraph(GeneralVertexList(numVertices))
        p = 0.2
        generator = ErdosRenyiGenerator(p)
        graph = generator.generate(graph)