Mesa 3.0.0b0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

mesa/examples/advanced/epstein_civil_violence/app.py

@@ -0,0 +1,72 @@
+from mesa.examples.advanced.epstein_civil_violence.agents import Citizen, Cop
+from mesa.examples.advanced.epstein_civil_violence.model import EpsteinCivilViolence
+from mesa.visualization import (
+    Slider,
+    SolaraViz,
+    make_plot_measure,
+    make_space_matplotlib,
+)
+
+COP_COLOR = "#000000"
+AGENT_QUIET_COLOR = "#648FFF"
+AGENT_REBEL_COLOR = "#FE6100"
+JAIL_COLOR = "#808080"
+JAIL_SHAPE = "rect"
+
+
+def citizen_cop_portrayal(agent):
+    if agent is None:
+        return
+
+    portrayal = {
+        "size": 25,
+        "shape": "s",  # square marker
+    }
+
+    if isinstance(agent, Citizen):
+        color = (
+            AGENT_QUIET_COLOR if agent.condition == "Quiescent" else AGENT_REBEL_COLOR
+        )
+        color = JAIL_COLOR if agent.jail_sentence else color
+        shape = JAIL_SHAPE if agent.jail_sentence else "circle"
+        portrayal["color"] = color
+        portrayal["shape"] = shape
+        if shape == "s":
+            portrayal["w"] = 0.9
+            portrayal["h"] = 0.9
+        else:
+            portrayal["r"] = 0.5
+            portrayal["filled"] = False
+        portrayal["layer"] = 0
+
+    elif isinstance(agent, Cop):
+        portrayal["color"] = COP_COLOR
+        portrayal["r"] = 0.9
+        portrayal["layer"] = 1
+
+    return portrayal
+
+
+model_params = {
+    "height": 40,
+    "width": 40,
+    "citizen_density": Slider("Initial Agent Density", 0.7, 0.0, 0.9, 0.1),
+    "cop_density": Slider("Initial Cop Density", 0.04, 0.0, 0.1, 0.01),
+    "citizen_vision": Slider("Citizen Vision", 7, 1, 10, 1),
+    "cop_vision": Slider("Cop Vision", 7, 1, 10, 1),
+    "legitimacy": Slider("Government Legitimacy", 0.82, 0.0, 1, 0.01),
+    "max_jail_term": Slider("Max Jail Term", 30, 0, 50, 1),
+}
+
+space_component = make_space_matplotlib(citizen_cop_portrayal)
+chart_component = make_plot_measure(["Quiescent", "Active", "Jailed"])
+
+epstein_model = EpsteinCivilViolence()
+
+page = SolaraViz(
+    epstein_model,
+    components=[space_component, chart_component],
+    model_params=model_params,
+    name="Epstein Civil Violence",
+)
+page  # noqa

mesa/examples/advanced/epstein_civil_violence/model.py

