def testSimulate(self): T = 1.0 self.graph.getVertexList().setInfected(0, 0.0) self.model.setT(T) times, infectedIndices, removedIndices, graph = self.model.simulate(verboseOut=True) numInfects = 0 for i in range(graph.getNumVertices()): if graph.getVertex(i)[HIVVertices.stateIndex] == HIVVertices==infected: numInfects += 1 self.assertTrue(numInfects == 0 or times[len(times)-1] >= T) #Test with a larger population as there seems to be an error when the #number of infectives becomes zero. M = 100 undirected = True graph = HIVGraph(M, undirected) graph.setRandomInfected(10, 0.95) self.graph.removeAllEdges() T = 21.0 hiddenDegSeq = self.gen.rvs(size=self.graph.getNumVertices()) rates = HIVRates(self.graph, hiddenDegSeq) model = HIVEpidemicModel(self.graph, rates) model.setRecordStep(10) model.setT(T) times, infectedIndices, removedIndices, graph = model.simulate(verboseOut=True) self.assertTrue((times == numpy.array([0, 10, 20], numpy.int)).all()) self.assertEquals(len(infectedIndices), 3) self.assertEquals(len(removedIndices), 3)
def profileSimulate(self): startDate, endDate, recordStep, printStep, M, targetGraph = HIVModelUtils.realSimulationParams() meanTheta, sigmaTheta = HIVModelUtils.estimatedRealTheta() meanTheta = numpy.array([337, 1.4319, 0.211, 0.0048, 0.0032, 0.5229, 0.042, 0.0281, 0.0076, 0.0293]) undirected = True graph = HIVGraph(M, undirected) logging.info("Created graph: " + str(graph)) alpha = 2 zeroVal = 0.9 p = Util.powerLawProbs(alpha, zeroVal) hiddenDegSeq = Util.randomChoice(p, graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) model = HIVEpidemicModel(graph, rates) model.setT0(startDate) model.setT(startDate+100) model.setRecordStep(recordStep) model.setPrintStep(printStep) model.setParams(meanTheta) logging.debug("MeanTheta=" + str(meanTheta)) ProfileUtils.profile('model.simulate()', globals(), locals())
def testInfectionProbability(self): undirected = True numVertices = 10 graph = HIVGraph(numVertices, undirected) hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) t = 0.1 graph.getVertex(0)[HIVVertices.stateIndex] = HIVVertices.infected graph.getVertex(1)[HIVVertices.stateIndex] = HIVVertices.removed graph.getVertex(2)[HIVVertices.stateIndex] = HIVVertices.infected for vertexInd1 in range(numVertices): for vertexInd2 in range(numVertices): vertex1 = graph.getVertex(vertexInd1) vertex2 = graph.getVertex(vertexInd2) if vertex1[HIVVertices.stateIndex]!=HIVVertices.infected or vertex2[HIVVertices.stateIndex]!=HIVVertices.susceptible: self.assertEquals(rates.infectionProbability(vertexInd1, vertexInd2, t), 0.0) elif vertex1[HIVVertices.genderIndex] == HIVVertices.female and vertex2[HIVVertices.genderIndex] == HIVVertices.male: self.assertEquals(rates.infectionProbability(vertexInd1, vertexInd2, t), rates.infectProb) elif vertex1[HIVVertices.genderIndex] == HIVVertices.male and vertex2[HIVVertices.genderIndex] == HIVVertices.female: self.assertEquals(rates.infectionProbability(vertexInd1, vertexInd2, t), rates.infectProb) elif vertex1[HIVVertices.genderIndex] == HIVVertices.male and vertex2[HIVVertices.orientationIndex]==HIVVertices.bi: self.assertEquals(rates.infectionProbability(vertexInd1, vertexInd2, t), rates.infectProb) else: self.assertEquals(rates.infectionProbability(vertexInd1, vertexInd2, t), 0.0)
def testPickle(self): numVertices = 10 graph = HIVGraph(numVertices) graph[0, 0] = 1 graph[3, 5] = 0.1 output = pickle.dumps(graph) newGraph = pickle.loads(output) graph[2, 2] = 1 self.assertEquals(newGraph[0, 0], 1) self.assertEquals(newGraph[3, 5], 0.1) self.assertEquals(newGraph[2, 2], 0.0) self.assertEquals(newGraph.getNumEdges(), 2) self.assertEquals(newGraph.getNumVertices(), numVertices) self.assertEquals(newGraph.isUndirected(), True) self.assertEquals(graph[0, 0], 1) self.assertEquals(graph[3, 5], 0.1) self.assertEquals(graph[2, 2], 1) self.assertEquals(graph.getNumEdges(), 3) self.assertEquals(graph.getNumVertices(), numVertices) self.assertEquals(graph.isUndirected(), True) for i in range(numVertices): nptst.assert_array_equal(graph.getVertex(i), newGraph.getVertex(i))
def createModel(t): """ The parameter t is the particle index. """ undirected = True graph = HIVGraph(M, undirected) alpha = 2 zeroVal = 0.9 p = Util.powerLawProbs(alpha, zeroVal) hiddenDegSeq = Util.randomChoice(p, graph.getNumVertices()) featureInds= numpy.ones(graph.vlist.getNumFeatures(), numpy.bool) featureInds[HIVVertices.dobIndex] = False featureInds[HIVVertices.infectionTimeIndex] = False featureInds[HIVVertices.hiddenDegreeIndex] = False featureInds[HIVVertices.stateIndex] = False featureInds = numpy.arange(featureInds.shape[0])[featureInds] matcher = GraphMatch("PATH", alpha=0.5, featureInds=featureInds, useWeightM=False) graphMetrics = HIVGraphMetrics2(targetGraph, breakDist, matcher, endDate) graphMetrics.breakDist = 0.0 rates = HIVRates(graph, hiddenDegSeq) model = HIVEpidemicModel(graph, rates, T=float(endDate), T0=float(startDate), metrics=graphMetrics) model.setRecordStep(recordStep) return model
def testContructor(self): numVertices = 10 graph = HIVGraph(numVertices) self.assertEquals(numVertices, graph.getNumVertices()) self.assertEquals(8, graph.getVertexList().getNumFeatures()) self.assertTrue(graph.isUndirected() == True)
def testGetSusceptibleSet(self): numVertices = 10 graph = HIVGraph(numVertices) self.assertTrue(graph.getSusceptibleSet() == set(range(numVertices))) for i in range(9): graph.getVertexList().setInfected(i, 0.0) self.assertTrue(graph.getSusceptibleSet() == set([9]))
def testRemoveEvent(self): undirected = True numVertices = 10 graph = HIVGraph(numVertices, undirected) hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) t = 0.1 V = graph.getVertexList().getVertices() femaleInds = V[:, HIVVertices.genderIndex]==HIVVertices.female maleInds = V[:, HIVVertices.genderIndex]==HIVVertices.male biMaleInds = numpy.logical_and(maleInds, V[:, HIVVertices.orientationIndex]==HIVVertices.bi) self.assertEquals(rates.expandedDegSeqFemales.shape[0], hiddenDegSeq[femaleInds].sum()*rates.p) self.assertEquals(rates.expandedDegSeqMales.shape[0], hiddenDegSeq[maleInds].sum()*rates.p) self.assertEquals(rates.expandedDegSeqBiMales.shape[0], hiddenDegSeq[biMaleInds].sum()*rates.p) graph.getVertexList().setInfected(4, t) graph.getVertexList().setInfected(7, t) graph.getVertexList().setInfected(8, t) rates.removeEvent(4, HIVVertices.randomDetect, t) rates.removeEvent(7, HIVVertices.randomDetect, t) removedInds= list(graph.getRemovedSet()) hiddenDegSeq[removedInds] = 0 #Check the new degree sequences are correct self.assertEquals(rates.expandedDegSeqFemales.shape[0], hiddenDegSeq[femaleInds].sum()*rates.p) self.assertEquals(rates.expandedDegSeqMales.shape[0], hiddenDegSeq[maleInds].sum()*rates.p) self.assertEquals(rates.expandedDegSeqBiMales.shape[0], hiddenDegSeq[biMaleInds].sum()*rates.p)
def testRandomDetectionRates(self): undirected = True numVertices = 10 graph = HIVGraph(numVertices, undirected) t = 0.1 graph.getVertexList().setInfected(0, t) hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) infectedList = [0, 2, 9] rdRates = rates.randomDetectionRates(infectedList, float(graph.size - len(graph.getRemovedSet()))) nptst.assert_array_almost_equal(rdRates, numpy.ones(len(infectedList))*rates.randDetectRate*len(infectedList)/float(graph.size - len(graph.getRemovedSet())))
def testSummary(self): numVertices = 10 graph = HIVGraph(numVertices) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(2, 2.0) graph.getVertexList().setInfected(7, 3.0) times = numpy.array([0, 1.0, 3.0, 4.0]) metrics = HIVGraphMetrics(times) summary = metrics.summary(graph) summaryReal = numpy.array([[1,0], [1,0], [3, 0], [3,0]]) nptst.assert_array_equal(summaryReal, summary)
def __init__(self): #Total number of people in population self.M = 1000 numInitialInfected = 5 #The graph is one in which edges represent a contact undirected = True self.graph = HIVGraph(self.M, undirected) for i in range(self.M): vertex = self.graph.getVertex(i) #Set the infection time of a number of individuals to 0 if i < numInitialInfected: vertex[HIVVertices.stateIndex] = HIVVertices.infected p = 0.01 generator = ErdosRenyiGenerator(p) self.graph = generator.generate(self.graph) perm1 = numpy.random.permutation(self.M) perm2 = numpy.random.permutation(self.M) sizes = [200, 300, 500, 1000] self.summary1 = [] self.summary2 = [] for size in sizes: self.summary1.append(self.graph.subgraph(perm1[0:size])) self.summary2.append(self.graph.subgraph(perm2[0:int(size/10)])) print(self.graph)
def simulate(theta, startDate, endDate, recordStep, M, graphMetrics=None): undirected = True graph = HIVGraph(M, undirected) logging.debug("Created graph: " + str(graph)) alpha = 2 zeroVal = 0.9 p = Util.powerLawProbs(alpha, zeroVal) hiddenDegSeq = Util.randomChoice(p, graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) model = HIVEpidemicModel(graph, rates, endDate, startDate, metrics=graphMetrics) model.setRecordStep(recordStep) model.setParams(theta) logging.debug("Theta = " + str(theta)) return model.simulate(True)
class HIVGraphMetricsProfile(): def __init__(self): #Total number of people in population self.M = 1000 numInitialInfected = 5 #The graph is one in which edges represent a contact undirected = True self.graph = HIVGraph(self.M, undirected) for i in range(self.M): vertex = self.graph.getVertex(i) #Set the infection time of a number of individuals to 0 if i < numInitialInfected: vertex[HIVVertices.stateIndex] = HIVVertices.infected p = 0.01 generator = ErdosRenyiGenerator(p) self.graph = generator.generate(self.graph) perm1 = numpy.random.permutation(self.M) perm2 = numpy.random.permutation(self.M) sizes = [200, 300, 500, 1000] self.summary1 = [] self.summary2 = [] for size in sizes: self.summary1.append(self.graph.subgraph(perm1[0:size])) self.summary2.append(self.graph.subgraph(perm2[0:int(size/10)])) print(self.graph) def profileDistance(self): times = numpy.arange(len(self.summary1)) #metrics = HIVGraphMetrics2(times, GraphMatch("RANK")) metrics = HIVGraphMetrics2(times, GraphMatch("U")) #Can try RANK and Umeyama algorithm - Umeyama is faster self.summary2 = self.summary2[0:2] ProfileUtils.profile('metrics.distance(self.summary1, self.summary2)', globals(), locals())
def testInfectedIndsAt(self): numVertices = 10 graph = HIVGraph(numVertices) self.assertTrue(graph.getRemovedSet() == set([])) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(2, 2.0) graph.getVertexList().setInfected(7, 3.0) inds = graph.infectedIndsAt(10) nptst.assert_array_equal(inds, numpy.array([1, 2, 7])) graph.getVertexList().setInfected(5, 12.0) nptst.assert_array_equal(inds, numpy.array([1, 2, 7]))
def testContactRates3(self): #Figure out why infection does not explode when we set infection probability #to a high value and do not detect undirected = True numVertices = 20 graph = HIVGraph(numVertices, undirected) hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) t = 0.1 for i in range(10): graph.getVertexList().setInfected(i, t) t = 0.2 infectedList = graph.infectedIndsAt(t) contactList = range(0, numVertices) contactRateInds, contactRates = rates.contactRates(infectedList, contactList, t) print(contactRateInds, contactRates)
def setUp(self): numpy.seterr(invalid='raise') logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) numpy.set_printoptions(suppress=True, precision=4, linewidth=100) numpy.random.seed(21) M = 1000 undirected = True graph = HIVGraph(M, undirected) alpha = 2 zeroVal = 0.9 p = Util.powerLawProbs(alpha, zeroVal) hiddenDegSeq = Util.randomChoice(p, graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) self.numParams = 6 self.graph = graph self.meanTheta = numpy.array([100, 0.9, 0.05, 0.001, 0.1, 0.005]) self.hivAbcParams = HIVABCParameters(self.meanTheta, self.meanTheta/2)
def testContactRates(self): undirected = True numVertices = 10 graph = HIVGraph(numVertices, undirected) t = 0.2 contactList = range(numVertices) hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) contactRateInds, contactRates = rates.contactRates([0, 5, 7], contactList, t) self.assertEquals(contactRates.shape[0], 3) #Now we have that 0 had contact with another rates.contactEvent(0, 3, 0.2) rates.contactEvent(1, 9, 0.1) infectedInds = numpy.arange(numVertices) contactRateInds, contactRates = rates.contactRates(infectedInds, contactList, t) #Note that in some cases an infected has no contacted as the persons do not match for i in range(infectedInds.shape[0]): if contactRateInds[i] != -1: if graph.getVertex(infectedInds[i])[HIVVertices.genderIndex]==graph.getVertex(contactRateInds[i])[HIVVertices.genderIndex]: self.assertEquals(contactRates[i], rates.heteroContactRate) elif graph.getVertex(infectedInds[i])[HIVVertices.genderIndex]!=graph.getVertex(contactRateInds[1])[HIVVertices.genderIndex] and graph.getVertex(infectedInds[i])[HIVVertices.orientationIndex]==HIVVertices.bi and graph.getVertex(contactRateInds[i])[HIVVertices.orientationIndex]==HIVVertices.bi: self.assertEquals(contactRates[i],rates.biContactRate)
def testUpperDetectionRates(self): """ See if the upper bound on detection rates is correct """ undirected = True numVertices = 10 graph = HIVGraph(numVertices, undirected) hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) t = 0.1 graph.getVertexList().setInfected(0, t) graph.getVertexList().setInfected(1, t) graph.getVertexList().setInfected(8, t) t = 0.2 rates.removeEvent(8, HIVVertices.randomDetect, t) rates.infectionProbability = 1.0 infectedList = graph.infectedIndsAt(t) removedList = graph.removedIndsAt(t) n = graph.size-removedList self.assertEquals(rates.upperDetectionRates(infectedList, n), rates.randomDetectionRates(infectedList, n, seed=21).sum()) t = 0.3 rates.contactEvent(0, 2, t) graph.vlist.setInfected(2, t) t = 0.4 rates.removeEvent(0, HIVVertices.randomDetect, t) infectedList = graph.infectedIndsAt(t) removedSet = graph.removedIndsAt(t) removedSet = set(removedSet.tolist()) nptst.assert_array_almost_equal(rates.contactTracingRates(infectedList, removedSet, t + rates.ctStartTime + 1), numpy.array([0, rates.ctRatePerPerson])) upperDetectionRates = rates.ctRatePerPerson + rates.randomDetectionRates(infectedList, n, seed=21).sum() self.assertEquals(rates.upperDetectionRates(infectedList, n), upperDetectionRates)
def testGetInfectedSet(self): numVertices = 10 graph = HIVGraph(numVertices) self.assertTrue(graph.getInfectedSet() == set([])) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(3, 0.0) graph.getVertexList().setInfected(7, 0.0) self.assertTrue(graph.getInfectedSet() == set([1, 3, 7]))
def setUp(self): numpy.random.seed(21) numpy.set_printoptions(suppress=True, precision=4) logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) M = 100 undirected = True self.graph = HIVGraph(M, undirected) s = 3 self.gen = scipy.stats.zipf(s) hiddenDegSeq = self.gen.rvs(size=self.graph.getNumVertices()) rates = HIVRates(self.graph, hiddenDegSeq) self.model = HIVEpidemicModel(self.graph, rates)
def runModel(theta, endDate=100.0, M=1000): numpy.random.seed(21) undirected= True recordStep = 10 printStep = 10 startDate = 0 alpha = 2 zeroVal = 0.9 p = Util.powerLawProbs(alpha, zeroVal) graph = HIVGraph(M, undirected) hiddenDegSeq = Util.randomChoice(p, graph.getNumVertices()) logging.debug("MeanTheta=" + str(theta)) rates = HIVRates(graph, hiddenDegSeq) model = HIVEpidemicModel(graph, rates, endDate, startDate) model.setRecordStep(recordStep) model.setPrintStep(printStep) model.setParams(theta) times, infectedIndices, removedIndices, graph = model.simulate(True) return times, infectedIndices, removedIndices, graph, model
def findDerivative(args): pertScale, startDate, endDate, recordStep, M, targetGraph, seed = args numpy.random.seed(seed) meanTheta, sigmaTheta = HIVModelUtils.toyTheta() epsilon = 5.0 undirected = True alpha = 2 zeroVal = 0.9 p = Util.powerLawProbs(alpha, zeroVal) graph = HIVGraph(M, undirected) featureInds= numpy.ones(graph.vlist.getNumFeatures(), numpy.bool) featureInds[HIVVertices.dobIndex] = False featureInds[HIVVertices.infectionTimeIndex] = False featureInds[HIVVertices.hiddenDegreeIndex] = False featureInds[HIVVertices.stateIndex] = False featureInds = numpy.arange(featureInds.shape[0])[featureInds] matcher = GraphMatch("PATH", alpha=0.5, featureInds=featureInds, useWeightM=False) abcParams = HIVABCParameters(meanTheta, sigmaTheta, pertScale) newTheta = abcParams.perturbationKernel(meanTheta) undirected = True graph = HIVGraph(M, undirected) graphMetrics = HIVGraphMetrics2(targetGraph, epsilon, matcher, float(endDate)) graphMetrics.breakDist = 1.0 hiddenDegSeq = Util.randomChoice(p, graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) model = HIVEpidemicModel(graph, rates, T=float(endDate), T0=float(startDate), metrics=graphMetrics) model.setRecordStep(recordStep) model.setParams(meanTheta) times, infectedIndices, removedIndices, graph = model.simulate(True) return abs(0.7 - graphMetrics.distance())/numpy.linalg.norm(newTheta-meanTheta)
def testShouldBreak(self): numVertices = 10 graph = HIVGraph(numVertices) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(2, 2.0) graph.getVertexList().setInfected(7, 3.0) summary1 = numpy.array([[1,0], [1,0], [3, 0], [3,0]]) summary2 = numpy.array([[1,0], [2,0], [3, 0], [3,0]]) times = numpy.array([0, 1.0, 3.0, 4.0]) epsilon = 1 currentTime = 5 self.assertTrue(HIVGraphMetrics(times).shouldBreak(summary2, graph, epsilon, currentTime)) currentTime = 1 self.assertTrue(HIVGraphMetrics(times).shouldBreak(summary2, graph, epsilon, currentTime)) currentTime = 0.9 self.assertFalse(HIVGraphMetrics(times).shouldBreak(summary2, graph, epsilon, currentTime))
def setUp(self): numpy.random.seed(21) numpy.set_printoptions(linewidth=100, suppress=True, precision=3) numVertices = 10 self.graph = HIVGraph(numVertices) self.graph.vlist.setInfected(1, 0.0) self.graph.vlist.setDetected(1, 0.1, 0) self.graph.vlist.setInfected(2, 2.0) self.graph.vlist.setDetected(2, 2.0, 0) self.graph.vlist.setInfected(7, 3.0) self.graph.vlist.setDetected(7, 3.0, 0)
def toySimulationParams(loadTarget=True): if loadTarget: resultsDir = PathDefaults.getOutputDir() + "viroscopy/toy/" graphFile = resultsDir + "ToyEpidemicGraph0" targetGraph = HIVGraph.load(graphFile) startDate = 0.0 endDate = 500.0 recordStep = 50 M = 5000 if loadTarget: return startDate, endDate, recordStep, M, targetGraph else: return startDate, endDate, recordStep, M
def __init__(self): #Total number of people in population self.M = 10000 numInitialInfected = 5 #The graph is one in which edges represent a contact undirected = True self.graph = HIVGraph(self.M, undirected) for i in range(self.M): vertex = self.graph.getVertex(i) #Set the infection time of a number of individuals to 0 if i < numInitialInfected: vertex[HIVVertices.stateIndex] = HIVVertices.infected outputDirectory = PathDefaults.getOutputDir() directory = outputDirectory + "test/" self.profileFileName = directory + "profile.cprof"
def testContactEvent(self): undirected = True numVertices = 10 graph = HIVGraph(numVertices, undirected) #for i in range(numVertices): # logging.debug(graph.getVertex(i)) t = 0.2 hiddenDegSeq = self.gen.rvs(size=graph.getNumVertices()) rates = HIVRates(graph, hiddenDegSeq) V = graph.getVertexList().getVertices() femaleInds = V[:, HIVVertices.genderIndex]==HIVVertices.female maleInds = V[:, HIVVertices.genderIndex]==HIVVertices.male biMaleInds = numpy.logical_and(maleInds, V[:, HIVVertices.orientationIndex]==HIVVertices.bi) self.assertEquals(rates.expandedDegSeqFemales.shape[0], hiddenDegSeq[femaleInds].sum()*rates.p) self.assertEquals(rates.expandedDegSeqMales.shape[0], hiddenDegSeq[maleInds].sum()*rates.p) self.assertEquals(rates.expandedDegSeqBiMales.shape[0], hiddenDegSeq[biMaleInds].sum()*rates.p) for i in range(numVertices): self.assertEquals(rates.contactTimesArr[i], -1) rates.contactEvent(0, 9, 0.1) rates.contactEvent(0, 3, 0.2) self.assertEquals(graph.getEdge(0, 3), 0.2) self.assertEquals(graph.getEdge(0, 9), 0.1) self.assertTrue((rates.contactTimesArr[0] == numpy.array([3])).all()) self.assertTrue((rates.contactTimesArr[9] == numpy.array([0])).all()) self.assertTrue((rates.contactTimesArr[3] == numpy.array([0])).all()) for i in range(numVertices): self.assertTrue((rates.neighboursList[i] == graph.neighbours(i)).all()) #Check that the degree sequence is correct degSequence = graph.outDegreeSequence() r = rates.q-rates.p self.assertEquals(rates.expandedDegSeqFemales.shape[0], hiddenDegSeq[femaleInds].sum()*rates.p + degSequence[femaleInds].sum()*r) self.assertEquals(rates.expandedDegSeqMales.shape[0], hiddenDegSeq[maleInds].sum()*rates.p + degSequence[maleInds].sum()*r) self.assertEquals(rates.expandedDegSeqBiMales.shape[0], hiddenDegSeq[biMaleInds].sum()*rates.p + degSequence[biMaleInds].sum()*r)
def testAddGraph(self): epsilon = 0.12 metrics = HIVGraphMetrics2(self.graph, epsilon) metrics.addGraph(self.graph) self.assertEquals(metrics.dists[0], 0.0) self.assertEquals(metrics.meanDistance(), 0.0) #Start a new graph #Compute distances directly matcher = GraphMatch("U") graph = HIVGraph(self.graph.size) dists = [] metrics = HIVGraphMetrics2(self.graph, epsilon) graph.vlist.setInfected(1, 0.0) graph.vlist.setDetected(1, 0.1, 0) metrics.addGraph(graph) t = graph.endTime() subgraph1 = graph.subgraph(graph.removedIndsAt(t)) subgraph2 = self.graph.subgraph(graph.removedIndsAt(t)) permutation, distance, time = matcher.match(subgraph1, subgraph2) lastDist = matcher.distance(subgraph1, subgraph2, permutation, True, True) self.assertEquals(metrics.dists[-1], lastDist) self.assertTrue(metrics.shouldBreak()) graph.vlist.setInfected(2, 2.0) graph.vlist.setDetected(2, 2.0, 0) metrics.addGraph(graph) t = graph.endTime() subgraph1 = graph.subgraph(graph.removedIndsAt(t)) subgraph2 = self.graph.subgraph(graph.removedIndsAt(t)) permutation, distance, time = matcher.match(subgraph1, subgraph2) lastDist = matcher.distance(subgraph1, subgraph2, permutation, True, True) self.assertEquals(metrics.dists[-1], lastDist) self.assertTrue(metrics.shouldBreak()) graph.vlist.setInfected(7, 3.0) graph.vlist.setDetected(7, 3.0, 0) metrics.addGraph(graph) t = graph.endTime() subgraph1 = graph.subgraph(graph.removedIndsAt(t)) subgraph2 = self.graph.subgraph(graph.removedIndsAt(t)) permutation, distance, time = matcher.match(subgraph1, subgraph2) lastDist = matcher.distance(subgraph1, subgraph2, permutation, True, True) self.assertEquals(metrics.dists[-1], lastDist) self.assertFalse(metrics.shouldBreak()) #Test case where one graph has zero size graph1 = HIVGraph(10) graph2 = HIVGraph(10) graph1.vlist[:, HIVVertices.stateIndex] = HIVVertices.removed metrics = HIVGraphMetrics2(graph2, epsilon) metrics.addGraph(graph1) #Problem is that distance is 1 when one graph is zero self.assertEquals(len(metrics.dists), 0)
class HIVGraphMetricsTest(unittest.TestCase): def setUp(self): numpy.random.seed(21) numpy.set_printoptions(linewidth=100, suppress=True, precision=3) numVertices = 10 self.graph = HIVGraph(numVertices) self.graph.getVertexList().setInfected(1, 0.0) self.graph.getVertexList().setDetected(1, 0.1, 0) self.graph.getVertexList().setInfected(2, 2.0) self.graph.getVertexList().setDetected(2, 2.0, 0) self.graph.getVertexList().setInfected(7, 3.0) self.graph.getVertexList().setDetected(7, 3.0, 0) def testSummary(self): numVertices = 10 graph = HIVGraph(numVertices) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(2, 2.0) graph.getVertexList().setInfected(7, 3.0) times = numpy.array([0, 1.0, 3.0, 4.0]) metrics = HIVGraphMetrics(times) summary = metrics.summary(graph) summaryReal = numpy.array([[1,0], [1,0], [3, 0], [3,0]]) nptst.assert_array_equal(summaryReal, summary) def testDistance(self): summary1 = numpy.array([[1,0], [1,0], [3, 0], [3,0]]) summary2 = numpy.array([[1,0], [1,0], [3, 0], [4,0]]) times = numpy.array([0, 1.0, 3.0, 4.0]) self.assertEquals(HIVGraphMetrics(times).distance(summary1, summary2), numpy.linalg.norm(summary1 - summary2)) def testShouldBreak(self): numVertices = 10 graph = HIVGraph(numVertices) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(2, 2.0) graph.getVertexList().setInfected(7, 3.0) summary1 = numpy.array([[1,0], [1,0], [3, 0], [3,0]]) summary2 = numpy.array([[1,0], [2,0], [3, 0], [3,0]]) times = numpy.array([0, 1.0, 3.0, 4.0]) epsilon = 1 currentTime = 5 self.assertTrue(HIVGraphMetrics(times).shouldBreak(summary2, graph, epsilon, currentTime)) currentTime = 1 self.assertTrue(HIVGraphMetrics(times).shouldBreak(summary2, graph, epsilon, currentTime)) currentTime = 0.9 self.assertFalse(HIVGraphMetrics(times).shouldBreak(summary2, graph, epsilon, currentTime))
def testDetectedNeighbours(self): numVertices = 10 graph = HIVGraph(numVertices) self.assertTrue(graph.getRemovedSet() == set([])) graph.getVertexList().setInfected(1, 0.0) graph.getVertexList().setInfected(2, 0.0) graph.getVertexList().setInfected(7, 0.0) graph.getVertexList().setDetected(1, 0.0, HIVVertices.randomDetect) graph.getVertexList().setDetected(2, 0.0, HIVVertices.randomDetect) graph.getVertexList().setDetected(7, 0.0, HIVVertices.randomDetect) graph[0, 1] = 1 graph[0, 2] = 1 graph[0, 3] = 1 graph[0, 4] = 1 self.assertTrue((graph.detectedNeighbours(0) == numpy.array([1, 2])).all()) graph.getVertexList().setInfected(3, 0.0) graph.getVertexList().setDetected(3, 0.0, HIVVertices.randomDetect) self.assertTrue((graph.detectedNeighbours(0) == numpy.array([1, 2, 3])).all())