# Model design
import agentpy as ap
import networkx as nx
import numpy as np
import random 

# Visualization
import matplotlib.pyplot as plt 
import seaborn as sns
import IPython

categories = ['innovator', 'early_adopter', 'early_majority', 'late_majority', 'laggard'] # tech adoption categories
probabilities = [0.05, 0.1, 0.35, 0.35, 0.15] # fraction of the population that falls into each category
thresholds = [0.0, 0.3, 0.7, 0.8, 0.9] # threshold above which fraction of adopted neighbors will cause agent to adopt

rng = np.random.default_rng()

samples = rng.choice(categories, p=probabilities)
samples

def tech_categorical(categories,probabilities,population_size=100, rng=np.random.default_rng()):
    rng = np.random.default_rng()

    samples = rng.choice(categories, size=population_size,p=probabilities)
    return samples

class InnovationAgent(ap.Agent):
    def setup(self):
        """
        Initializes the agent's adoption state and assigns it to a category based on predefined probabilities.
        """
        # Everyone starts as having not adopted the technology
        self.adopted = False

        # Select a category for the agent using the given probabilities
        rng = np.random
        self.category_idx = rng.choice(len(self.p.categories), p=self.p.probabilities)
        self.category = self.p.categories[self.category_idx]

    def num_adopted_neighbors(self):
        """
        Calculates the number of neighboring agents who have adopted the innovation.
        Returns:
            int: The count of neighbors who have adopted.
        """
        # Get the neighbors of the current agent
        neighbors = self.network.neighbors(self)
        
        # Check adoption status for each neighbor
        adopted = [n.adopted for n in neighbors]
        
        # Count the number of adopters
        return sum(adopted)

    def neighbor_adopted_frac(self):
        """
        Calculates the fraction of neighboring agents who have adopted the innovation.
        Returns:
            float: Fraction of neighbors who have adopted, or 0 if there are no neighbors.
        """
        # Get the neighbors of the current agent
        neighbors = self.network.neighbors(self)
        
        # Check adoption status for each neighbor
        adopted = [n.adopted for n in neighbors]
        len_neighbors = len(adopted)

        # Handle case where there are no neighbors
        if len_neighbors == 0:
            return 0

        # Calculate and return the fraction of adopters
        num_adopters = sum(adopted)
        return num_adopters / len_neighbors

    def adopt_innovation(self):
        """
        Determines whether the agent adopts the innovation based on its category
        and the adoption status of its neighbors.
        """
        # Only proceed if the agent has not already adopted the innovation
        if not self.adopted:
            # Innovators adopt unconditionally
            if self.category == 'innovator':
                self.adopted = True
            # Other categories adopt based on a threshold of neighbor adoption
            elif self.category in ['early_adopter', 'early_majority', 'late_majority', 'laggard']:
                # Calculate the fraction of neighbors who have adopted
                adopted_frac = self.neighbor_adopted_frac()

                # Get the threshold for the agent's category
                threshold = self.p.thresholds[self.category_idx]

                # Adopt if the fraction meets or exceeds the threshold
                if adopted_frac >= threshold:
                    self.adopted = True

class InnovationModel(ap.Model):
    """
    This class represents the overall model for innovation diffusion. It manages the setup,
    simulation steps, and final results.
    """

    def setup(self):
        """
        Initializes the network and agents for the simulation. A small-world network is
        created using the Watts-Strogatz model, and agents are assigned to it.
        """
        graph = nx.watts_strogatz_graph(
            self.p.population,
            self.p.number_of_connections,
            self.p.network_rewire_probability,
        )

        # Create agents and a network
        self.agents = ap.AgentList(self, self.p.population, InnovationAgent)
        self.network = self.agents.network = ap.Network(self, graph)
        self.network.add_agents(self.agents, self.network.nodes)

    def update(self):
        """
        Calculates the fraction of agents who have adopted the innovation and records it.
        Stops the simulation if all agents have adopted.
        """
        frac_adopted = sum(1 for a in self.agents if a.adopted) / self.p.population
        self.record("fraction adopted", frac_adopted)

        # Stop if everyone has adopted the tech
        if frac_adopted == 1:
            self.stop()

    def step(self):
        """
        Executes a single step of the simulation. During each step, agents decide
        whether to adopt the innovation based on their category and network connections.
        """
        for agent in self.agents:
            agent.adopt_innovation() # Agents adopt innovations based on their category and network connections
    
    def end(self):
        """
        Finalizes the simulation. Additional computations or outputs can be added here if needed.
        """
        pass

