app.py

# -*- coding: utf-8 -*-
"""revolutions_exploration.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/1omNn2hrbDL_s1qwCOr7ViaIjrRW61YDt
"""

# !pip install gradio

# Commented out IPython magic to ensure Python compatibility.
# 
# %%capture
# import multiprocessing
# 
# multiprocessing.cpu_count()
# 
# !pip install cmocean
# !pip install git+https://github.com/MNoichl/mesa
# 
# !pip install compress-pickle --quiet

import random
import pandas as pd
from mesa import Agent, Model
from mesa.space import MultiGrid
import networkx as nx
from mesa.time import RandomActivation
from mesa.datacollection import DataCollector
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib as mpl

import cmocean

import tqdm

import scipy as sp

# from compress_pickle import dump, load

from scipy.stats import beta

# Commented out IPython magic to ensure Python compatibility.
# %%capture
# !pip install git+https://github.com/MNoichl/opinionated.git#egg=opinionated
import opinionated
import matplotlib.pyplot as plt

plt.style.use("opinionated_rc")
from opinionated.core import download_googlefont
download_googlefont('Quicksand', add_to_cache=True)
plt.rc('font', family='Quicksand')

experiences = {
            'dissident_experiences': [1,0,0],
            'supporter_experiences': [1,1,1],
        }

def apply_half_life_decay(data_list, half_life, decay_factors=None):
    steps = len(data_list)

    # Check if decay_factors are provided and are of the correct length
    if decay_factors is None or len(decay_factors) < steps:
        decay_factors = [0.5 ** (i / half_life) for i in range(steps)]
    decayed_list = [data_list[i] * decay_factors[steps - 1 - i] for i in range(steps)]


    return decayed_list



half_life=20
decay_factors = [0.5 ** (i / half_life) for i in range(200)]

def get_beta_mean_from_experience_dict(experiences, half_life=20,decay_factors=None): #note: precomputed decay supersedes halflife!
  eta = 1e-10
  return beta.mean(sum(apply_half_life_decay(experiences['dissident_experiences'], half_life,decay_factors))+eta,
                   sum(apply_half_life_decay(experiences['supporter_experiences'], half_life,decay_factors))+eta)


def get_beta_sample_from_experience_dict(experiences, half_life=20,decay_factors=None):
  eta = 1e-10

  # print(sum(apply_half_life_decay(experiences['dissident_experiences'], half_life)))
  # print(sum(apply_half_life_decay(experiences['supporter_experiences'], half_life)))
  return beta.rvs(sum(apply_half_life_decay(experiences['dissident_experiences'], half_life,decay_factors))+eta,
                   sum(apply_half_life_decay(experiences['supporter_experiences'], half_life,decay_factors))+eta, size=1)[0]


print(get_beta_mean_from_experience_dict(experiences,half_life,decay_factors))
print(get_beta_sample_from_experience_dict(experiences,half_life))

#@title Load network functionality

def generate_community_points(num_communities, total_nodes, powerlaw_exponent=2.0, sigma=0.05, plot=False):
    """
    This function generates points in 2D space, where points are grouped into communities.
    Each community is represented by a Gaussian distribution.

    Args:
        num_communities (int): Number of communities (gaussian distributions).
        total_nodes (int): Total number of points to be generated.
        powerlaw_exponent (float): The power law exponent for the powerlaw sequence.
        sigma (float): The standard deviation for the gaussian distributions.
        plot (bool): If True, the function plots the generated points.

    Returns:
        numpy.ndarray: An array of generated points.
    """

       # Sample from a powerlaw distribution
    sequence = nx.utils.powerlaw_sequence(num_communities, powerlaw_exponent)

    # Normalize sequence to represent probabilities
    probabilities = sequence / np.sum(sequence)

    # Assign nodes to communities based on probabilities
    community_assignments = np.random.choice(num_communities, size=total_nodes, p=probabilities)

    # Calculate community_sizes from community_assignments
    community_sizes = np.bincount(community_assignments)
    # Ensure community_sizes has length equal to num_communities
    if len(community_sizes) < num_communities:
        community_sizes = np.pad(community_sizes, (0, num_communities - len(community_sizes)), 'constant')

    points = []
    community_centers = []

    # For each community
    for i in range(num_communities):
        # Create a random center for this community
        center = np.random.rand(2)
        community_centers.append(center)

        # Sample from Gaussian distributions with the center and sigma
        community_points = np.random.normal(center, sigma, (community_sizes[i], 2))

        points.append(community_points)

    points = np.concatenate(points)

    # Optional plotting
    if plot:
        plt.figure(figsize=(8,8))
        plt.scatter(points[:, 0], points[:, 1], alpha=0.5)
        # for center in community_centers:
        sns.kdeplot(x=points[:, 0], y=points[:, 1], levels=5, color="k", linewidths=1)
        # plt.xlim(0, 1)
        # plt.ylim(0, 1)
        plt.show()

    return points


