Esempio n. 1
0
def behavior_comparison():
    networks = (
        ('Caveman-50-10', fio.read_network('networks/cavemen-50-10.txt')),
        ('Elitist-500', fio.read_network('networks/elitist-500.txt')),
        ('CGG-500', fio.read_network('networks/cgg-500.txt'))
    )

    num_sims = 50
    num_behaviors = 3
    distributions = []
    averages = np.zeros((len(networks), num_behaviors))
    loop = tqdm(total=len(networks) * num_behaviors * num_sims)
    for i, (n_name, net) in enumerate(networks):

        behaviors = (
            ('No Mitigations',
             behavior.NoMitigation()),
            ('Generic Pressure R=1',
             behavior.SimplePressureBehavior(net, rng=RNG, radius=1)),
            ('Edge Pressure R=1',
             behavior.SimpleEdgePressureBehavior(net, rng=RNG, radius=1))
            # ('All Edges Sequential Flicker 1/4',
            #  StaticFlickerBehavior(net.M, net.edges, (True, False, False, False))),
            # ('All Edges Random Flicker 0.25',
            #  RandomFlickerBehavior(net.M, net.edges, 0.25)),
            # ('Collected Pressure Flicker 0.25, R=1',
            #  UnifiedPressureFlickerBehavior(net, 1, RNG)),
            # ('Generic Pressure Radius 3',
            #  SimplePressureBehavior(net, 3)),
            # ('Pressure Decay Radius 3',
            #  PressureDecayBehavior(net, 3)),
            # ('Pressure Flicker Radius 3',
            #  PressureFlickerBehavior(net, 3))
        )

        for j, (b_name, behavior) in enumerate(behaviors):
            s_scores = []
            for _ in range(num_sims):
                loop.set_description(f'{n_name}, {b_name}')
                end_sir = simulate(net.M, sir0=make_starting_sir(net.N, 1, rng=RNG),
                                   disease=Disease(4, 0.3),
                                   update_connections=behavior,
                                   max_steps=200,
                                   rng=RNG)[-1]
                s_scores.append(np.sum(end_sir[0, :] > 0)/net.N)
                loop.update()
            # plt.title(f'{n_name}, {b_name}, Avg: {sum(s_scores)/len(s_scores)}')
            # plt.hist(s_scores)
            # plt.figure()
            averages[i, j] = sum(s_scores)/len(s_scores)
            distributions.append(s_scores)
    print(wasserstein_distance(distributions[1], distributions[2]))
    print(wasserstein_distance(distributions[4], distributions[5]))
    print(wasserstein_distance(distributions[7], distributions[8]))
    # plt.show()
    np.set_printoptions(precision=3, suppress=True)
    print(averages)
Esempio n. 2
0
def show_edit_distance():
    if len(sys.argv) < 3:
        print(f'Usage: {sys.argv[0]} <network 0> <network 1>')
        return

    start_time = time.time()
    net0 = fio.read_network(sys.argv[1])
    net1 = fio.read_network(sys.argv[2])
    distance = nx.graph_edit_distance(net0.G, net1.G)
    name0 = fio.get_network_name(sys.argv[1])
    name1 = fio.get_network_name(sys.argv[2])
    print(
        f'Distance between {name0} and {name1}: {distance} ({time.time()-start_time} s)'
    )
Esempio n. 3
0
def pressure_decay_test():
    G, layout, communities = fio.read_network('networks/elitist-500.txt')
    if layout is None or communities is None:
        raise Exception('File is incomplete.')
    net = Network(G, communities=communities)
    simulate(net.M, make_starting_sir(net.N, 1, RNG), Disease(4, 0.3),
             behavior.PressureDecayBehavior(net, 3), 200, layout, RNG)
Esempio n. 4
0
def generic_pressure_test():
    G, layout, communities = fio.read_network('networks/cavemen-10-10.txt')
    if layout is None or communities is None:
        raise Exception('File is incomplete.')
    net = Network(G, communities=communities)
    simulate(net.M, make_starting_sir(net.N, 1, RNG), Disease(4, 0.3),
             behavior.SimplePressureBehavior(net, 1), 200, layout, RNG)
