subgraphIndices = subgraphIndices[0:100]
graph = graph.subgraph(subgraphIndices)
d = 0.5
#Rewrite edges to have a decay rate of d
edges = graph.getAllEdges()
for m in range(edges.shape[0]):
graph.addEdge(edges[m, 0], edges[m, 1], d)
logging.info("Computing max product paths")
#Make sure the diagonal entrices have information 1
P = graph.maxProductPaths()
P = P + numpy.eye(numVertices)
u = numpy.random.rand(numVertices)
L = 0.1*numpy.sum(u)
logging.info("Computing max budgeted influence with branch and bound method")
influence2 = BABInfluence()
inds2 = influence2.maxBudgetedInfluence(P, u, L)
logging.info("Best activation: " + str(numpy.sum(numpy.max(P[inds2, :], 0))))
logging.info("Cost: " + str(numpy.sum(u[inds2, :], 0)) + "\n")
logging.info("Computing max budgeted influence with greedy method")
influence = GreedyInfluence()
inds = influence.maxBudgetedInfluence(P, u, L)
logging.info("Best activation: " + str(numpy.sum(numpy.max(P[inds, :], 0))))
logging.info("Cost: " + str(numpy.sum(u[inds, :], 0)) + "\n\n")
#This is really slow even with 100 vertices - need a better method to cull
#ks = range(10, 100, 10)
ks = list(range(10, 310, 10))
maxK = max(ks)
noises = [0.05, 0.1, 0.15, 0.2]
outputDir = PathDefaults.getOutputDir() + "influence/"
lmbda = 0.1
kernel = LinearKernel()
alterRegressor = PrimalRidgeRegression(lmbda)
egoRegressor = KernelShiftRegression(kernel, lmbda)
edgeLearner = EgoEdgeLabelPredictor(alterRegressor, egoRegressor)
influence = GreedyInfluence()
p = 0.05
cFilename = outputDir + "C.npy"
C = numpy.load(cFilename)
logging.info("Loaded matrix of coefficients from " + cFilename)
classifier = "Ego"
for noise in noises:
graphFilename = outputDir + "SyntheticExamples_n=" + str(noise) + ".spg"
graph = SparseGraph.load(graphFilename)
paramsFile = outputDir + classifier + "ParamsLinear_n=" + str(noise)
paramsList = edgeLearner.loadParams(paramsFile)
influenceArray = numpy.zeros((k, 2))
outputDirectory = PathDefaults.getOutputDir()
outputDir = outputDirectory + "influence/"
for i in range(len(generators)):
fileName = outputDir + "FullTransGraph" + str(generators[i]) + ".spg"
graph = SparseGraph.load(fileName)
numVertices = graph.getNumVertices()
logging.info(graph.degreeDistribution())
logging.info("Computing max product paths")
#Make sure the diagonal entrices have information 1
P = graph.maxProductPaths()
P = P + numpy.eye(numVertices)
logging.info("Computing max influence")
influence = GreedyInfluence()
inds = influence.maxInfluence(P, maxIks)
for m in range(len(iks)):
ik = iks[m]
influenceArray[m, 0, i] = numpy.sum(numpy.max(P[inds[0:ik], :], 0))
influenceArray[m, 1, i] = numpy.sum(numpy.max(P[inds2[0:ik], :], 0))
influenceArray[m, 2, i] = numpy.sum(numpy.max(P[inds3[0:ik], :], 0))
#Now save the results
numpy.save(outputDir + "InfluenceArraySW1", influenceArray[:,:,0])
numpy.save(outputDir + "InfluenceArrayER", influenceArray[:,:,1])
logging.info("All done.")
numVertices = graph.getNumVertices()
#Rewrite edges to have a decay rate of d
edges = graph.getAllEdges()
for m in range(edges.shape[0]):
d = numpy.random.rand()
graph.addEdge(edges[m, 0], edges[m, 1], d)
logging.info("Computing max product paths")
#Make sure the diagonal entrices have information 1
P = graph.maxProductPaths()
P = P + numpy.eye(numVertices)
P2 = numpy.array(P != 0, numpy.int32)
logging.info("Computing max influence")
influence = GreedyInfluence()
inds = influence.maxInfluence(P, maxIks)
logging.info("Computing Kempes max influence")
inds2 = influence.maxInfluence(P2, maxIks)
inds3 = numpy.random.permutation(numVertices)[0:maxIks]
for m in range(len(iks)):
ik = iks[m]
influenceArray[m, 0] = numpy.sum(numpy.max(P[inds[0:ik], :], 0))
influenceArray[m, 1] = numpy.sum(numpy.max(P[inds2[0:ik], :], 0))
influenceArray[m, 2] = numpy.sum(numpy.max(P[inds3[0:ik], :], 0))
#Now save the results
numpy.save(outputDir + "influenceArraySW2", influenceArray)
logging.info("All done.")
