removed problematic trial code

app.py

@@ -569,63 +569,63 @@ class PoliticalModel(Model):
 
 # # Example usage
 
-radius=.09
-physical_graph_points = np.random.rand(100, 2)
-physical_graph = graph_from_coordinates(physical_graph_points, radius)
-physical_graph = nx.convert_node_labels_to_integers(ensure_neighbors(physical_graph))
+# radius=.09
+# physical_graph_points = np.random.rand(100, 2)
+# physical_graph = graph_from_coordinates(physical_graph_points, radius)
+# physical_graph = nx.convert_node_labels_to_integers(ensure_neighbors(physical_graph))
 
-# unconnected nodes: link or drop?
-networks = {
-    "physical": {"network": physical_graph, "type": "physical", "positions": physical_graph_points, 'network_data_to_keep':{'radius':radius},'homophily':0. }}
+# # unconnected nodes: link or drop?
+# networks = {
+#     "physical": {"network": physical_graph, "type": "physical", "positions": physical_graph_points, 'network_data_to_keep':{'radius':radius},'homophily':0. }}
 
 
-model = PoliticalModel(100, networks, .5, .5,.5, half_life=20, print_agents=False, print_frequency=50, agent_reporters=True, intervention_list=[])
+# model = PoliticalModel(100, networks, .5, .5,.5, half_life=20, print_agents=False, print_frequency=50, agent_reporters=True, intervention_list=[])
 
 
-for _ in tqdm.tqdm_notebook(range(40)):  # Run for specified number of steps
-    model.step()
+# for _ in tqdm.tqdm_notebook(range(40)):  # Run for specified number of steps
+#     model.step()
 
-import matplotlib.pyplot as plt
-import pandas as pd
+# import matplotlib.pyplot as plt
+# import pandas as pd
 
-# Assuming 'model' is defined and has a datacollector with the necessary data
-agent_df = model.datacollector.get_agent_vars_dataframe().reset_index()
+# # Assuming 'model' is defined and has a datacollector with the necessary data
+# agent_df = model.datacollector.get_agent_vars_dataframe().reset_index()
 
-# Pivot the dataframe for Estimation
-agent_df_pivot = agent_df.pivot(index='Step', columns='AgentID', values='Estimation')
+# # Pivot the dataframe for Estimation
+# agent_df_pivot = agent_df.pivot(index='Step', columns='AgentID', values='Estimation')
 
-# Create the result plot
-run_plot, ax = plt.subplots(figsize=(12, 8))
+# # Create the result plot
+# run_plot, ax = plt.subplots(figsize=(12, 8))
 
-# Define colors for Dissident and Supporter
-colors = {1: '#d6a44b', 0: '#1b4968'}  # 1 for Dissident, 0 for Supporter
-labels = {1: 'Dissident', 0: 'Supporter'}
-legend_handles = []
+# # Define colors for Dissident and Supporter
+# colors = {1: '#d6a44b', 0: '#1b4968'}  # 1 for Dissident, 0 for Supporter
+# labels = {1: 'Dissident', 0: 'Supporter'}
+# legend_handles = []
 
-# Plot each agent's data
-for agent_id in agent_df_pivot.columns:
-    # Get the agent type (Dissident or Supporter)
-    agent_type = agent_df[agent_df['AgentID'] == agent_id]['Dissident'].iloc[0]
+# # Plot each agent's data
+# for agent_id in agent_df_pivot.columns:
+#     # Get the agent type (Dissident or Supporter)
+#     agent_type = agent_df[agent_df['AgentID'] == agent_id]['Dissident'].iloc[0]
 
-    # Plot
-    line, = plt.plot(agent_df_pivot.index, agent_df_pivot[agent_id], color=colors[agent_type], alpha=0.1)
+#     # Plot
+#     line, = plt.plot(agent_df_pivot.index, agent_df_pivot[agent_id], color=colors[agent_type], alpha=0.1)
 
 
-# Compute and plot the mean estimation for each group
-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]}')
+# # Compute and plot the mean estimation for each group
+# 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]}')
 
-# Set the plot title and labels
-plt.title('Agent Estimation Over Time', loc='right')
-plt.xlabel('Time step')
-plt.ylabel('Estimation')
+# # Set the plot title and labels
+# plt.title('Agent Estimation Over Time', loc='right')
+# plt.xlabel('Time step')
+# plt.ylabel('Estimation')
 