Esempio n. 5
0
def multi_behavior_test(display=True):
    """
    A basic test to visualize the multi-behavior.
    """
    net = fio.read_network('networks/elitist-500.txt')
    ph1 = behavior.BetweenDistancePressureHandler(net.dm, 0, 1)
    ph2 = behavior.BetweenDistancePressureHandler(net.dm, 1, 2)
    ph3 = behavior.BetweenDistancePressureHandler(net.dm, 2, 3)
    ph4 = behavior.BetweenDistancePressureHandler(net.dm, 10, 40)

    behaviors = [
        behavior.FlickerPressureBehavior(RNG, ph1, .1),
        behavior.FlickerPressureBehavior(RNG, ph2, .2),
        behavior.FlickerPressureBehavior(RNG, ph3, .8),
        behavior.FlickerPressureBehavior(RNG, ph4, 1)
    ]
    update_behavior = behavior.MultiPressureBehavior(RNG, behaviors)
    if display:
        return simulate(M=net.M, sir0=make_starting_sir(net.N, 1, RNG),
                        disease=Disease(4, .3),
                        update_connections=update_behavior,
                        max_steps=200, rng=RNG, layout=net.layout)
    else:
        return simulate(M=net.M, sir0=make_starting_sir(net.N, 1, RNG),
                        disease=Disease(4, .3),
                        update_connections=update_behavior,
                        max_steps=200, rng=RNG, layout=None)
Esempio n. 6
0
def analyze_network_entry_point():
    """Analyze the network given by the command line argument."""
    if len(sys.argv) < 2:
        print(f'Usage: {sys.argv[0]} <network>')
        return

    net = fio.read_network(sys.argv[1])
    G = nx.Graph(net.G)
    name = fio.get_network_name(sys.argv[1])
    analyze_network(G, name)
    visualize_network(G,
                      net.layout,
                      name,
                      edge_width_func=all_same,
                      block=False)
    intercommunity_edges = tuple(
        (u, v) for u, v in G.edges if net.communities[u] != net.communities[v])
    G.remove_edges_from(intercommunity_edges)
    visualize_network(G,
                      net.layout,
                      'Partitioned ' + name,
                      edge_width_func=all_same,
                      block=False)
    meta_G, meta_ns, meta_ew = make_meta_community_network(
        intercommunity_edges, G)
    meta_layout = make_meta_community_layout(meta_G, net.layout)
    visualize_network(meta_G,
                      meta_layout,
                      f'{name} Meta Communities',
                      edge_width_func=lambda G: meta_ew,
                      node_size=meta_ns,
                      block=False)
    input('Press <enter> to exit.')
Esempio n. 7
0
def main():
    networks = ('cavemen-50-10', 'elitist-500', 'agent-generated-500',
                'annealed-agent-generated-500', 'barabasi-albert-500-3',
                'cgg-500', 'connected-comm-50-10', 'spatial-network',
                'watts-strogatz-500-4-.1')
    network_paths = fio.network_names_to_paths(networks)
    for name, path in zip(networks, network_paths):
        net = fio.read_network(path)
        print(f'{name:<30} {rate_social_good(net, DecayFunction(.5)):>10.3f}')
Esempio n. 8
0
def show_social_good():
    if len(sys.argv) < 2:
        print(f'Usage {sys.argv[1]} <network>')
        return

    net = fio.read_network(sys.argv[1])
    for k in np.linspace(.5, 1.5, 5):
        sg_score = socialgood.rate_social_good(net,
                                               socialgood.DecayFunction(k))
        print(f'{k:<6.3f}: {sg_score}')
Esempio n. 9
0
def save_social_good_csv(networks: Sequence[str],
                         network_paths: Sequence[str]):
    decay_functions = (DecayFunction(.5), DecayFunction(1), DecayFunction(2))

    with open('social-good.csv', 'w') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow([DecayFunction.function_desc] +
                        [str(df.k) for df in decay_functions])

        for name, path in tqdm(tuple(zip(networks, network_paths))):
            scores = []
            for decay_func in decay_functions:
                net = fio.read_network(path)
                social_good_score = rate_social_good(net, decay_func)
                scores.append(f'{social_good_score:.3f}')
            writer.writerow([name] + scores)
Esempio n. 10
0
def visualize_communicability():
    if len(sys.argv) < 2:
        print(f'Usage {sys.argv[1]} <network>')
        return

    net = fio.read_network(sys.argv[1])
    name = fio.get_network_name(sys.argv[1])
    communicability = nx.communicability_exp(net.G)
    scores = np.array(
        [sum(communicability[u].values()) for u in communicability.keys()])
    plt.title(f'{name}\nCommunicability')
    plt.hist(scores)  # type: ignore
    plt.show(block=False)
    print(f'Network score: {np.sum(scores)}')
    scores = (scores - np.min(scores)) / (np.max(scores) - np.min(scores))
    node_size = 300 * scores
    visualize_network(net.G, net.layout, name, node_size=node_size)