def graph_from_coordinates(coords, radius):
    """
    This function creates a random geometric graph from an array of coordinates.

    Args:
        coords (numpy.ndarray): An array of coordinates.
        radius (float): A radius of circles or spheres.

    Returns:
        networkx.Graph: The created graph.
    """

    # Create a KDTree for efficient query
    kdtree = sp.spatial.cKDTree(coords)
    edge_indexes = kdtree.query_pairs(radius)
    g = nx.Graph()
    g.add_nodes_from(list(range(len(coords))))
    g.add_edges_from(edge_indexes)

    return g


def plot_graph(graph, positions):
    """
    This function plots a graph with the given positions.

    Args:
        graph (networkx.Graph): The graph to be plotted.
        positions (dict): A dictionary of positions for the nodes.
    """

    plt.figure(figsize=(8,8))
    pos_dict = {i: positions[i] for i in range(len(positions))}
    nx.draw_networkx_nodes(graph, pos_dict, node_size=30, node_color="#1a2340", alpha=0.7)
    nx.draw_networkx_edges(graph, pos_dict, edge_color="grey", width=1, alpha=1)
    plt.show()



def ensure_neighbors(graph):
    """
    Ensure that all nodes in a NetworkX graph have at least one neighbor.

    Parameters:
    graph (networkx.Graph): The NetworkX graph to check.

    Returns:
    networkx.Graph: The updated NetworkX graph where all nodes have at least one neighbor.
    """
    nodes = list(graph.nodes())
    for node in nodes:
        if len(list(graph.neighbors(node))) == 0:
            # The node has no neighbors, so select another node to connect it with
            other_node = random.choice(nodes)
            while other_node == node:  # Make sure we don't connect the node to itself
                other_node = random.choice(nodes)
            graph.add_edge(node, other_node)
    return graph


def compute_homophily(G,attr_name='attr'):
    same_attribute_edges = sum(G.nodes[n1][attr_name] == G.nodes[n2][attr_name] for n1, n2 in G.edges())
    total_edges = G.number_of_edges()
    return same_attribute_edges / total_edges if total_edges > 0 else 0

def assign_initial_attributes(G, ratio,attr_name='attr'):
    nodes = list(G.nodes)
    random.shuffle(nodes)
    attr_boundary = int(ratio * len(nodes))
    for i, node in enumerate(nodes):
        G.nodes[node][attr_name] = 0 if i < attr_boundary else 1
    return G

def distribute_attributes(G, target_homophily, seed=None, max_iter=10000, cooling_factor=0.9995,attr_name='attr'):
    random.seed(seed)
    current_homophily = compute_homophily(G,attr_name)
    temp = 1.0

    for i in range(max_iter):
        # pick two random nodes with different attributes and swap their attributes
        nodes = list(G.nodes)
        random.shuffle(nodes)
        for node1, node2 in zip(nodes[::2], nodes[1::2]):
            if G.nodes[node1][attr_name] != G.nodes[node2][attr_name]:
                G.nodes[node1][attr_name], G.nodes[node2][attr_name] = G.nodes[node2][attr_name], G.nodes[node1][attr_name]
                break

        new_homophily = compute_homophily(G,attr_name)
        delta_homophily = new_homophily - current_homophily
        dir_factor = np.sign(target_homophily - current_homophily)

        # if the new homophily is closer to the target, or if the simulated annealing condition is met, accept the swap
        if abs(new_homophily - target_homophily) < abs(current_homophily - target_homophily) or \
           (delta_homophily / temp < 700 and random.random() < np.exp(dir_factor * delta_homophily / temp)):
            current_homophily = new_homophily
        else:  # else, undo the swap
            G.nodes[node1][attr_name], G.nodes[node2][attr_name] = G.nodes[node2][attr_name], G.nodes[node1][attr_name]

        temp *= cooling_factor  # cool down

    return G


def reindex_graph_to_match_attributes(G1, G2, attr_name):
    # Get a sorted list of nodes in G1 based on the attribute
    G1_sorted_nodes = sorted(G1.nodes(data=True), key=lambda x: x[1][attr_name])

    # Get a sorted list of nodes in G2 based on the attribute
    G2_sorted_nodes = sorted(G2.nodes(data=True), key=lambda x: x[1][attr_name])

    # Create a mapping from the G2 node IDs to the G1 node IDs
    mapping = {G2_node[0]: G1_node[0] for G2_node, G1_node in zip(G2_sorted_nodes, G1_sorted_nodes)}

    # Generate the new graph with the updated nodes
    G2_updated = nx.relabel_nodes(G2, mapping)

    return G2_updated

