Exemplo n.º 1
0
    def test_edge_num_attribute(self):

        g = nx.karate_club_graph()
        attr = {(u, v): {"even": int((u+v) % 10)} for (u, v) in g.edges()}
        nx.set_edge_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.EdgeNumericalAttribute("even", value=0, op="==", probability=1)
        model.add_rule("Susceptible", "Infected", c)

        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 = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.EdgeNumericalAttribute("even", value=[3, 10], op="IN", probability=1)
        model.add_rule("Susceptible", "Infected", c)

        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)
Exemplo n.º 2
0
    def test_edge_stochastic(self):

        # Fixed Threshold
        g = nx.erdos_renyi_graph(1000, 0.1)
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")

        c1 = cpm.EdgeStochastic(0.1, triggering_status="Infected")
        model.add_rule("Susceptible", "Infected", c1)

        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)

        # Ad-hoc Threshold
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")

        c1 = cpm.EdgeStochastic(triggering_status="Infected")
        model.add_rule("Susceptible", "Infected", c1)

        config = mc.Configuration()

        for e in g.edges():
            config.add_edge_configuration("threshold", e,
                                          np.random.random_sample())

        config.add_model_parameter('percentage_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(10)
        self.assertEqual(len(iterations), 10)

        # Predefined threshold 1/N

        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")

        c1 = cpm.EdgeStochastic(triggering_status="Infected")
        model.add_rule("Susceptible", "Infected", c1)

        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)
Exemplo n.º 3
0
    def test_compartment_add_node_pa(self):

        g = nx.karate_club_graph()
        attr = {n: {"even": int(n % 2)} for n in g.nodes()}
        nx.set_node_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        a1 = act.AddNode(probability=1,
                         initial_status="Susceptible",
                         copy_attributes=True,
                         number_of_edges=4,
                         model='PA')
        c1 = cmp.NodeStochastic(1)

        model.add_rule("Susceptible", "Susceptible", c1)
        model.add_action(a1)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(6)
        nodes = [sum(n['node_count'].values()) for n in iterations]
        self.assertEqual(nodes, [35, 36, 37, 38, 39, 40])
Exemplo n.º 4
0
    def test_compartment_add_node(self):

        g = nx.karate_club_graph()
        attr = {n: {"even": int(n % 2)} for n in g.nodes()}
        nx.set_node_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c2 = act.AddNode(probability=1,
                         initial_status="Susceptible",
                         copy_attributes=True)
        c1 = cpm.NodeStochastic(1, composed=c2)

        model.add_rule("Susceptible", "Susceptible", c1)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(6)
        nodes = [sum(n['node_count'].values()) for n in iterations]

        self.assertEqual(nodes, [34, 67, 133, 265, 529, 1057])
Exemplo n.º 5
0
    def test_compartment_swap_edge(self):

        g = nx.karate_club_graph()
        attr = {(u, v): {"even": int((u + v) % 10)} for (u, v) in g.edges()}
        nx.set_edge_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        a1 = act.SwapEdges(probability=1,
                           number_of_swaps=1,
                           copy_attributes=True,
                           initial_status="Susceptible")
        c1 = cmp.NodeStochastic(0.5)

        model.add_rule("Susceptible", "Susceptible", c1)
        model.add_action(a1)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(6)
        self.assertEqual(len(iterations), 6)
Exemplo n.º 6
0
def full_simulate_net_diffusion(frac_infected=0.01,
                                threshold=0.038,
                                profile=0.0000105,
                                p_removal=0.22,
                                num_exec=20,
                                num_iter=32,
                                nproc=8):
    # Network generation
    g = nx.erdos_renyi_graph(1000, 0.1)

    # Composite Model instantiation
    sir_th_model = CompMod.CompositeModel(g)

    # Model statuses
    sir_th_model.add_status("Susceptible")
    sir_th_model.add_status("Infected")
    sir_th_model.add_status("Removed")

    # Compartment definition
    c1 = NodeThreshold(threshold=None, triggering_status="Infected")
    c2 = NodeStochastic(p_removal)

    # Rule definition
    sir_th_model.add_rule("Susceptible", "Infected", c1)
    sir_th_model.add_rule("Infected", "Removed", c2)

    # Model initial status configuration, assume 1% of population is infected
    config = MoCon.Configuration()
    config.add_model_parameter('fraction_infected', frac_infected)

    # Setting nodes parameters
    for i in g.nodes():
        config.add_node_configuration("threshold", i, threshold)
        config.add_node_configuration("profile", i, profile)

    # Simulation execution
    sir_th_model.set_initial_status(config)
    trends = multi_runs(sir_th_model,
                        execution_number=num_exec,
                        iteration_number=num_iter,
                        nprocesses=nproc)

    # Convert into a dataframe that lists each number of infected nodes by iteration number (to make average
    # calculation)
    df_infected = pd.DataFrame(
        [execution['trends']['node_count'][1] for execution in trends])

    # Normalize each run, so that they are consistent with Google Trends Data for comparison:
    df_infected = df_infected.apply(lambda x: x / x.max(), axis=1)
    df_infected = pd.melt(df_infected,
                          var_name='Execution',
                          value_name='Infected')
    df_infected['Infected'] *= 100

    return df_infected
