Update app.py

app.py

@@ -5,23 +5,9 @@ Original file is located at
     https://colab.research.google.com/drive/1omNn2hrbDL_s1qwCOr7ViaIjrRW61YDt
 """
 
-# Commented out IPython magic to ensure Python compatibility.
-# %%capture
-# !pip install gradio
-# # !pip install gradio==3.50.2
-
-# Commented out IPython magic to ensure Python compatibility.
-# %%capture
-#
-# !pip install cmocean
-# !pip install mesa
-#
-# !pip install opinionated
-
 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
@@ -29,99 +15,61 @@ 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
-
-# # %%capture
-# !pip install git+https://github.com/MNoichl/opinionated.git#egg=opinionated
-# # import opinionated
-
 import opinionated
-import matplotlib.pyplot as plt
+import PIL
 
 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],
-}
 
+# -----------------------------
+# Decayed Beta helpers
+# -----------------------------
 def apply_half_life_decay(data_list, half_life, decay_factors=None):
     steps = len(data_list)
     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)]
+    return [data_list[i] * decay_factors[steps - 1 - i] for i in range(steps)]
 
 def get_beta_mean_from_experience_dict(experiences, half_life=20, decay_factors=None):
     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
-    )
+    a = sum(apply_half_life_decay(experiences['dissident_experiences'], half_life, decay_factors)) + eta
+    b = sum(apply_half_life_decay(experiences['supporter_experiences'], half_life, decay_factors)) + eta
+    return beta.mean(a, b)
 
 def get_beta_sample_from_experience_dict(experiences, half_life=20, decay_factors=None):
     eta = 1e-10
-    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
+    a = sum(apply_half_life_decay(experiences['dissident_experiences'], half_life, decay_factors)) + eta
+    b = sum(apply_half_life_decay(experiences['supporter_experiences'], half_life, decay_factors)) + eta
+    return beta.rvs(a, b, size=1)[0]
 
+# -----------------------------
+# Network helpers
+# -----------------------------
 def generate_community_points(num_communities, total_nodes, powerlaw_exponent=2.0, sigma=0.05, plot=False):
-    """
-    Generate 2D points grouped into communities (Gaussian around random centers).
-    """
     sequence = nx.utils.powerlaw_sequence(num_communities, powerlaw_exponent)
     probabilities = sequence / np.sum(sequence)
-
     community_assignments = np.random.choice(num_communities, size=total_nodes, p=probabilities)
     community_sizes = np.bincount(community_assignments)
     if len(community_sizes) < num_communities:
         community_sizes = np.pad(community_sizes, (0, num_communities - len(community_sizes)), 'constant')
-
-    points = []
-    community_centers = []
-
+    points, community_centers = [], []
     for i in range(num_communities):
         center = np.random.rand(2)
         community_centers.append(center)
         community_points = np.random.normal(center, sigma, (community_sizes[i], 2))
         points.append(community_points)
-
     points = np.concatenate(points)
-
     if plot:
         plt.figure(figsize=(8, 8))
         plt.scatter(points[:, 0], points[:, 1], alpha=0.5)
         sns.kdeplot(x=points[:, 0], y=points[:, 1], levels=5, color="k", linewidths=1)
         plt.show()
-
     return points
 
 def graph_from_coordinates(coords, radius):
-    """
-    Create a random geometric graph from an array of coordinates.
-    """
     kdtree = sp.spatial.cKDTree(coords)
     edge_indexes = kdtree.query_pairs(radius)
     g = nx.Graph()
@@ -129,96 +77,85 @@ def graph_from_coordinates(coords, radius):
     g.add_edges_from(edge_indexes)
     return g
 
-def plot_graph(graph, positions):
-    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 have at least one neighbor.
-    """
     nodes = list(graph.nodes())
     for node in nodes:
-        if len(list(graph.neighbors(node))) == 0:
-            other_node = random.choice(nodes)
-            while other_node == node:
-                other_node = random.choice(nodes)
-            graph.add_edge(node, other_node)
+        if graph.degree(node) == 0:
+            other = random.choice(nodes)
+            while other == node:
+                other = random.choice(nodes)
+            graph.add_edge(node, other)
     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
+    same = sum(G.nodes[n1][attr_name] == G.nodes[n2][attr_name] for n1, n2 in G.edges())
+    m = G.number_of_edges()
+    return same / m if m > 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))
+    k = int(ratio * len(nodes))
     for i, node in enumerate(nodes):
-        G.nodes[node][attr_name] = 0 if i < attr_boundary else 1
+        G.nodes[node][attr_name] = 0 if i < k 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)
+    current = compute_homophily(G, attr_name)
     temp = 1.0
-
-    for i in range(max_iter):
+    for _ in range(max_iter):
         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]
+        for n1, n2 in zip(nodes[::2], nodes[1::2]):
+            if G.nodes[n1][attr_name] != G.nodes[n2][attr_name]:
+                G.nodes[n1][attr_name], G.nodes[n2][attr_name] = G.nodes[n2][attr_name], G.nodes[n1][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 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
+        new = compute_homophily(G, attr_name)
+        delta = new - current
+        dir_factor = np.sign(target_homophily - current)
+        if abs(new - target_homophily) < abs(current - target_homophily) or \
+           (delta / temp < 700 and random.random() < np.exp(dir_factor * delta / temp)):
+            current = new
         else:
-            G.nodes[node1][attr_name], G.nodes[node2][attr_name] = G.nodes[node2][attr_name], G.nodes[node1][attr_name]
-
+            G.nodes[n1][attr_name], G.nodes[n2][attr_name] = G.nodes[n2][attr_name], G.nodes[n1][attr_name]
         temp *= cooling_factor
-
     return G
 
 def reindex_graph_to_match_attributes(G1, G2, attr_name):
-    G1_sorted_nodes = sorted(G1.nodes(data=True), key=lambda x: x[1][attr_name])
-    G2_sorted_nodes = sorted(G2.nodes(data=True), key=lambda x: x[1][attr_name])
-    mapping = {G2_node[0]: G1_node[0] for G2_node, G1_node in zip(G2_sorted_nodes, G1_sorted_nodes)}
-    G2_updated = nx.relabel_nodes(G2, mapping)
-    return G2_updated
-
-##########################
-
+    g1_sorted = sorted(G1.nodes(data=True), key=lambda x: x[1][attr_name])
+    g2_sorted = sorted(G2.nodes(data=True), key=lambda x: x[1][attr_name])
+    mapping = {g2[0]: g1[0] for g2, g1 in zip(g2_sorted, g1_sorted)}
+    return nx.relabel_nodes(G2, mapping)
+
+# -----------------------------
+# Reporters
+# -----------------------------
 def compute_mean(model):
-    agent_estimations = [agent.estimation for agent in model.schedule.agents]
-    return np.mean(agent_estimations)
+    return np.mean([a.estimation for a in model.schedule.agents])
 
 def compute_median(model):
-    agent_estimations = [agent.estimation for agent in model.schedule.agents]
-    return np.median(agent_estimations)
+    return np.median([a.estimation for a in model.schedule.agents])
 
 def compute_std(model):
-    agent_estimations = [agent.estimation for agent in model.schedule.agents]
-    return np.std(agent_estimations)
+    return np.std([a.estimation for a in model.schedule.agents])
 
+# -----------------------------
+# Agent and Model
+# -----------------------------
 class PoliticalAgent(Agent):
-    """An agent in the political model.
-    Attributes:
-        estimation (float): current expectation of political change
-        dissident (bool): True if supports regime change
-    """
-
     def __init__(self, unique_id, model, dissident):
-        super().__init__(unique_id, model)
+        # Mesa versions differ here. Try the new signature, then fall back.
+        try:
+            super().__init__(unique_id, model)
+        except TypeError:
+            super().__init__()      # object.__init__ without args
+            self.unique_id = unique_id
+            self.model = model
+            # provide .random like classic Mesa Agent did
+            if hasattr(model, "random"):
+                self.random = model.random
+
         self.experiences = {
             'dissident_experiences': [1],
             'supporter_experiences': [1],
@@ -229,62 +166,65 @@ class PoliticalAgent(Agent):
         self.dissident = dissident
 
     def update_estimation(self, network_id):
-        """Update the agent's estimation for a given network."""
-        # neighbors are node ids, map to agent objects via model.id2agent
-        potential_partners = [self.model.id2agent[n] for n in self.model.networks[network_id]['network'].neighbors(self.unique_id)]
+        partners = [self.model.id2agent[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)
+        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)
+
+        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:
-                        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)
+        if not partners:
+            return
 
-                    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)
+        partner = random.choice(partners)
+        ntype = self.model.networks[network_id]['type']
 