parameters = {
    'population': 100,
    "categories": ['innovator', 'early_adopter', 'early_majority', 'late_majority', 'laggard'],
    "probabilities": [0.05, 0.1, 0.35, 0.35, 0.15],
    "thresholds": [0.0, 0.1, 0.25, 0.5, 0.9],
    "number_of_connections": 4,
    "network_rewire_probability": 0.1,
    "steps":100,
}

Completed: 100 steps
Run time: 0:00:00.014400
Simulation finished

model = InnovationModel(parameters)
results = model.run()

Completed: 100 steps
Run time: 0:00:00.011041
Simulation finished

%matplotlib inline
data = results.variables.InnovationModel
ax = data.plot()

%matplotlib inline  
# Enable interactive widgets for matplotlib (e.g., zooming and panning).

# Get the network and agent data from the model.
network = model.network  # Retrieve the network structure from the model.
adopted_states = [agent.adopted for agent in model.agents]  # Extract the adoption status (True/False) for all agents.

# Define node colors based on the adopted parameter.
# Nodes representing agents with 'adopted = True' will be red, otherwise black.
node_colors = ['red' if adopted else 'black' for adopted in adopted_states]

# Generate labels for nodes based on the agent's category index.
# Each node is labeled with its corresponding agent's category index as a string.
labels = [str(agent.category_idx) for agent in model.agents]
labels = {i: labels[i] for i in range(len(labels))}  # Map labels to node indices for visualization.

# Define the layout of the graph using the spring layout.
pos = nx.spring_layout(network.graph)  # Position nodes using a force-directed layout algorithm.

# Draw the network graph using NetworkX's `draw` method.
nx.draw(
    network.graph,         # The graph to draw.
    pos,                   # Node positions.
    node_color=node_colors,  # Colors of the nodes based on adoption status.
    with_labels=False,     # Whether to show labels on the nodes (currently disabled).
    node_size=500          # Size of the nodes in the graph.
)

# Add a legend to explain node colors.
# The legend will have two entries: one for 'Adopted' (red) and one for 'Not Adopted' (black).
plt.legend(handles=[
    plt.Line2D([0], [0], marker='o', color='w', label='Adopted', markerfacecolor='red', markersize=10),
    plt.Line2D([0], [0], marker='o', color='w', label='Not Adopted', markerfacecolor='black', markersize=10)
])

# Add a title to the plot for better understanding.
plt.title("Agent Network with Node Colors Based on Adoption Status")

# Display the graph.
plt.show()
# plt.close()  # Optionally close the plot if running in an interactive environment to avoid clutter.

import networkx as nx
import matplotlib.pyplot as plt

# Parameters for the Watts-Strogatz graph
n = 30  # Number of nodes
k = 4   # Each node is connected to k nearest neighbors in ring topology
p = 0.1 # Probability of rewiring each edge

# Create a Watts-Strogatz small-world graph
G = nx.watts_strogatz_graph(n, k, p)

# Draw the graph
plt.figure(figsize=(8, 6))
nx.draw(G, with_labels=True, node_color='lightblue', edge_color='gray', node_size=500, font_size=10)

# Show the plot
plt.title("Watts-Strogatz Graph")
plt.show()

AI Tech Adoption Model

Jupyter notebook for AI Tech Adoption

Introduction¶

Simple Exploration¶

Agentpy Agent definition¶

Running The Model¶

Prompt to 4o¶

Output¶

Summary of the Model:¶

Further Prompt¶

Response¶

Strengths of the Configuration¶

Limitations of Realism¶

Suggestions to Improve Realism¶

Conclusion¶

Actual Model Run¶

Interpretation¶

Playing around with networkx graphing¶