Esempio n. 11
0
def visualize_social_good(networks: Sequence[str],
                          network_paths: Sequence[str]):
    for name, path in zip(networks, network_paths):
        net = fio.read_network(path)
        node_size = node_size_from_social_good(net.G, DecayFunction(1))
        plt.title(f'{name} Node Size')
        plt.hist(node_size, bins=None)
        plt.figure()
        print(
            f'{name} min = {np.min(node_size):.2f} max = {np.max(node_size):.2f}'
        )
        visualize_network(net.G,
                          net.layout,
                          name,
                          node_size=node_size,
                          block=False)

    input('Done.')
Esempio n. 12
0
def pressure_flicker_test(pressure_distance, display=True):
    """
    A basic test to use for visualizing simulations
    """
    net = fio.read_network('networks/elitist-500.txt')
    pressure_handler = behavior.DistancePressureHandler(net.dm, pressure_distance)
    # pressure_handler = behavior.AllPressureHandler()
    update_behavior = behavior.FlickerPressureBehavior(RNG, pressure_handler, 0.25)
    if display:
        return simulate(M=net.M, sir0=make_starting_sir(net.N, 1, RNG),
                        disease=Disease(4, 0.3),
                        update_connections=update_behavior,
                        max_steps=200, rng=RNG, layout=net.layout)
    else:
        return simulate(M=net.M, sir0=make_starting_sir(net.N, 1, RNG),
                        disease=Disease(4, 0.3),
                        update_connections=update_behavior,
                        max_steps=200, rng=RNG, layout=None)
Esempio n. 13
0
def multi_pressure_handler_test(display=True):
    """
    A basic test for the MultiPressureHandler.
    """
    net = fio.read_network('networks/elitist-500.txt')
    ph1 = behavior.BetweenDistancePressureHandler(net.dm, 2, 3)
    ph2 = behavior.BetweenDistancePressureHandler(net.dm, 10, 40)
    ph = behavior.MultiPressureHandler((ph1, ph2))
    update_behavior = behavior.FlickerPressureBehavior(RNG, ph, 1)
    if display:
        return simulate(M=net.M, sir0=make_starting_sir(net.N, 1, RNG),
                        disease=Disease(4, .3),
                        update_connections=update_behavior,
                        max_steps=200, rng=RNG, layout=net.layout)
    else:
        return simulate(M=net.M, sir0=make_starting_sir(net.N, 1, RNG),
                        disease=Disease(4, .3),
                        update_connections=update_behavior,
                        max_steps=200, rng=RNG, layout=None)
def elitist_experiment():
    rng = np.random.default_rng()
    path = 'networks/elitist-500.txt'
    name = fio.get_network_name(path)
    net = fio.read_network(path)
    r, fp = 2, .75
    update_connections, uc_name = (sd.SimplePressureBehavior(net, rng, r, fp),
                                   f'Pressure(r={r}, fp={fp})')
    # update_connections, uc_name = sd.no_update, 'Static'
    disease = sd.Disease(4, .2)
    sir0 = sd.make_starting_sir(net.N, (0, ), rng)
    survival_rates = np.array([
        simulate_return_survival_rate(net, disease, update_connections, rng,
                                      sir0) for _ in range(500)
    ])
    title = f'{disease} {uc_name}\n{name} Survival Rates'
    plt.title(title)
    plt.boxplot(survival_rates)
    plt.savefig(title + '.png', format='png')
Esempio n. 15
0
def main():
    if len(sys.argv) < 3:
        print(f'Usage {sys.argv[0]} <network> <num communities>')
        return

    M, layout = old_read_network_file(sys.argv[1])
    if layout is None:
        print('layout is None. Exiting.')
        return

    G = nx.Graph(M)
    # interedges = label_partition(G, int(sys.argv[2]))
    interedges = girvan_newman_partition(G, int(sys.argv[2]))
    communities = intercommunity_edges_to_communities(G, interedges)

    new_name = get_network_name(sys.argv[1]) + '-new-format'
    write_network(G, new_name, layout, communities)

    net = read_network(new_name + '.txt')

    interedges = tuple(
        set((u, v) for u, v in net.edges if communities[u] != communities[v]))
    partitioned = nx.Graph(net.G)
    partitioned.remove_edges_from(interedges)
    meta_network, meta_ns, meta_ew = make_meta_community_network(
        interedges, partitioned)
    meta_layout = make_meta_community_layout(meta_network, layout)

    print(f'There are {len(meta_network)} communities.')
    node_color = [COLORS[i] for i in communities.values()]
    visualize_network(G, layout, new_name, node_color=node_color,
                      block=False)  # type: ignore
    plt.figure()
    plt.hist([len(comp) for comp in nx.connected_components(partitioned)],
             bins=None)
    plt.figure()
    visualize_network(meta_network,
                      meta_layout,
                      new_name + ' meta community',
                      node_size=meta_ns,
                      edge_width_func=lambda G: meta_ew)