-            elif self.model.networks[network_id]['type'] == 'social_media':
+        if ntype == 'physical':
+            if current_experiment >= self.model.threshold:
                 if partner.dissident:
-                    self.experiences['dissident_experiences'].append(1 * self.model.social_media_factor)
+                    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 * self.model.social_media_factor)
+                    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)
+
+        elif ntype == 'social_media':
+            if partner.dissident:
+                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)
 
     def combine_estimations(self):
-        # Placeholder for bounded confidence, not used currently
+        # Bounded confidence placeholder; keep harmless
         if not hasattr(self, "current_estimations"):
             return
         values = [list(d.values())[0] for d in self.current_estimations]
         if len(values) > 0:
-            within_range = [value for value in values if abs(self.estimation - value) <= self.model.bounded_confidence_range]
-            if len(within_range) > 0:
-                self.estimation = np.mean(within_range)
+            within = [v for v in values if abs(self.estimation - v) <= self.model.bounded_confidence_range]
+            if len(within) > 0:
+                self.estimation = np.mean(within)
 
     def step(self):
         if not hasattr(self, 'current_estimations'):
             self.current_estimations = []
-        for network_id in self.model.networks.keys():
-            self.update_estimation(network_id)
+        for net_id in self.model.networks.keys():
+            self.update_estimation(net_id)
         self.combine_estimations()
         del self.current_estimations
 
 class PoliticalModel(Model):
-    """A model of a political system with multiple interacting agents."""
-
     def __init__(
         self,
         n_agents,
@@ -302,7 +242,7 @@ class PoliticalModel(Model):
         intervention_list=None,
         rng_seed=None,
     ):
-        # Important: initialize parent so self.random exists
+        # Ensure Mesa creates self.random
         try:
             super().__init__(rng_seed=rng_seed)  # Mesa >= 3.0
         except TypeError:
@@ -322,10 +262,10 @@ class PoliticalModel(Model):
         self.print_frequency = print_frequency
         self.early_stopping_steps = early_stopping_steps
         self.early_stopping_range = early_stopping_range
+        self.bounded_confidence_range = 1.0  # harmless default
 
         self.mean_estimations = []
         self.decay_factors = [0.5 ** (i / self.half_life) for i in range(500)]
-
         self.running = True
         self.share_regime_supporters = share_regime_supporters
 
@@ -335,9 +275,7 @@ class PoliticalModel(Model):
         # Align attributes across networks and compute homophilies
         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'
+                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(
@@ -347,20 +285,17 @@ class PoliticalModel(Model):
                     cooling_factor=0.995,
                     attr_name='dissident'
                 )
+                self.networks[this_network].setdefault('network_data_to_keep', {})
                 self.networks[this_network]['network_data_to_keep']['actual_homophily'] = compute_homophily(
-                    self.networks[this_network]["network"],
-                    attr_name='dissident'
+                    self.networks[this_network]["network"], attr_name='dissident'
                 )
             if i > 0:
-                # Reindex so node ids match across networks
                 first_key = next(iter(self.networks))
                 self.networks[this_network]["network"] = reindex_graph_to_match_attributes(
-                    self.networks[first_key]["network"],
-                    self.networks[this_network]["network"],
-                    'dissident'
+                    self.networks[first_key]["network"], self.networks[this_network]["network"], 'dissident'
                 )
 
-        # Create agents and an id -> agent map for stable lookups
+        # Create agents and id -> agent map
         self.id2agent = {}
         first_key = next(iter(self.networks))
         for i in range(self.num_agents):
@@ -375,16 +310,13 @@ class PoliticalModel(Model):
             "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)
-
                     def reporter(model, attr_name=attr_name):
                         return getattr(model, attr_name)
-
                     model_reporters[attr_name] = reporter
 
         if agent_reporters:
@@ -401,44 +333,37 @@ class PoliticalModel(Model):
         # Interventions
         for this_intervention in self.intervention_list:
             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 = list(self.schedule.agents)  # stable across Mesa versions
-                    current_supporters = sum(not agent.dissident for agent in agents)
+                    agents = list(self.schedule.agents)
+                    current_supporters = sum(not a.dissident for a in agents)
                     total_agents = len(agents)
-                    current_share = current_supporters / total_agents
-
                     required_supporters = int(target_supporter_share * total_agents)
-                    agents_to_change = abs(required_supporters - current_supporters)
-
-                    if current_share < target_supporter_share:
-                        dissidents = [agent for agent in agents if agent.dissident]
-                        for agent in random.sample(dissidents, min(agents_to_change, len(dissidents))):
-                            agent.dissident = False
-                    elif current_share > target_supporter_share:
-                        supporters = [agent for agent in agents if not agent.dissident]
-                        for agent in random.sample(supporters, min(agents_to_change, len(supporters))):
-                            agent.dissident = True
-
+                    to_change = abs(required_supporters - current_supporters)
+                    if current_supporters / total_agents < target_supporter_share:
+                        pool = [a for a in agents if a.dissident]
+                        for a in random.sample(pool, min(to_change, len(pool))):
+                            a.dissident = False
+                    else:
+                        pool = [a for a in agents if not a.dissident]
+                        for a in random.sample(pool, min(to_change, len(pool))):
+                            a.dissident = True
                 if this_intervention['type'] == 'social_media_adjustment':
-                    self.social_media_factor = max(0, min(1, self.social_media_factor + self_intervention['strength']))
+                    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)
+        self.mean_estimations.append(compute_mean(self))
 
         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:
+            recent = self.mean_estimations[-self.early_stopping_steps:]
+            if max(recent) - min(recent) < self.early_stopping_range:
                 self.running = False
 
