def IC(G_df, S, iter_num=3):
'''
Input: G_df: dataframe of edges ['followee','follower', 'prob']
S: seedset
iter_num: Number of total IC steps
mc_num: Number of Monte-Carlo simulations
Output: list of activated nodes
'''
g = nx.DiGraph()
G = G_df[['followee', 'follower']].values
weights = G_df['prob'].values
g.add_edges_from(G, weights=weights)
# Model configuration
model = ep.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_initial_configuration('Infected', S)
# Edge configuration
for e in g.edges:
config.add_edge_configuration('threshold', e, 1)
model.set_initial_status(config)
iteration = model.iteration_bunch(iter_num)
return iteration
activated = []
for i in range(iter_num):
activated += [k for k, v in iteration[i]['status'].items() if v == 1]
return list(set(activated))
def indipendent_cascade_model(self):
'''
Configuration and execution of the Indipendent Cascade Model algorithm, iteration is performed by itetration.
Model execution is stopped when nodes are no longer influenced.
'''
model = ids.IndependentCascadesModel(self.__year_graph)
config = mc.Configuration()
config.add_model_initial_configuration("Infected", self.__seed)
for e in self.__year_graph.edges():
threshold = self.cascade_threshold(e)
config.add_edge_configuration('threshold', e, threshold)
model.set_initial_status(config)
self.__influenced = dict()
while True:
iteration = model.iteration()
if len(iteration.get('status')) == 0:
break
lst = []
for k in iteration.get('status'):
if iteration.get('status')[k] == 1:
lst.append(k)
if len(lst) == 0:
break
self.__influenced['iteration {0}'.format(
iteration.get('iteration'))] = lst
def test_config(self):
for g in get_graph(True):
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
config.add_model_initial_configuration("Infected", [1, 2, 3])
config.add_node_set_configuration("partial", {1: 1, 2: 2})
try:
model.set_initial_status(config)
except:
pass
if isinstance(g, nx.Graph):
edges = list(g.edges)
nodes = list(g.nodes)
else:
edges = [(g.vs[e.tuple[0]]['name'], g.vs[e.tuple[1]]['name'])
for e in g.es]
nodes = g.vs['name']
config.add_edge_set_configuration("partial",
{e: 1
for e in edges[:10]})
try:
model.set_initial_status(config)
except:
pass
config.add_node_set_configuration("partial", {n: 1 for n in nodes})
config.add_edge_set_configuration("partial", {e: 1 for e in edges})
model.set_initial_status(config)
for g in get_graph():
model = opn.MajorityRuleModel(g)
config = mc.Configuration()
config.add_model_parameter("percentage_infected", 0.2)
try:
model.set_initial_status(config)
except:
pass
for g in get_graph(True):
model = epd.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
try:
model.set_initial_status(config)
except:
pass
for g in get_graph(True):
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
try:
model.set_initial_status(config)
except:
pass
def test_independent_cascade_model(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
threshold = 0.1
for e in g.edges():
config.add_edge_configuration("threshold", e, threshold)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def test_config(self):
g = nx.erdos_renyi_graph(99, 0.1)
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
config.add_model_initial_configuration("Infected", [1, 2, 3])
config.add_node_set_configuration("partial", {1: 1, 2: 2})
try:
model.set_initial_status(config)
except:
pass
config.add_edge_set_configuration("partial",
{e: 1
for e in list(g.edges)[:10]})
try:
model.set_initial_status(config)
except:
pass
config.add_node_set_configuration("partial", {n: 1 for n in g.nodes})
config.add_edge_set_configuration("partial", {e: 1 for e in g.edges})
model.set_initial_status(config)
g = nx.complete_graph(100)
model = opn.MajorityRuleModel(g)
config = mc.Configuration()
config.add_model_parameter("fraction_infected", 0.2)
try:
model.set_initial_status(config)
except:
pass
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
try:
model.set_initial_status(config)
except:
pass
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
try:
model.set_initial_status(config)
except:
pass
def test_independent_cascade_model(self):
for g in get_graph(True):
model = epd.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
threshold = 0.1
if isinstance(g, nx.Graph):
for e in g.edges:
config.add_edge_configuration("threshold", e, threshold)
else:
edges = [(g.vs[e.tuple[0]]['name'], g.vs[e.tuple[1]]['name']) for e in g.es]
for e in edges:
config.add_edge_configuration("threshold", e, threshold)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
iterations = model.iteration_bunch(10, node_status=False)
self.assertEqual(len(iterations), 10)
def model_IC(g, S, proba_list, steps):
spread_simulations = []
for k in range(steps):
# r.seed creo que solo en el THmodel para indiv threshol de cada nodo
model = ep.IndependentCascadesModel(g)
config = mc.Configuration()
infected_nodes = S
config.add_model_initial_configuration("Infected", infected_nodes)
# Setting the edge parameters
link = 0
for e in g.edges():
config.add_edge_configuration("proba", e, proba_list[link])
link += 1
model.set_initial_status(config)
# iterations = []
while True:
iteration = model.iteration()
# iterations.append(iteration)
if iteration["iteration"] > 0 and (
iteration["status_delta"][0]
== 0) and (iteration["status_delta"][1]
== 0) and (iteration["status_delta"][2] == 0):
break
#en caso de que se quiera ver la evolución de los infectados, sanos y recuperados
# ina = []
# acti = []
# remo = []
# for i in range(iteration["iteration"]):
# ina.append(iterations[i]["node_count"][0])
# acti.append(iterations[i]["node_count"][1])
# remo.append(iterations[i]["node_count"][2])
#en caso de que se quiera ver la evolución de los infectados, sanos y recuperados
spread_simulations.append(iteration["node_count"][2] - len(S))
vexpected = np.mean(spread_simulations)
#return iterations, ina, acti, remo, maxspread
#return vexpected, spread_simulations
return vexpected
def test_optional_parameters(self):
for g in get_graph(True):
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
if isinstance(g, nx.Graph):
config.add_node_set_configuration("test", {n: 1 for n in g.nodes})
config.add_edge_set_configuration("etest", {e: 1 for e in g.edges})
else:
config.add_node_set_configuration("test", {n: 1 for n in g.vs['name']})
edges = [(g.vs[e.tuple[0]]['name'], g.vs[e.tuple[1]]['name']) for e in g.es]
config.add_edge_set_configuration("etest", {e: 1 for e in edges})
self.assertEqual(len(iterations), 10)
model = epd.KerteszThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('adopter_rate', 0.4)
predefined_blocked = [0, 1, 2, 3, 4, 5]
config.add_model_initial_configuration("Blocked", predefined_blocked)
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iteration = model.iteration()
blocked = [x for x, v in future.utils.iteritems(iteration["status"]) if v == -1]
self.assertEqual(blocked, predefined_blocked)
model = epd.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.ProfileModel(g)
config = mc.Configuration()
config.add_model_parameter('percentage_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.ProfileThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.KerteszThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('adopter_rate', 0.4)
config.add_model_parameter('percentage_blocked', 0.1)
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
def find_diffusion_from_max_metrics(graph, node_list, time_step):
# Model selection
model = ep.IndependentCascadesModel(graph)
node_position = nx.spring_layout(graph)
# Model Configuration
config = mc.Configuration()
config.add_model_initial_configuration('Infected', node_list)
# config.add_model_parameter('fraction_infected',0.1)
# Setting the edge parameters
threshold = 0.25
for e in graph.edges():
config.add_edge_configuration("threshold", e, threshold)
model.set_initial_status(config)
# Simulation execution
iterations = model.iteration_bunch(time_step)
susceptible = iterations[0].get('status')
altered_nodes = dict()
for ii in range(0, time_step):
print(iterations[ii])
if ii > 0:
y = iterations[ii].get('status')
susceptible = {
ii: jj
for ii, jj in susceptible.items() if ii not in y
}
result = dict(y.items() - susceptible.items())
altered_nodes.update(result)
infected_status = 1
infected_nodes = []
removed_nodes = []
for node, status in altered_nodes.items():
if status == infected_status:
infected_nodes.append(node)
else:
removed_nodes.append(node)
percentage_of_infected = (len(infected_nodes) + len(removed_nodes)) / int(
nx.number_of_nodes(graph))
# print(len(infected_nodes))
# print(len(removed_nodes))
# print(int(nx.number_of_nodes(graph)))
print(percentage_of_infected)
title = "The node status after " + str(time_step) + " time steps"
susceptible_nodes = list(susceptible.keys())
nx.draw_networkx_nodes(graph,
pos=node_position,
nodelist=susceptible_nodes,
node_size=20,
node_color="white",
label='Susceptible',
edgecolors="black")
nx.draw_networkx_nodes(graph,
pos=node_position,
nodelist=infected_nodes,
node_size=20,
node_color="red",
label='Infected',
edgecolors="black")
nx.draw_networkx_nodes(graph,
pos=node_position,
nodelist=removed_nodes,
node_size=20,
node_color="blue",
label='Removed',
edgecolors="black")
nx.draw_networkx_edges(graph, pos=node_position)
nx.draw_networkx_labels(graph, pos=node_position, font_size=10)
plt.legend(scatterpoints=1)
plt.title(label=title)
plt.show()
def test_optional_parameters(self):
g = nx.erdos_renyi_graph(1000, 0.1)
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
config.add_node_set_configuration("test", {n: 1 for n in g.nodes()})
config.add_edge_set_configuration("etest", {e: 1 for e in g.edges()})
self.assertEqual(len(iterations), 10)
model = epd.KerteszThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('adopter_rate', 0.4)
predefined_blocked = [0, 1, 2, 3, 4, 5]
config.add_model_initial_configuration("Blocked", predefined_blocked)
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iteration = model.iteration()
blocked = [
x for x, v in future.utils.iteritems(iteration["status"])
if v == -1
]
self.assertEqual(blocked, predefined_blocked)
model = epd.IndependentCascadesModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.ProfileModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.ProfileThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.ThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
model = epd.KerteszThresholdModel(g)
config = mc.Configuration()
config.add_model_parameter('adopter_rate', 0.4)
config.add_model_parameter('percentage_blocked', 0.1)
config.add_model_parameter('fraction_infected', 0.1)
model.set_initial_status(config)
iterations = model.iteration_bunch(10)
self.assertEqual(len(iterations), 10)
score = float(ls[2])
g.add_edge(source, to, weight=score)
# import ndlib.models.ModelConfig as mc
# # Model Configuration
# config = mc.Configuration()
# infected_nodes = [0, 1, 2, 3, 4, 5]
# config.add_model_initial_configuration("Infected", infected_nodes)
# Network topology
# g = nx.erdos_renyi_graph(1000, 0.1)
# Model selection
model = ep.IndependentCascadesModel(g)
# Model Configuration
config = mc.Configuration()
#config.add_model_parameter('fraction_infected', 0.1)
infected_nodes = ['70775228', '70775228', '70775228']
config.add_model_initial_configuration("Infected", infected_nodes)
# Setting the edge parameters
threshold = 0.5
for e in g.edges():
config.add_edge_configuration("threshold", e, threshold)
model.set_initial_status(config)
print("start iteration")