Esempio n. 16
0
def run_experiments(args: Tuple[str, int, int, Disease, Sequence[FlickerConfig], str])\
        -> Optional[FlickerComparisonResult]:
    """
    Run a batch of experiments and return a tuple containing the network's name,
    number of flickering edges, and a mapping of behavior name to the final
    amount of susceptible nodes. Return None on failure.

    args: (path to the network,
           number of sims to run for each behavior,
           simulation length,
           disease,
           a sequence of configs for the flickers to use,
           the name of the baseline flicker to compare the other results to)
    """
    network_path, num_sims, sim_len, disease, flicker_configs, baseline_flicker_name = args
    net = fio.read_network(network_path)
    intercommunity_edges = {(u, v)
                            for u, v in net.edges
                            if net.communities[u] != net.communities[v]}

    behavior_to_results: Dict[str, Sequence[float]] = {}
    for config in flicker_configs:
        behavior = config.make_behavior(net.M, intercommunity_edges)
        # The tuple comprehension is pretty arcane, so here is an explanation.
        # Each entry is the sum of the number of entries in the final SIR where
        # the days in S are greater than 0. That is to say, the number of
        # susceptible agents at the end of the simulation.
        perc_sus = tuple(
            np.sum(
                simulate(net.M, make_starting_sir(net.N, 1), disease, behavior,
                         sim_len, None)[-1][0] > 0) / net.N
            for _ in range(num_sims))
        behavior_to_results[behavior.name] = perc_sus

    return FlickerComparisonResult(fio.get_network_name(network_path),
                                   num_sims, sim_len,
                                   len(intercommunity_edges) / net.E,
                                   behavior_to_results, baseline_flicker_name)
Esempio n. 17
0
def main():
    n_trials = 100
    max_steps = 100
    rng = np.random.default_rng(0)
    disease = Disease(4, .2)
    names = ('elitist-500', 'cavemen-50-10', 'spatial-network', 'cgg-500',
             'watts-strogatz-500-4-.1')
    paths = fio.network_names_to_paths(names)
    behavior_configs = (RandomFlickerConfig(.5, 'Random .5', rng),
                        StaticFlickerConfig((True, False), 'Static .5'))

    for net_name, path in zip(names, paths):
        net = fio.read_network(path)
        to_flicker = tuple((u, v) for u, v in net.edges
                           if net.communities[u] != net.communities[v])
        proportion_flickering = len(to_flicker) / net.E
        social_good = rate_social_good(net)
        trial_to_pf = tuple(proportion_flickering for _ in range(n_trials))
        trial_to_sg = tuple(social_good for _ in range(n_trials))
        print(f'Running simulations for {net_name}.')
        for config in behavior_configs:
            behavior = config.make_behavior(net.M, to_flicker)
            sim_results = [
                get_final_stats(
                    simulate(net.M,
                             make_starting_sir(net.N, 1, rng),
                             disease,
                             behavior,
                             max_steps,
                             None,
                             rng=rng)) for _ in tqdm(range(n_trials))
            ]
            results = BasicExperimentResult(f'{net_name} {config.name}',
                                            sim_results, trial_to_pf,
                                            trial_to_sg)
            results.save_csv(RESULTS_DIR)
            results.save_box_plots(RESULTS_DIR)
            results.save_perc_sus_vs_social_good(RESULTS_DIR)
Esempio n. 18
0
def agent_based_entry_point():
    if len(sys.argv) < 2:
        print(f'Usage: {sys.argv[0]} <network or number of agents>')
        return

    N = int_or_none(sys.argv[1])
    if N is None:
        net = read_network(sys.argv[1])
        N = net.N
    else:
        net = Network(nx.empty_graph(N))

    rand = np.random.default_rng()
    for i in range(50):
        start_time = time.time()
        H = make_agent_generated_network(nx.Graph(net.G),
                                         TimeBasedBehavior(N, 4, 6, 15, rand))
        if H is None:
            print(
                f'Failure on iteration {i} ({time.time()-start_time:.2f} s).')
        else:
            print(
                f'Success on iteration {i} ({time.time()-start_time:.2f} s).')
Esempio n. 19
0
def pressure_test_entry_point():
    rng = np.random.default_rng()
    net = fio.read_network('networks/cavemen-50-10.txt')
    simulate(net.M, make_starting_sir(net.N, (0, ), rng), Disease(4, 0.3),
             SimplePressureBehavior(net, 1), 200, None, rng)
Esempio n. 20
0
 def __call__(self) -> Network:
     if self._net is None:
         path = fio.network_names_to_paths((self._name, ))[0]
         self._net = fio.read_network(path)
     return self._net