##########################

def compute_mean(model):
    agent_estimations = [agent.estimation for agent in model.schedule.agents]
    return np.mean(agent_estimations)

def compute_median(model):
    agent_estimations = [agent.estimation for agent in model.schedule.agents]
    return np.median(agent_estimations)

def compute_std(model):
    agent_estimations = [agent.estimation for agent in model.schedule.agents]
    return np.std(agent_estimations)




class PoliticalAgent(Agent):
    """An agent in the political model.

    Attributes:
        estimation (float): Agent's current expectation of political change.
        dissident (bool): True if the agent supports a regime change, False otherwise.
        networks_estimations (dict): A dictionary storing the estimations of the agent for each network.
    """

    def __init__(self, unique_id, model, dissident):
        super().__init__(unique_id, model)
        self.experiences = {
            'dissident_experiences': [1],
            'supporter_experiences': [1],
        }
        # self.estimation = estimation
        self.estimations = []
        self.estimation = .5 #hardcoded_mean, will change in first step if agent interacts.

        self.experiments = []


        self.dissident = dissident
        # self.historical_estimations = []

    def update_estimation(self, network_id):
        """Update the agent's estimation for a given network."""
        # Get the neighbors from the network
        potential_partners = [self.model.schedule.agents[n] for n in self.model.networks[network_id]['network'].neighbors(self.unique_id)]




        current_estimate =get_beta_mean_from_experience_dict(self.experiences,half_life=self.model.half_life,decay_factors=self.model.decay_factors)
        self.estimations.append(current_estimate)
        self.estimation =current_estimate
        current_experiment = get_beta_sample_from_experience_dict(self.experiences,half_life=self.model.half_life, decay_factors=self.model.decay_factors)
        self.experiments.append(current_experiment)

        if potential_partners:
            partner = random.choice(potential_partners)
            if self.model.networks[network_id]['type'] == 'physical':
              if current_experiment >= self.model.threshold:

                  if partner.dissident: # removed division by 100?
                    self.experiences['dissident_experiences'].append(1)
                    self.experiences['supporter_experiences'].append(0)
                  else:
                    self.experiences['dissident_experiences'].append(0)
                    self.experiences['supporter_experiences'].append(1)

                  partner.experiences['dissident_experiences'].append(1 * self.model.social_learning_factor)
                  partner.experiences['supporter_experiences'].append(0)

              else:
                  partner.experiences['dissident_experiences'].append(0)
                  partner.experiences['supporter_experiences'].append(1 * self.model.social_learning_factor)


            # else:
            #     pass
            # Only one network for the moment!
            elif self.model.networks[network_id]['type'] == 'social_media':
              if partner.dissident: # removed division by 100?
                self.experiences['dissident_experiences'].append(1 * self.model.social_media_factor)
                self.experiences['supporter_experiences'].append(0)
              else:
                self.experiences['dissident_experiences'].append(0)
                self.experiences['supporter_experiences'].append(1 * self.model.social_media_factor)

                # self.networks_estimations[network_id] = self.estimation

    def combine_estimations(self):
        # """Combine the estimations from all networks using a bounded confidence model."""
        values = [list(d.values())[0] for d in self.current_estimations]

        if len(values) > 0:
            # Filter the network estimations based on the bounded confidence range
            within_range = [value for value in values if abs(self.estimation - value) <= self.model.bounded_confidence_range]

            # If there are any estimations within the range, update the estimation
            if len(within_range) > 0:
                self.estimation = np.mean(within_range)




    def step(self):
        """Agent step function which updates the estimation for each network and then combines the estimations."""
        if not hasattr(self, 'current_estimations'): # agents might already have this attribute because they were partnered up in the past.
            self.current_estimations = []

        for network_id in self.model.networks.keys():
            self.update_estimation(network_id)

        self.combine_estimations()
        # self.historical_estimations.append(self.current_estimations)
        del self.current_estimations


