def testInit(self):
        degSequence = numpy.array([2, 1, 2])
        generator = ConfigModelGenerator(degSequence)
        generator = ConfigModelGenerator(degSequence, degSequence)

        degSequence = numpy.array([2, 1, 3])
        generator = ConfigModelGenerator(degSequence)
        generator = ConfigModelGenerator(degSequence, degSequence)

        self.assertRaises(ValueError, ConfigModelGenerator, None)

        degSequence2 = numpy.array([2, 1, 2.2])
        self.assertRaises(ValueError, ConfigModelGenerator, degSequence2)
        self.assertRaises(ValueError, ConfigModelGenerator, degSequence,
                          degSequence2)

        degSequence2 = numpy.array([2, 1, -1])
        self.assertRaises(ValueError, ConfigModelGenerator, degSequence2)
        self.assertRaises(ValueError, ConfigModelGenerator, degSequence,
                          degSequence2)

        degSequence2 = numpy.array([2, 1, 4])
        self.assertRaises(ValueError, ConfigModelGenerator, degSequence2)
        self.assertRaises(ValueError, ConfigModelGenerator, degSequence,
                          degSequence2)
def computeContactConfigGraphs():
    graphFileNameBase = resultsDir + "ConfigGraph"

    for j in range(numGraphs):
        configGraph = SparseGraph(GeneralVertexList(numVertices))
        degSequence = numpy.zeros(numVertices, numpy.int)
        lastDegSequence = numpy.zeros(numVertices, numpy.int)
        generator = ConfigModelGenerator(lastDegSequence)

        for i in dayList:
            logging.info("Date: " + str(DateUtils.getDateStrFromDay(i, startYear)))
            subgraphIndices = numpy.nonzero(detections <= i)[0]
            subgraphIndices = numpy.unique(subgraphIndices)
            subgraph = sGraph.subgraph(subgraphIndices)

            subDegSequence = subgraph.degreeSequence()
            degSequence[subgraphIndices] = subDegSequence
            diffSequence = degSequence - lastDegSequence
            generator.setOutDegSequence(diffSequence)
            configGraph = generator.generate(configGraph, False)

            lastDegSequence = configGraph.degreeSequence()
            assert (degSequence>=lastDegSequence).all()
            assert subgraph.getNumEdges() >= configGraph.getNumEdges()

        configGraph.save(graphFileNameBase + str(j))
Ejemplo n.º 3
0
def ConfigurationModel(edges_list):
    deg_dict = defaultdict(int)

    for u, v in edges_list:
        deg_dict[v] += 1
    l = array(deg_dict.values())
    n = len(l)
    graph = SparseGraph(n)
    generator = ConfigModelGenerator(l)
    graph = generator.generate(graph)
    l, _ = graph.adjacencyList()
    return convertAdjListToEdgeList(l)
Ejemplo n.º 4
0
def ConfigurationModel(edges_list):
    deg_dict = defaultdict(int)
    
    
    for u,v in edges_list:
        deg_dict[v] += 1
    l = array(deg_dict.values())
    n = len(l)
    graph = SparseGraph(n)
    generator = ConfigModelGenerator(l)
    graph = generator.generate(graph)
    l, _ = graph.adjacencyList()
    return convertAdjListToEdgeList(l)
    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 computeInfectConfigGraphs():
    #We need the directed infection graph 
    hivReader = HIVGraphReader()
    graph = hivReader.readHIVGraph(False)
    sGraphInfect = graph.getSparseGraph(edgeTypeIndex2)
    sGraph = sGraphInfect

    graphFileNameBase = resultsDir + "ConfigInfectGraph"

    for j in range(numGraphs):
        configGraph = SparseGraph(GeneralVertexList(numVertices), False)
        
        outDegSequence = numpy.zeros(numVertices, numpy.int)
        inDegSequence = numpy.zeros(numVertices, numpy.int)
        lastOutDegSequence = numpy.zeros(numVertices, numpy.int)
        lastInDegSequence = numpy.zeros(numVertices, numpy.int)
        generator = ConfigModelGenerator(lastOutDegSequence, lastInDegSequence)

        for i in dayList:
            logging.info("Date: " + str(DateUtils.getDateStrFromDay(i, startYear)))
            subgraphIndices = numpy.nonzero(detections <= i)[0]
            subgraphIndices = numpy.unique(subgraphIndices)
            subgraph = sGraph.subgraph(subgraphIndices)

            outDegSequence[subgraphIndices] = subgraph.outDegreeSequence()
            inDegSequence[subgraphIndices] = subgraph.inDegreeSequence()
            outDiffSequence = outDegSequence - lastOutDegSequence
            inDiffSequence = inDegSequence - lastInDegSequence

            generator.setInDegSequence(inDiffSequence)
            generator.setOutDegSequence(outDiffSequence)
            configGraph = generator.generate(configGraph, False)

            lastOutDegSequence = configGraph.outDegreeSequence()
            lastInDegSequence = configGraph.inDegreeSequence()

            assert (outDegSequence>=lastOutDegSequence).all()
            assert (inDegSequence>=lastInDegSequence).all()

        configGraph.save(graphFileNameBase + str(j))
    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)
    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 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)