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())