Exemplo n.º 7
0
def simulate_net_diffusion(frac_infected=0.01,
                           threshold=0.18,
                           profile=0.00001,
                           p_removal=0.017,
                           num_exec=10,
                           num_iter=100,
                           nproc=8):

    g = nx.erdos_renyi_graph(1000, 0.1)

    # Composite Model instantiation
    sir_th_model = CompMod.CompositeModel(g)

    # Model statuses
    sir_th_model.add_status("Susceptible")
    sir_th_model.add_status("Infected")
    sir_th_model.add_status("Removed")

    # Compartment definition
    c1 = NodeThreshold(threshold=None, triggering_status="Infected")
    c2 = NodeStochastic(p_removal)

    # Rule definition
    sir_th_model.add_rule("Susceptible", "Infected", c1)
    sir_th_model.add_rule("Infected", "Removed", c2)

    # Model initial status configuration
    config = MoCon.Configuration()
    config.add_model_parameter('fraction_infected', frac_infected)

    # Setting nodes parameters
    for i in g.nodes():
        config.add_node_configuration("threshold", i, threshold)
        config.add_node_configuration("profile", i, profile)

    # Simulation execution
    sir_th_model.set_initial_status(config)
    trends = multi_runs(sir_th_model,
                        execution_number=num_exec,
                        iteration_number=num_iter,
                        nprocesses=nproc)

    df_infected = pd.DataFrame(
        [execution['trends']['node_count'][1] for execution in trends])

    # Normalize each run:
    df_infected = df_infected.apply(lambda x: x / x.max(), axis=1)
    df_infected = pd.melt(df_infected,
                          var_name='Execution',
                          value_name='Infected')

    # Normalize (mean) values so that they are consistent with Google Trends Data for comparison:
    y_forecasted = df_infected.groupby('Execution').mean() * 100

    return y_forecasted
Exemplo n.º 8
0
    def test_node_threshold(self):

        # Fixed Threshold
        g = nx.erdos_renyi_graph(1000, 0.1)
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")

        c1 = cpm.NodeThreshold(0.1, triggering_status="Infected")
        model.add_rule("Susceptible", "Infected", c1)

        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)

        # Ad-hoc Threshold
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")

        c1 = cpm.NodeThreshold(triggering_status="Infected")
        model.add_rule("Susceptible", "Infected", c1)

        config = mc.Configuration()

        for i in g.nodes():
            config.add_node_configuration("threshold", i,
                                          np.random.random_sample())

        config.add_model_parameter('fraction_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(10)
        self.assertEqual(len(iterations), 10)
Exemplo n.º 9
0
def generate_model(network):

    # model parameters
    infect_probability = 0.025
    incubation_time = 14
    incubation_probability = 0.5
    ill_probability = 0.5
    disease_time = 21
    recover_probability = 0.66

    # Composite Model instantiation
    model = gc.CompositeModel(network)

    # Model statuses
    model.add_status("Susceptible")
    model.add_status("Infected")
    model.add_status("Contagious")
    model.add_status("Ill")
    #model.add_status("Hospitalized")
    model.add_status("Dead")
    model.add_status("Recovered")

    # if another node is contagious or ill, this node can get infected
    infect_condition_c = EdgeStochastic(infect_probability, "Contagious")
    model.add_rule("Susceptible", "Infected", infect_condition_c)
    infect_condition_i = EdgeStochastic(infect_probability, "Ill")
    model.add_rule("Susceptible", "Infected", infect_condition_i)
    # if infected, after incubation time there is a chance of becoming contagious
    incubation_time_condition = CountDown("incubation",
                                          iterations=incubation_time)
    incubation_probability_condition = NodeStochastic(
        incubation_probability, composed=incubation_time_condition)
    model.add_rule("Infected", "Contagious", incubation_probability_condition)
    # if contagious, there is a chance of becoming ill
    ill_probability_condition = NodeStochastic(ill_probability,
                                               triggering_status="Contagious")
    model.add_rule("Infected", "Ill", ill_probability_condition)
    # if ill, after disease time there is a chance of becoming Recovered
    recover_time_condition = CountDown("incubation", iterations=disease_time)
    recover_probability_condition = NodeStochastic(
        recover_probability, composed=recover_time_condition)
    model.add_rule("Ill", "Recovered", recover_probability_condition)
    #  if ill, after disease time there is also chance of becoming Dead
    die_probability_condition = NodeStochastic((1 - recover_probability),
                                               composed=recover_time_condition)
    model.add_rule("Ill", "Dead", die_probability_condition)

    return model
Exemplo n.º 10
0
    def test_countwodn(self):

        g = nx.karate_club_graph()

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.CountDown(name="time", iterations=4)
        model.add_rule("Susceptible", "Infected", c)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(100)
        self.assertEqual(len(iterations), 100)
Exemplo n.º 11
0
    def test_node_attribute(self):

        g = nx.karate_club_graph()
        attr = {n: {"even": int(n % 2)} for n in g.nodes()}
        nx.set_node_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.NodeCategoricalAttribute("even", "0", probability=0.6)
        model.add_rule("Susceptible", "Infected", c)

        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)