class PoliticalModel(Model):
    """A model of a political system with multiple interacting agents.

    Attributes:
        networks (dict): A dictionary of networks with network IDs as keys and NetworkX Graph objects as values.
    """

    def __init__(self, n_agents, networks, share_regime_supporters,
                #  initial_expectation_of_change,
                 threshold,
                 social_learning_factor=1,social_media_factor=1, # one for equal learning, lower gets discounted
                 half_life=20, print_agents=False, print_frequency=30,
                 early_stopping_steps=20, early_stopping_range=0.01, agent_reporters=True,intervention_list=[],randomID=False):
        self.num_agents = n_agents
        self.threshold = threshold
        self.social_learning_factor = social_learning_factor
        self.social_media_factor = social_media_factor
        self.print_agents_state = print_agents
        self.half_life = half_life
        self.intervention_list = intervention_list
        self.model_id = randomID

        self.print_frequency = print_frequency
        self.early_stopping_steps = early_stopping_steps
        self.early_stopping_range = early_stopping_range


        self.mean_estimations = []
        self.decay_factors = [0.5 ** (i / self.half_life) for i in range(500)] # Nte this should be larger than

        # we could use this for early stopping!
        self.running = True
        self.share_regime_supporters = share_regime_supporters
        self.schedule = RandomActivation(self)
        self.networks = networks

        # Assign dissident as argument to networks, compute homophilies, and match up the networks so that the same id leads to the same atrribute
        for i, this_network in enumerate(self.networks):
          self.networks[this_network]["network"] = assign_initial_attributes(self.networks[this_network]["network"],self.share_regime_supporters,attr_name='dissident')
          if 'homophily' in self.networks[this_network]:
            self.networks[this_network]["network"] = distribute_attributes(self.networks[this_network]["network"],
                                                                           self.networks[this_network]['homophily'], max_iter=5000, cooling_factor=0.995,attr_name='dissident')
            self.networks[this_network]['network_data_to_keep']['actual_homophily'] = compute_homophily(self.networks[this_network]["network"],attr_name='dissident')
          if i>0:
            self.networks[this_network]["network"] = reindex_graph_to_match_attributes(self.networks[next(iter(self.networks))]["network"], self.networks[this_network]["network"], 'dissident')

        # print(self.networks)

        for i in range(self.num_agents):
            # estimation = random.normalvariate(initial_expectation_of_change, 0.2) We set a flat prior now

            agent = PoliticalAgent(i, self, self.networks[next(iter(self.networks))]["network"].nodes(data=True)[i]['dissident'])
            self.schedule.add(agent)
        # Should we update to  the real share here?!
####################

        # Keep the attributes in the model and define model reporters
        model_reporters = {
            "Mean": compute_mean,
            "Median": compute_median,
            "STD": compute_std
        }

        for this_network in self.networks:
            if 'network_data_to_keep' in self.networks[this_network]:
                for key, value in self.networks[this_network]['network_data_to_keep'].items():
                    attr_name = this_network + '_' + key
                    setattr(self, attr_name, value)

                    # Define a reporter function for this attribute
                    def reporter(model, attr_name=attr_name):
                        return getattr(model, attr_name)

                    # Add the reporter function to the dictionary
                    model_reporters[attr_name] = reporter

        # Initialize DataCollector with the dynamic model reporters
        if agent_reporters:
            self.datacollector = DataCollector(
                model_reporters=model_reporters,
                agent_reporters={"Estimation": "estimation", "Dissident": "dissident"}#, "Historical Estimations": "historical_estimations"}
            )
        else:
            self.datacollector = DataCollector(
                model_reporters=model_reporters
            )





    def step(self):
        """Model step function which activates the step function of each agent."""

        self.datacollector.collect(self)  # Collect data

        # do interventions, if present:
        for this_intervention in self.intervention_list:
          # print(this_intervention)
          if this_intervention['time'] == len(self.mean_estimations):

            if this_intervention['type'] == 'threshold_adjustment':
              self.threshold = max(0, min(1, self.threshold + this_intervention['strength']))

            if this_intervention['type'] == 'share_adjustment':
                target_supporter_share = max(0, min(1, self.share_regime_supporters + this_intervention['strength']))
                agents = [self.schedule._agents[i] for i in self.schedule._agents]
                current_supporters = sum(not agent.dissident for agent in agents)
                total_agents = len(agents)
                current_share = current_supporters / total_agents

                # Calculate the number of agents to change
                required_supporters = int(target_supporter_share * total_agents)
                agents_to_change = abs(required_supporters - current_supporters)

                if current_share < target_supporter_share:
                    # Not enough supporters, need to increase
                    dissidents = [agent for agent in agents if agent.dissident]
                    for agent in random.sample(dissidents, agents_to_change):
                        agent.dissident = False
                elif current_share > target_supporter_share:
                    # Too many supporters, need to reduce
                    supporters = [agent for agent in agents if not agent.dissident]
                    for agent in random.sample(supporters, agents_to_change):
                        agent.dissident = True
        # print(self.threshold)
            if this_intervention['type'] == 'social_media_adjustment':
              self.social_media_factor = max(0, min(1, self.social_media_factor + this_intervention['strength']))


        self.schedule.step()
        current_mean_estimation = compute_mean(self)
        self.mean_estimations.append(current_mean_estimation)

        # Implement the early stopping criteria
        if len(self.mean_estimations) >= self.early_stopping_steps:
            recent_means = self.mean_estimations[-self.early_stopping_steps:]
            if max(recent_means) - min(recent_means) < self.early_stopping_range:
                # if self.print_agents_state:
                  # print('Early stopping at: ', self.schedule.steps)
                  # self.print_agents()
              self.running = False

        # if self.print_agents_state and (self.schedule.steps % self.print_frequency == 0 or self.schedule.steps == 1):
        #     print(self.schedule.steps)
        #     self.print_agents()