-# Add legend
-plt.legend(loc='lower right')
+# # Add legend
+# plt.legend(loc='lower right')
 
 
-plt.show()
+# plt.show()
 
 def run_and_plot_simulation(separate_agent_types=False,n_agents=300, share_regime_supporters=0.4, threshold=0.5, social_learning_factor=1, simulation_steps=40, half_life=20,
                             phys_network_radius=.06, powerlaw_exponent=3,physical_network_type='physical_network_type_fully_connected',
@@ -635,3 +635,303 @@ def run_and_plot_simulation(separate_agent_types=False,n_agents=300, share_regim
 
     print(physical_network_type)
 
+    networks = {}
+
+    # Set up 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) #100 nodes, power-law exponent 2.5
+        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)
+        G = nx.convert_node_labels_to_integers(ensure_neighbors(G))
+        networks['physical'] =  {"network": G, "type": "physical", "positions": physical_graph_points}
+
+    if introduce_physical_homophily_true_false:
+       networks['physical']['homophily'] = physical_homophily
+    networks['physical']['network_data_to_keep'] = {}
+
+
+    # Set up 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)  # 100 nodes, power-law exponent adjusted for social media
+          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)
+          G = nx.convert_node_labels_to_integers(ensure_neighbors(G))
+          networks['social_media'] = {"network": G, "type": "social_media", "positions": social_media_graph_points}
+
+      if introduce_social_media_homophily_true_false:
+          networks['social_media']['homophily'] = social_media_homophily
+      networks['social_media']['network_data_to_keep'] = {}
+
+
+
+    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()
+
+
+
+    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 esult-plot
+    run_plot, 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)
+
+            # 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)
+
+
+
+    else:
+        # Define colors for Dissident and Supporter
+        colors = {1: '#d6a44b', 0: '#1b4968'}  # 1 for Dissident, 0 for Supporter
+        labels = {1: 'Dissident', 0: 'Supporter'}
+        legend_handles = []
+
+        # Plot each agent's data
+        for agent_id in agent_df_pivot.columns:
+            # Get the agent type (Dissident or Supporter)
+            agent_type = agent_df[agent_df['AgentID'] == agent_id]['Dissident'].iloc[0]
+
+            # Plot
+            line, = plt.plot(agent_df_pivot.index, agent_df_pivot[agent_id], color=colors[agent_type], alpha=0.1)
+
+
+        # Compute and plot the mean estimation for each group
+        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]}')
+        plt.legend(loc='lower right')
+
+
+
+    # Set the plot title and labels
+    plt.title('Agent Estimation Over Time', loc='right')
+    plt.xlabel('Time step')
+    plt.ylabel('Estimation')
+
+
+
+
+# Create the network-plot
+    n_networks = len(networks)
+    network_plot, 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']
+        # Collect estimations and set the node attributes
+
+
+        nx.set_node_attributes(network, estimations, 'estimation')
+
+        # Use the positions provided in the network dict if available
+        if 'positions' in network_dict:
+            pos = network_dict['positions']
+        else:
+            pos = nx.kamada_kawai_layout(network)
+
+        # Draw the network with nodes colored by their estimation values
+        node_colors = [estimations[node] for node in network.nodes]
+        axs[idx].set_title(f'Network: {network_id}', loc='right')
+        nx.draw(network, pos, node_size=50, node_color=node_colors,
+                cmap=cmocean.tools.crop_by_percent(cmocean.cm.curl, 20, which='both', N=None),
+                with_labels=False,vmin=0, vmax=1, ax=axs[idx])
+        # Create a dummy ScalarMappable with the same colormap
+        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])
+
+    return run_plot, network_plot
+
+
+# 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("""# Simulate Revolutions
+                    Agents are placed on a fully connected graph. Vary the parameters below, and click 'Run Simulation' to run.
+                """)
+    with gr.Row():
+      with gr.Column():
+
+          with gr.Group():
+              separate_agent_types = gr.Checkbox(value=False, label="Separate agent types in plot")
+
+              # 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)
+
+
+              # physical network settings
+              with gr.Group():
+              # with gr.Group():
+                gr.Markdown("""**Physical Network Settings:**""")
+               # Define the checkbox
+                introduce_physical_homophily_true_false = gr.Checkbox(value=False, label="Stipulate Homophily")
+
+                # Define a group to hold the slider
+                with gr.Group(visible=False) as homophily_group:
+                    physical_homophily = gr.Slider(0, 1, label="Homophily", info='How much homophily to stipulate.')
+
+                # Function to update the visibility of the group based on the checkbox
+                def update_homophily_group_visibility(checkbox_state):
+                    return {
+                        homophily_group: gr.Group(visible=checkbox_state)  # The group visibility depends on the checkbox
+                    }
+
+                # Bind the function to the checkbox
+                introduce_physical_homophily_true_false.change(
+                    update_homophily_group_visibility,
+                    inputs=introduce_physical_homophily_true_false,
+                    outputs=homophily_group
+                )
+
+
+                physical_network_type = gr.Dropdown(label="Physical Network Type", value="Fully Connected",choices=["Fully Connected", "Random Geometric","Powerlaw"])#value ="Fully Connected"
+
+
+                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")
+
+                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")
+
+                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])
+
+            # 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:**""")
+
+              # Define the checkbox for social media network
+              social_media_factor = gr.Slider(0, 2, label="Social Media Factor", info='How strongly to weigh the social media network against learning in the real world.')
+              introduce_social_media_homophily_true_false = gr.Checkbox(value=False, label="Stipulate Homophily")
+
+              # Define a group to hold the slider for social media network
+              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.')
+
+              # Function to update the visibility of the group based on the checkbox for social media network
+              def update_social_media_homophily_group_visibility(checkbox_state):
+                  return {
+                      social_media_homophily_group: gr.Group(visible=checkbox_state)  # The group visibility depends on the checkbox for social media network
+                  }
+
+              # Bind the function to the checkbox for social media network
+              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")
+
+              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")
+
+              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])
+          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,outputs=social_media_group)
+
+
+      with gr.Column():
+          # Button to trigger the simulation
+          button = gr.Button("Run Simulation")
+          plot_output = gr.Plot(label="Simulation Result")
+          network_output = gr.Plot(label="Networks")
+
+
+    # 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=[separate_agent_types,n_agents_slider, share_regime_slider, threshold_slider, social_learning_slider,
+                steps_slider, half_life_slider, physical_network_type_random_geometric_radius,physical_network_type_random_geometric_powerlaw_exponent,physical_network_type,
+                introduce_physical_homophily_true_false,physical_homophily,
+                introduce_social_media_homophily_true_false,social_media_homophily,social_media_network_type_random_geometric_radius,social_media_network_type_powerlaw_exponent,social_media_network_type,use_social_media_network],
+        outputs=[plot_output,network_output]
+    )
+
+# Launch the interface
+if __name__ == "__main__":
+    demo.launch(debug=True)
+