Exemplo n.º 12
0
    def test_compartment_remove_node(self):

        g = nx.karate_club_graph()

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c2 = act.RemoveNode(probability=1)
        c1 = cpm.NodeStochastic(1, composed=c2)

        model.add_rule("Susceptible", "Susceptible", c1)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(6)
        nodes = [sum(n['node_count'].values()) for n in iterations]
        self.assertEqual(nodes, [34, 1, 1, 1, 1, 1])
Exemplo n.º 13
0
    def test_node_stochastic_composed(self):
        g = nx.erdos_renyi_graph(1000, 0.1)
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")
        model.add_status("Removed")

        # cascading composition
        c3 = cpm.NodeStochastic(0.2)
        c2 = cpm.NodeStochastic(0.4, composed=c3)
        c1 = cpm.NodeStochastic(0.5, "Infected", composed=c2)

        model.add_rule("Susceptible", "Infected", c1)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(100)
        self.assertEqual(len(iterations), 100)
Exemplo n.º 14
0
    def test_compartment_remove_node_bottom(self):

        g = nx.karate_club_graph()

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        a1 = act.RemoveNode(probability=1, model="bottom")
        c1 = cmp.NodeStochastic(0.5)

        model.add_rule("Susceptible", "Susceptible", c1)
        model.add_action(a1)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(6)
        nodes = [sum(n['node_count'].values()) for n in iterations]
        self.assertEqual(nodes, [33, 32, 31, 30, 29, 28])
Exemplo n.º 15
0
    def test_node_stochastic(self):
        g = nx.erdos_renyi_graph(1000, 0.1)
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")
        model.add_status("Removed")

        c1 = cpm.NodeStochastic(0.02, "Infected")
        c2 = cpm.NodeStochastic(0.01)
        c3 = cpm.NodeStochastic(0.5)

        model.add_rule("Susceptible", "Infected", c1)
        model.add_rule("Infected", "Removed", c2)
        model.add_rule("Infected", "Susceptible", c3)

        config = mc.Configuration()
        config.add_model_parameter('fraction_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(100)
        self.assertEqual(len(iterations), 100)
Exemplo n.º 16
0
    def test_conditional_composition(self):
        g = nx.erdos_renyi_graph(1000, 0.1)
        model = gc.CompositeModel(g)

        model.add_status("Susceptible")
        model.add_status("Infected")
        model.add_status("Removed")

        # conditional composition
        c1 = cpm.NodeStochastic(0.5)
        c2 = cpm.NodeStochastic(0.2)
        c3 = cpm.NodeStochastic(0.1)

        cc = cpm.ConditionalComposition(c1, c2, c3)

        model.add_rule("Susceptible", "Infected", cc)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(100)
        self.assertEqual(len(iterations), 100)
Exemplo n.º 17
0
import ndlib.models.CompositeModel as gc
import ndlib.models.ModelConfig as mc
import networkx as nx
from ndlib.models.compartments import NodeStochastic
import heuristics
import random

random.seed(a=27609)
G = nx.barabasi_albert_graph(2000, 3, seed=27609)

# Composite Model instantiation
model = gc.CompositeModel(G)

# Model statuses
model.add_status("Susceptible")
model.add_status("Infected")
model.add_status("Infected_2")
model.add_status("Infected_Both")
model.add_status("Removed")
# Compartment definition

contagion_1 = NodeStochastic(0.1, triggering_status="Infected")
contagion_2 = NodeStochastic(0.1, triggering_status="Infected_2")
contagion_both = NodeStochastic(0.1, triggering_status="Infected_Both")
contagion_interaction_1 = NodeStochastic(.2, triggering_status="Infected")
contagion_interaction_2 = NodeStochastic(1, triggering_status="Infected_2")
# Should be adjusted based on rate that KKT assumes in original paper.
recovered = NodeStochastic(1)


# Rule definition
Exemplo n.º 18
0
    def test_node_num_variable(self):

        g = nx.karate_club_graph()
        attr = {n: {"even": int(n % 10)} for n in g.nodes()}
        nx.set_node_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=0,
                                      op='==')
        model.add_rule("Susceptible", "Infected", c)

        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 = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=[3, 5],
                                      op='IN')
        model.add_rule("Susceptible", "Infected", c)

        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)

        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable(5,
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=0,
                                      op='==')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even', value=0, op='==')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=3,
                                      value=0,
                                      value_type=3,
                                      op='==')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable(None,
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=0,
                                      op='==')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=0)
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=0,
                                      op='IN')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=['a', 3],
                                      op='IN')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=[3, 'a'],
                                      op='IN')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=[5, 3],
                                      op='IN')
        with self.assertRaises(ValueError):
            cpm.NodeNumericalVariable('even',
                                      var_type=NumericalType.ATTRIBUTE,
                                      value=[5, 3],
                                      op='IN')