def run_simulation(n_agents=300, share_regime_supporters=0.4, threshold=0.5, social_learning_factor=1, simulation_steps=400, half_life=20):
    # Helper functions like graph_from_coordinates, ensure_neighbors should be defined outside this function

    # Complete graph
    G = nx.complete_graph(n_agents)

    # Networks dictionary
    networks = {
        "physical": {"network": G, "type": "physical", "positions": nx.circular_layout(G)}#kamada_kawai
    }

    # Intervention list
    intervention_list = [    ]

    # Initialize the model
    model = PoliticalModel(n_agents, networks, share_regime_supporters, threshold,
                           social_learning_factor, half_life=half_life, print_agents=False, print_frequency=50, agent_reporters=True, intervention_list=intervention_list)

    # Run the model
    for _ in tqdm.tqdm_notebook(range(simulation_steps)):  # Run for specified number of steps
        model.step()
    return model

# Example usage

def run_and_plot_simulation(n_agents=300, share_regime_supporters=0.4, threshold=0.5, social_learning_factor=1, simulation_steps=40, half_life=20):
    model =run_simulation(n_agents=n_agents, share_regime_supporters=share_regime_supporters, threshold=threshold, social_learning_factor=social_learning_factor, simulation_steps=simulation_steps, half_life=half_life)
    # Get data and reset index
    agent_df = model.datacollector.get_agent_vars_dataframe().reset_index()

    # Pivot the dataframe
    agent_df_pivot = agent_df.pivot(index='Step', columns='AgentID', values='Estimation')

    # Create the plot
    fig, ax = plt.subplots(figsize=(12, 8))
    for column in agent_df_pivot.columns:
        plt.plot(agent_df_pivot.index, agent_df_pivot[column], color='gray', alpha=0.1)

    # Compute and plot the mean estimation
    mean_estimation = agent_df_pivot.mean(axis=1)
    plt.plot(mean_estimation.index, mean_estimation, color='black', linewidth=2)

    # Set the plot title and labels
    plt.title('Agent Estimation Over Time')
    plt.xlabel('Time step')
    plt.ylabel('Estimation')
    return fig


# run_and_plot_simulation(n_agents=300, share_regime_supporters=0.4, threshold=0.5, social_learning_factor=1, simulation_steps=40, half_life=20)

import gradio as gr
import matplotlib.pyplot as plt


# Gradio interface
with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
  with gr.Column():
    gr.Markdown("# Simulation Visualization Interface")
    with gr.Row():
      with gr.Column():


          # Sliders for each parameter
          n_agents_slider = gr.Slider(minimum=100, maximum=500, step=10, label="Number of Agents", value=150)
          share_regime_slider = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Share of Regime Supporters", value=0.4)
          threshold_slider = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Threshold", value=0.5)
          social_learning_slider = gr.Slider(minimum=0.0, maximum=2.0, step=0.1, label="Social Learning Factor", value=1.0)
          steps_slider = gr.Slider(minimum=10, maximum=100, step=5, label="Simulation Steps", value=40)
          half_life_slider = gr.Slider(minimum=5, maximum=50, step=5, label="Half-Life", value=20)

      with gr.Column():
          # Button to trigger the simulation
          button = gr.Button("Run Simulation")
          plot_output = gr.Plot(label="Simulation Result")

    # Function to call when button is clicked
    def run_simulation_and_plot(*args):
        fig = run_and_plot_simulation(*args)
        return fig

    # Setting up the button click event
    button.click(
        run_simulation_and_plot,
        inputs=[n_agents_slider, share_regime_slider, threshold_slider, social_learning_slider, steps_slider, half_life_slider],
        outputs=[plot_output]
    )

# Launch the interface
if __name__ == "__main__":
    demo.launch(debug=True)