-import PIL
-
+# -----------------------------
+# Runner and plotting
+# -----------------------------
 def run_and_plot_simulation(
     separate_agent_types=False,
     n_agents=300,
@@ -458,57 +383,49 @@ def run_and_plot_simulation(
     social_media_network_type_powerlaw_exponent=3,
     social_media_network_type='Powerlaw',
     use_social_media_network=False,
-    social_media_factor=1.0,   # NEW: wired from UI
+    social_media_factor=1.0,
     rng_seed=None
 ):
     print(physical_network_type)
-
     networks = {}
 
     # Physical network
     if physical_network_type == 'Fully Connected':
         G = nx.complete_graph(n_agents)
         networks['physical'] = {"network": G, "type": "physical", "positions": nx.circular_layout(G)}
-
     elif physical_network_type == "Powerlaw":
         s = nx.utils.powerlaw_sequence(n_agents, powerlaw_exponent)
         G = nx.expected_degree_graph(s, selfloops=False)
         G = nx.convert_node_labels_to_integers(ensure_neighbors(G))
         networks['physical'] = {"network": G, "type": "physical", "positions": nx.kamada_kawai_layout(G)}
-
     elif physical_network_type == "Random Geometric":
-        physical_graph_points = np.random.rand(n_agents, 2)
-        G = graph_from_coordinates(physical_graph_points, phys_network_radius)
+        pts = np.random.rand(n_agents, 2)
+        G = graph_from_coordinates(pts, phys_network_radius)
         G = nx.convert_node_labels_to_integers(ensure_neighbors(G))
-        networks['physical'] = {"network": G, "type": "physical", "positions": physical_graph_points}
+        networks['physical'] = {"network": G, "type": "physical", "positions": pts}
 
     if introduce_physical_homophily_true_false:
         networks['physical']['homophily'] = physical_homophily
-    networks['physical']['network_data_to_keep'] = {}
+    networks['physical'].setdefault('network_data_to_keep', {})
 
     # Social media network
     if use_social_media_network:
         if social_media_network_type == 'Fully Connected':
             G = nx.complete_graph(n_agents)
             networks['social_media'] = {"network": G, "type": "social_media", "positions": nx.circular_layout(G)}
-
         elif social_media_network_type == "Powerlaw":
             s = nx.utils.powerlaw_sequence(n_agents, social_media_network_type_powerlaw_exponent)
             G = nx.expected_degree_graph(s, selfloops=False)
             G = nx.convert_node_labels_to_integers(ensure_neighbors(G))
             networks['social_media'] = {"network": G, "type": "social_media", "positions": nx.kamada_kawai_layout(G)}
-
         elif social_media_network_type == "Random Geometric":
-            social_media_graph_points = np.random.rand(n_agents, 2)
-            G = graph_from_coordinates(social_media_graph_points, social_media_network_type_random_geometric_radius)
+            pts = np.random.rand(n_agents, 2)
+            G = graph_from_coordinates(pts, social_media_network_type_random_geometric_radius)
             G = nx.convert_node_labels_to_integers(ensure_neighbors(G))
-            networks['social_media'] = {"network": G, "type": "social_media", "positions": social_media_graph_points}
-
+            networks['social_media'] = {"network": G, "type": "social_media", "positions": pts}
         if introduce_social_media_homophily_true_false:
             networks['social_media']['homophily'] = social_media_homophily
-        networks['social_media']['network_data_to_keep'] = {}
-
-    intervention_list = []
+        networks['social_media'].setdefault('network_data_to_keep', {})
 
     model = PoliticalModel(
         n_agents,
@@ -516,12 +433,12 @@ def run_and_plot_simulation(
         share_regime_supporters,
         threshold,
         social_learning_factor=social_learning_factor,
-        social_media_factor=social_media_factor,  # NEW
+        social_media_factor=social_media_factor,
         half_life=half_life,
         print_agents=False,
         print_frequency=50,
         agent_reporters=True,
-        intervention_list=intervention_list,
+        intervention_list=[],
         rng_seed=rng_seed
     )
 
@@ -531,75 +448,64 @@ def run_and_plot_simulation(
     agent_df = model.datacollector.get_agent_vars_dataframe().reset_index()
     agent_df_pivot = agent_df.pivot(index='Step', columns='AgentID', values='Estimation')
 
-    run_plot, ax = plt.subplots(figsize=(12, 8))
+    # Time series plot
+    fig1, ax = plt.subplots(figsize=(12, 8))
     if not separate_agent_types:
-        for column in agent_df_pivot.columns:
-            plt.plot(agent_df_pivot.index, agent_df_pivot[column], color='gray', alpha=0.1)
-        mean_estimation = agent_df_pivot.mean(axis=1)
-        plt.plot(mean_estimation.index, mean_estimation, color='black', linewidth=2)
+        for col in agent_df_pivot.columns:
+            plt.plot(agent_df_pivot.index, agent_df_pivot[col], color='gray', alpha=0.1)
+        mean_est = agent_df_pivot.mean(axis=1)
+        plt.plot(mean_est.index, mean_est, color='black', linewidth=2)
     else:
         colors = {1: '#d6a44b', 0: '#1b4968'}
-        labels = {1: 'Dissident', 0: 'Supporter'}
-
-        for agent_id in agent_df_pivot.columns:
-            agent_type = agent_df[agent_df['AgentID'] == agent_id]['Dissident'].iloc[0]
-            plt.plot(agent_df_pivot.index, agent_df_pivot[agent_id], color=colors[agent_type], alpha=0.1)
-
-        for agent_type, color in colors.items():
-            mean_estimation = agent_df_pivot.loc[:, agent_df[agent_df['Dissident'] == agent_type]['AgentID']].mean(axis=1)
-            plt.plot(mean_estimation.index, mean_estimation, color=color, linewidth=2, label=f'{labels[agent_type]}')
+        for aid in agent_df_pivot.columns:
+            typ = agent_df.loc[agent_df['AgentID'] == aid, 'Dissident'].iloc[0]
+            plt.plot(agent_df_pivot.index, agent_df_pivot[aid], color=colors[typ], alpha=0.1)
+        for typ, color in colors.items():
+            mean_est = agent_df_pivot.loc[:, agent_df[agent_df['Dissident'] == typ]['AgentID']].mean(axis=1)
+            plt.plot(mean_est.index, mean_est, color=color, linewidth=2, label='Dissident' if typ == 1 else 'Supporter')
         plt.legend(loc='lower right')
 
     plt.title('Agent Estimation Over Time', loc='right')
     plt.xlabel('Time step')
     plt.ylabel('Estimation')
-
     plt.savefig('run_plot.png', bbox_inches='tight', dpi=400, transparent=True)
     run_plot = PIL.Image.open('run_plot.png').convert('RGBA')
 
     # Network plot
     n_networks = len(networks)
-    network_plot, axs = plt.subplots(1, n_networks, figsize=(9.5 * n_networks, 8))
+    fig2, axs = plt.subplots(1, n_networks, figsize=(9.5 * n_networks, 8))
     if n_networks == 1:
         axs = [axs]
 
-    estimations = {}
-    for agent in model.schedule.agents:
-        estimations[agent.unique_id] = agent.estimation
-
-    for idx, (network_id, network_dict) in enumerate(networks.items()):
-        network = network_dict['network']
-        nx.set_node_attributes(network, estimations, 'estimation')
-
-        if 'positions' in network_dict:
-            pos = network_dict['positions']
-        else:
-            pos = nx.kamada_kawai_layout(network)
-
-        node_colors = [estimations[node] for node in network.nodes]
-        axs[idx].set_title(f'Network: {network_id}', loc='right')
-
+    estimations = {a.unique_id: a.estimation for a in model.schedule.agents}
+    for idx, (net_id, net_dict) in enumerate(networks.items()):
+        net = net_dict['network']
+        nx.set_node_attributes(net, estimations, 'estimation')
+        pos = net_dict.get('positions', nx.kamada_kawai_layout(net))
+        node_colors = [estimations[node] for node in net.nodes]
+        axs[idx].set_title(f'Network: {net_id}', loc='right')
         nx.draw_networkx_nodes(
-            network, pos, node_size=50, node_color=node_colors,
+            net, pos, node_size=50, node_color=node_colors,
             cmap=cmocean.tools.crop_by_percent(cmocean.cm.curl, 20, which='both', N=None),
             vmin=0, vmax=1, ax=axs[idx]
         )
-        nx.draw_networkx_edges(network, pos, alpha=0.3, ax=axs[idx])
-
+        nx.draw_networkx_edges(net, pos, alpha=0.3, ax=axs[idx])
         sm = mpl.cm.ScalarMappable(
             cmap=cmocean.tools.crop_by_percent(cmocean.cm.curl, 20, which='both', N=None),
             norm=plt.Normalize(vmin=0, vmax=1)
         )
         sm.set_array([])
-        network_plot.colorbar(sm, ax=axs[idx])
+        fig2.colorbar(sm, ax=axs[idx])
 
     plt.savefig('network_plot.png', bbox_inches='tight', dpi=400, transparent=True)
     network_plot = PIL.Image.open('network_plot.png').convert('RGBA')
 
     return run_plot, network_plot
 
+# -----------------------------
+# Gradio UI
+# -----------------------------
 import gradio as gr
-import matplotlib.pyplot as plt
 
 with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
     with gr.Column():
@@ -610,25 +516,21 @@ Vary the parameters below, and click 'Run Simulation' to run.
             with gr.Column():
                 with gr.Group():
                     separate_agent_types = gr.Checkbox(value=False, label="Separate agent types in plot")
-
-                    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)
+                    n_agents_slider = gr.Slider(100, 500, step=10, label="Number of Agents", value=150)
+                    share_regime_slider = gr.Slider(0.0, 1.0, step=0.01, label="Share of Regime Supporters", value=0.4)
+                    threshold_slider = gr.Slider(0.0, 1.0, step=0.01, label="Threshold", value=0.5)
+                    social_learning_slider = gr.Slider(0.0, 2.0, step=0.1, label="Social Learning Factor", value=1.0)
+                    steps_slider = gr.Slider(10, 100, step=5, label="Simulation Steps", value=40)
+                    half_life_slider = gr.Slider(5, 50, step=5, label="Half-Life", value=20)
 
                     # Physical network settings
                     with gr.Group():
                         gr.Markdown("""**Physical Network Settings:**""")
                         introduce_physical_homophily_true_false = gr.Checkbox(value=False, label="Stipulate Homophily")
-
                         with gr.Group(visible=False) as homophily_group:
                             physical_homophily = gr.Slider(0, 1, label="Homophily", info='How much homophily to stipulate.')
-
                         def update_homophily_group_visibility(checkbox_state):
                             return {homophily_group: gr.Group(visible=checkbox_state)}
-
                         introduce_physical_homophily_true_false.change(
                             update_homophily_group_visibility,
                             inputs=introduce_physical_homophily_true_false,
@@ -637,83 +539,70 @@ Vary the parameters below, and click 'Run Simulation' to run.
 
                         physical_network_type = gr.Dropdown(label="Physical Network Type", value="Fully Connected",
                                                             choices=["Fully Connected", "Random Geometric", "Powerlaw"])
-
                         with gr.Group(visible=True) as physical_network_type_fully_connected_group:
                             gr.Markdown("""""")
-
                         with gr.Group(visible=False) as physical_network_type_random_geometric_group:
-                            physical_network_type_random_geometric_radius = gr.Slider(minimum=.0, maximum=.5, label="Radius")
-
+                            physical_network_type_random_geometric_radius = gr.Slider(0.0, 0.5, label="Radius")
                         with gr.Group(visible=False) as physical_network_type_powerlaw_group:
-                            physical_network_type_random_geometric_powerlaw_exponent = gr.Slider(minimum=.0, maximum=5.2, label="Powerlaw Exponent")
-
+                            physical_network_type_random_geometric_powerlaw_exponent = gr.Slider(0.0, 5.2, label="Powerlaw Exponent")
                         def update_sliders(option):
                             return {
                                 physical_network_type_fully_connected_group: gr.Group(visible=option == "Fully Connected"),
                                 physical_network_type_random_geometric_group: gr.Group(visible=option == "Random Geometric"),
                                 physical_network_type_powerlaw_group: gr.Group(visible=option == "Powerlaw")
                             }
-
                         physical_network_type.change(
                             update_sliders,
                             inputs=physical_network_type,
-                            outputs=[physical_network_type_fully_connected_group,
-                                     physical_network_type_random_geometric_group,
-                                     physical_network_type_powerlaw_group]
+                            outputs=[
+                                physical_network_type_fully_connected_group,
+                                physical_network_type_random_geometric_group,
+                                physical_network_type_powerlaw_group
+                            ]
                         )
 
                 # Social media settings
                 use_social_media_network = gr.Checkbox(value=False, label="Use social media network")
                 with gr.Group(visible=False) as social_media_group:
                     gr.Markdown("""**Social Media Network Settings:**""")
-
                     social_media_factor = gr.Slider(0, 2, label="Social Media Factor",
                                                     info='Weight of social media vs learning in the real world.',
                                                     value=1.0)
                     introduce_social_media_homophily_true_false = gr.Checkbox(value=False, label="Stipulate Homophily")
-
                     with gr.Group(visible=False) as social_media_homophily_group:
                         social_media_homophily = gr.Slider(0, 1, label="Homophily", info='How much homophily to stipulate in social media network.')
-
                     def update_social_media_homophily_group_visibility(checkbox_state):
                         return {social_media_homophily_group: gr.Group(visible=checkbox_state)}
-
                     introduce_social_media_homophily_true_false.change(
                         update_social_media_homophily_group_visibility,
                         inputs=introduce_social_media_homophily_true_false,
                         outputs=social_media_homophily_group
                     )
-
                     social_media_network_type = gr.Dropdown(label="Social Media Network Type", value="Fully Connected",
                                                             choices=["Fully Connected", "Random Geometric", "Powerlaw"])
-
                     with gr.Group(visible=True) as social_media_network_type_fully_connected_group:
                         gr.Markdown("""""")
-
                     with gr.Group(visible=False) as social_media_network_type_random_geometric_group:
-                        social_media_network_type_random_geometric_radius = gr.Slider(minimum=0.0, maximum=0.5, label="Radius")
-
+                        social_media_network_type_random_geometric_radius = gr.Slider(0.0, 0.5, label="Radius")
                     with gr.Group(visible=False) as social_media_network_type_powerlaw_group:
-                        social_media_network_type_powerlaw_exponent = gr.Slider(minimum=0.0, maximum=5.2, label="Powerlaw Exponent")
-
+                        social_media_network_type_powerlaw_exponent = gr.Slider(0.0, 5.2, label="Powerlaw Exponent")
                     def update_social_media_network_sliders(option):
                         return {
                             social_media_network_type_fully_connected_group: gr.Group(visible=option == "Fully Connected"),
                             social_media_network_type_random_geometric_group: gr.Group(visible=option == "Random Geometric"),
                             social_media_network_type_powerlaw_group: gr.Group(visible=option == "Powerlaw")
                         }
-
                     social_media_network_type.change(
                         update_social_media_network_sliders,
                         inputs=social_media_network_type,
-                        outputs=[social_media_network_type_fully_connected_group,
-                                 social_media_network_type_random_geometric_group,
-                                 social_media_network_type_powerlaw_group]
+                        outputs=[
+                            social_media_network_type_fully_connected_group,
+                            social_media_network_type_random_geometric_group,
+                            social_media_network_type_powerlaw_group
+                        ]
                     )
-
                 def update_social_media_group_visibility(checkbox_state):
                     return {social_media_group: gr.Group(visible=checkbox_state)}
-
                 use_social_media_network.change(
                     update_social_media_group_visibility,
                     inputs=use_social_media_network,
@@ -726,8 +615,7 @@ Vary the parameters below, and click 'Run Simulation' to run.
                 network_output = gr.Image(label="Networks")
 
         def run_simulation_and_plot(*args):
-            fig = run_and_plot_simulation(*args)
-            return fig
+            return run_and_plot_simulation(*args)
 
         button.click(
             run_simulation_and_plot,
@@ -750,11 +638,10 @@ Vary the parameters below, and click 'Run Simulation' to run.
                 social_media_network_type_powerlaw_exponent,
                 social_media_network_type,
                 use_social_media_network,
-                social_media_factor,  # NEW: now wired through
+                social_media_factor,
             ],
             outputs=[plot_output, network_output]
         )
 
-# Launch the interface
 if __name__ == "__main__":
     demo.launch(debug=True)