@@ -0,0 +1,146 @@
+import mesa
+from mesa.examples.advanced.epstein_civil_violence.agents import Citizen, Cop
+
+
+class EpsteinCivilViolence(mesa.Model):
+    """
+    Model 1 from "Modeling civil violence: An agent-based computational
+    approach," by Joshua Epstein.
+    http://www.pnas.org/content/99/suppl_3/7243.full
+    Attributes:
+        height: grid height
+        width: grid width
+        citizen_density: approximate % of cells occupied by citizens.
+        cop_density: approximate % of cells occupied by cops.
+        citizen_vision: number of cells in each direction (N, S, E and W) that
+            citizen can inspect
+        cop_vision: number of cells in each direction (N, S, E and W) that cop
+            can inspect
+        legitimacy:  (L) citizens' perception of regime legitimacy, equal
+            across all citizens
+        max_jail_term: (J_max)
+        active_threshold: if (grievance - (risk_aversion * arrest_probability))
+            > threshold, citizen rebels
+        arrest_prob_constant: set to ensure agents make plausible arrest
+            probability estimates
+        movement: binary, whether agents try to move at step end
+        max_iters: model may not have a natural stopping point, so we set a
+            max.
+    """
+
+    def __init__(
+        self,
+        width=40,
+        height=40,
+        citizen_density=0.7,
+        cop_density=0.074,
+        citizen_vision=7,
+        cop_vision=7,
+        legitimacy=0.8,
+        max_jail_term=1000,
+        active_threshold=0.1,
+        arrest_prob_constant=2.3,
+        movement=True,
+        max_iters=1000,
+        seed=None,
+    ):
+        super().__init__(seed=seed)
+        self.width = width
+        self.height = height
+        self.citizen_density = citizen_density
+        self.cop_density = cop_density
+        self.citizen_vision = citizen_vision
+        self.cop_vision = cop_vision
+        self.legitimacy = legitimacy
+        self.max_jail_term = max_jail_term
+        self.active_threshold = active_threshold
+        self.arrest_prob_constant = arrest_prob_constant
+        self.movement = movement
+        self.max_iters = max_iters
+        self.iteration = 0
+
+        self.grid = mesa.experimental.cell_space.OrthogonalMooreGrid(
+            (width, height), capacity=1, torus=True, random=self.random
+        )
+
+        model_reporters = {
+            "Quiescent": lambda m: self.count_type_citizens(m, "Quiescent"),
+            "Active": lambda m: self.count_type_citizens(m, "Active"),
+            "Jailed": self.count_jailed,
+            "Cops": self.count_cops,
+        }
+        agent_reporters = {
+            "x": lambda a: a.cell.coordinate[0],
+            "y": lambda a: a.cell.coordinate[1],
+            "breed": lambda a: type(a).__name__,
+            "jail_sentence": lambda a: getattr(a, "jail_sentence", None),
+            "condition": lambda a: getattr(a, "condition", None),
+            "arrest_probability": lambda a: getattr(a, "arrest_probability", None),
+        }
+        self.datacollector = mesa.DataCollector(
+            model_reporters=model_reporters, agent_reporters=agent_reporters
+        )
+        if self.cop_density + self.citizen_density > 1:
+            raise ValueError("Cop density + citizen density must be less than 1")
+
+        for cell in self.grid.all_cells:
+            if self.random.random() < self.cop_density:
+                cop = Cop(self, vision=self.cop_vision)
+                cop.move_to(cell)
+
+            elif self.random.random() < (self.cop_density + self.citizen_density):
+                citizen = Citizen(
+                    self,
+                    hardship=self.random.random(),
+                    regime_legitimacy=self.legitimacy,
+                    risk_aversion=self.random.random(),
+                    threshold=self.active_threshold,
+                    vision=self.citizen_vision,
+                )
+                citizen.move_to(cell)
+
+        self.running = True
+        self.datacollector.collect(self)
+
+    def step(self):
+        """
+        Advance the model by one step and collect data.
+        """
+        self.agents.shuffle_do("step")
+        # collect data
+        self.datacollector.collect(self)
+        self.iteration += 1
+        if self.iteration > self.max_iters:
+            self.running = False
+
+    @staticmethod
+    def count_type_citizens(model, condition, exclude_jailed=True):
+        """
+        Helper method to count agents by Quiescent/Active.
+        """
+        citizens = model.agents_by_type[Citizen]
+
+        if exclude_jailed:
+            return len(
+                [
+                    c
+                    for c in citizens
+                    if (c.condition == condition) and (c.jail_sentence == 0)
+                ]
+            )
+        else:
+            return len([c for c in citizens if c.condition == condition])
+
+    @staticmethod
+    def count_jailed(model):
+        """
+        Helper method to count jailed agents.
+        """
+        return len([a for a in model.agents_by_type[Citizen] if a.jail_sentence > 0])
+
+    @staticmethod
+    def count_cops(model):
+        """
+        Helper method to count jailed agents.
+        """
+        return len(model.agents_by_type[Cop])

mesa/examples/advanced/pd_grid/Readme.md

@@ -0,0 +1,43 @@
+# Demographic Prisoner's Dilemma on a Grid
+
+## Summary
+
+The Demographic Prisoner's Dilemma is a family of variants on the classic two-player [Prisoner's Dilemma]. The model consists of agents, each with a strategy of either Cooperate or Defect. Each agent's payoff is based on its strategy and the strategies of its spatial neighbors. After each step of the model, the agents adopt the strategy of their neighbor with the highest total score.
+
+The model payoff table is:
+
+|               | Cooperate | Defect|
+|:-------------:|:---------:|:-----:|
+| **Cooperate** | 1, 1      | 0, D  |
+| **Defect**    | D, 0      | 0, 0  |
+
+Where *D* is the defection bonus, generally set higher than 1. In these runs, the defection bonus is set to $D=1.6$.
+
+The Demographic Prisoner's Dilemma demonstrates how simple rules can lead to the emergence of widespread cooperation, despite the Defection strategy dominating each individual interaction game. However, it is also interesting for another reason: it is known to be sensitive to the activation regime employed in it.
+
+## How to Run
+
+##### Web based model simulation
+
+To run the model interactively, run ``solara run app.py`` in this directory.
+
+##### Jupyter Notebook
+
+Launch the ``Demographic Prisoner's Dilemma Activation Schedule.ipynb`` notebook and run the code.
+
+## Files
+
+* ``agents.py``: contains the agent class.
+* ``model.py``: contains the model class; the model takes a ``activation_order`` string as an argument, which determines in which order agents are activated: Sequential, Random or Simultaneous.
+* ``app.py``: contains the interactive visualization server.
+* ``Demographic Prisoner's Dilemma Activation Schedule.ipynb``: Jupyter Notebook for running the scheduling experiment. This runs the model three times, one for each activation type, and demonstrates how the activation regime drives the model to different outcomes.
+
+## Further Reading
+
+This model is adapted from:
+
+Wilensky, U. (2002). NetLogo PD Basic Evolutionary model. http://ccl.northwestern.edu/netlogo/models/PDBasicEvolutionary. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
+
+The Demographic Prisoner's Dilemma originates from:
+
+[Epstein, J. Zones of Cooperation in Demographic Prisoner's Dilemma. 1998.](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.8.8629&rep=rep1&type=pdf)

mesa/examples/advanced/pd_grid/agents.py

@@ -0,0 +1,50 @@
+from mesa.experimental.cell_space import CellAgent
+
+
+class PDAgent(CellAgent):
+    """Agent member of the iterated, spatial prisoner's dilemma model."""
+
+    def __init__(self, model, starting_move=None):
+        """
+        Create a new Prisoner's Dilemma agent.
+
+        Args:
+            model: model instance
+            starting_move: If provided, determines the agent's initial state:
+                           C(ooperating) or D(efecting). Otherwise, random.
+        """
+        super().__init__(model)
+        self.score = 0
+        if starting_move:
+            self.move = starting_move
+        else:
+            self.move = self.random.choice(["C", "D"])
+        self.next_move = None
+
+    @property
+    def is_cooroperating(self):
+        return self.move == "C"
+
+    def step(self):
+        """Get the best neighbor's move, and change own move accordingly
+        if better than own score."""
+
+        # neighbors = self.model.grid.get_neighbors(self.pos, True, include_center=True)
+        neighbors = [*list(self.cell.neighborhood.agents), self]
+        best_neighbor = max(neighbors, key=lambda a: a.score)
+        self.next_move = best_neighbor.move
+
+        if self.model.activation_order != "Simultaneous":
+            self.advance()
+
+    def advance(self):
+        self.move = self.next_move
+        self.score += self.increment_score()
+
+    def increment_score(self):
+        neighbors = self.cell.neighborhood.agents
+        if self.model.activation_order == "Simultaneous":
+            moves = [neighbor.next_move for neighbor in neighbors]
+        else:
+            moves = [neighbor.move for neighbor in neighbors]
+        return sum(self.model.payoff[(self.move, move)] for move in moves)