simulatingrisk 1.0.0__py3-none-any.whl

simulatingrisk/risky_bet/model.py

@@ -0,0 +1,237 @@
+from enum import Enum
+from functools import cached_property
+import statistics
+
+import mesa
+
+from simulatingrisk.utils import coinflip
+
+
+Bet = Enum("Bet", ["RISKY", "SAFE"])
+bet_choices = [Bet.SAFE, Bet.RISKY]
+
+# divergent color scheme, eleven colors
+# from https://colorbrewer2.org/?type=diverging&scheme=RdYlGn&n=11
+divergent_colors = [
+    "#a50026",
+    "#d73027",
+    "#f46d43",
+    "#fdae61",
+    "#fee08b",
+    "#ffffbf",
+    "#d9ef8b",
+    "#a6d96a",
+    "#66bd63",
+    "#1a9850",
+    "#006837",
+]
+# low values = risk inclined (more likely to take a risky bet)
+# higher value = risk averse (less likely to the bet)
+
+
+class Gambler(mesa.Agent):
+    def __init__(self, unique_id, model, initial_wealth):
+        super().__init__(unique_id, model)
+        # starting wealth determined by the model
+        self.initial_wealth = initial_wealth  # store initial value
+        self.wealth = initial_wealth
+        # get a random risk tolerance; returns a value between 0.0 and 1.0
+        self.risk_level = self.random.random()
+        self.choice = None
+
+    def __repr__(self):
+        return (
+            f"<Gambler id={self.unique_id} wealth={self.wealth} "
+            + f"risk_level={self.risk_level}>"
+        )
+
+    def step(self):
+        # decide how to bet based on risk tolerance and likelihood
+        # that the risky bet will pay off
+        if self.model.prob_risky_payoff > self.risk_level:
+            self.choice = Bet.RISKY
+        else:
+            self.choice = Bet.SAFE
+
+        # determine the payoff for this choice
+        self.calculate_payoff(self.choice)
+
+        # every ten rounds, agents adjust their risk level
+        # make this a model method?
+        if self.model.adjustment_round:
+            self.adjust_risk()
+
+    def calculate_payoff(self, choice):
+        if choice == Bet.RISKY:
+            # if the risky bet paid off, multiply current wealth by 1.5
+            if self.model.risky_payoff:
+                self.wealth = self.wealth * 1.5
+
+            # if it doesn't, multiply by 0.5
+            else:
+                self.wealth = self.wealth * 0.5
+
+        # otherwise, no change
+
+    @cached_property
+    def neighbors(self):
+        """Get neighbors for the current agent; uses Von Neumann
+        neighborhood (no diagonals), does not include self."""
+        # because this simulation doesn't include any movement,
+        # neighbors won't change over the run and we can cache
+        return self.model.grid.get_neighbors(
+            self.pos, moore=False, include_center=False
+        )
+
+    @property
+    def wealthiest_neighbor(self):
+        """identify and return the current wealthiest neighbor"""
+        # sort neighbors by wealth, wealthiest neighbor first
+        return sorted(self.neighbors, key=lambda x: x.wealth, reverse=True)[0]
+
+    def adjust_risk(self):
+        # look at neighbors (4)
+        # if anyone has more money,
+        # either adopt their risk attitude or average theirs with yours
+        # then reset wealth back to initial value
+
+        wealthiest = self.wealthiest_neighbor
+        # if wealthiest neighbor is richer, adjust
+        if wealthiest.wealth > self.wealth:
+            # adjust risk based on model configuration
+            if self.model.risk_adjustment == "adopt":
+                # adopt wealthiest neighbor's risk level
+                self.risk_level = wealthiest.risk_level
+            elif self.model.risk_adjustment == "average":
+                #  average theirs with mine
+                self.risk_level = statistics.mean(
+                    [self.risk_level, wealthiest.risk_level]
+                )
+
+        # reset wealth back to initial value
+        self.wealth = self.initial_wealth
+
+
+class RiskyBetModel(mesa.Model):
+    """
+    Model for simulating a risky bet game.
+
+    :param grid_size: number for square grid size (creates n*n agents)
+    :param risk_adjustment: strategy agents should use for adjusting risk;
+        adopt (default), or average
+    """
+
+    initial_wealth = 1000
+    running = True  # required for batch run
+
+    def __init__(self, grid_size, risk_adjustment="adopt"):
+        super().__init__()
+        # assume a fully-populated square grid
+        self.num_agents = grid_size * grid_size
+        self.risk_adjustment = risk_adjustment
+        # initialize a single grid (each square inhabited by a single agent);
+        # configure the grid to wrap around so everyone has neighbors
+        self.grid = mesa.space.SingleGrid(grid_size, grid_size, True)
+        self.schedule = mesa.time.SimultaneousActivation(self)
+
+        # initialize agents and add to grid and scheduler
+        for i in range(self.num_agents):
+            a = Gambler(i, self, self.initial_wealth)
+            self.schedule.add(a)
+            # place randomly in an empty spot
+            self.grid.move_to_empty(a)
+
+        self.datacollector = mesa.DataCollector(
+            model_reporters={
+                # state of the world
+                "prob_risky_payoff": "prob_risky_payoff",
+                "risky_bet": "risky_bet",
+                # aggregate information about agents
+                "risk_min": "risk_min",
+                "risk_q1": "risk_q1",
+                "risk_mean": "risk_mean",
+                "risk_q3": "risk_q3",
+                "risk_max": "risk_max",
+            },
+            agent_reporters={"risk_level": "risk_level", "choice": "choice"},
+        )
+
+    def step(self):
+        # run a single round of the game
+
+        # determine the probability of the risky bet paying off this round
+        self.prob_risky_payoff = self.random.random()
+        # determine whether it actually pays off
+        self.risky_payoff = self.call_risky_bet()
+
+        self.schedule.step()
+        self.datacollector.collect(self)
+        # every ten rounds, agents adjust their risk level
+
+        # delete cached property before the next round
+        try:
+            del self.agent_risk_levels
+        except AttributeError:
+            pass
+
+    def call_risky_bet(self):
+        # flip a weighted coin to determine if the risky bet pays off,
+        # weighted by current round payoff probability
+        self.risky_bet = coinflip([True, False], weight=self.prob_risky_payoff)
+        return self.risky_bet
+
+    @property
+    def adjustment_round(self) -> bool:
+        """is the current round an adjustment round?"""
+        # agents should adjust their wealth every 10 rounds;
+        # check if the current step is an adjustment round
+        return self.schedule.steps > 0 and self.schedule.steps % 10 == 0
+
+    @cached_property
+    def agent_risk_levels(self) -> [float]:
+        # list of all risk levels for all current agents;
+        # property is cached but should be cleared in each new round
+
+        # NOTE: occasionally median method is complaining that this is empty
+        return [a.risk_level for a in self.schedule.agents]
+
+    @property
+    def max_agent_wealth(self):
+        # what is the current largest wealth of any agent?
+        return max([a.wealth for a in self.schedule.agents])
+
+    @property
+    def risk_median(self):
+        # calculate median of current agent risk levels
+        if self.agent_risk_levels:
+            # occasionally this complains about an empty list
+            # hopefully only possible in unit tests...
+            return statistics.median(self.agent_risk_levels)
+
+    @property
+    def risk_mean(self):
+        return statistics.mean(self.agent_risk_levels)
+
+    @property
+    def risk_min(self):
+        return min(self.agent_risk_levels)
+
+    @property
+    def risk_max(self):
+        return max(self.agent_risk_levels)
+
+    @property
+    def risk_q1(self):
+        risk_median = self.risk_median
+        # first quartile is the median of values less than the median
+        submedian_values = [r for r in self.agent_risk_levels if r < risk_median]
+        if submedian_values:
+            return statistics.median(submedian_values)
+
+    @property
+    def risk_q3(self):
+        risk_median = self.risk_median
+        # third quartile is the median of values greater than the median
+        supermedian_values = [r for r in self.agent_risk_levels if r > risk_median]
+        if supermedian_values:
+            return statistics.median(supermedian_values)

simulatingrisk/risky_bet/run.py

@@ -0,0 +1,46 @@
+import mesa
+
+from simulatingrisk.risky_bet.model import RiskyBetModel, divergent_colors
+from simulatingrisk.risky_bet.server import agent_portrayal, grid_size, model_params
+from simulatingrisk.charts.histogram import RiskHistogramModule, risk_bins
+from simulatingrisk.utils import labelLabel
+
+grid = mesa.visualization.CanvasGrid(agent_portrayal, grid_size, grid_size, 500, 500)
+
+
+risk_chart = mesa.visualization.ChartModule(
+    labelLabel(
+        [
+            {"Label": "risk_min", "Color": divergent_colors[0]},
+            {"Label": "risk_q1", "Color": divergent_colors[3]},
+            {"Label": "risk_mean", "Color": divergent_colors[5]},
+            {"Label": "risk_q3", "Color": divergent_colors[7]},
+            {"Label": "risk_max", "Color": divergent_colors[-1]},
+        ]
+    ),
+    data_collector_name="datacollector",
+    canvas_height=100,
+)
+
+world_chart = mesa.visualization.ChartModule(
+    labelLabel(
+        [
+            {"Label": "prob_risky_payoff", "Color": "gray"},
+            {"Label": "risky_bet", "Color": "blue"},
+        ]
+    ),
+    data_collector_name="datacollector",
+    canvas_height=100,
+)
+
+
+histogram = RiskHistogramModule(risk_bins, 175, 500, "risk levels")
+
+server = mesa.visualization.ModularServer(
+    RiskyBetModel,
+    [grid, histogram, world_chart, risk_chart],
+    "Risky Bet Simulation",
+    model_params=model_params,
+)
+server.port = 8521  # The default
+server.launch()

simulatingrisk/risky_bet/server.py

@@ -0,0 +1,102 @@
+import math
+
+import mesa
+from simulatingrisk.risky_bet.model import divergent_colors
+
+
+def risk_index(risk_level):
+    """Calculate a risk bin index for a given risk level.
+    Risk levels range from 0.0 to 1.0,
+    Implement eleven bins, with bins for 0 - 0.05 and 0.95 - 1.0,
+    since risk = 0, 0.5, and 1 are all special cases we want clearly captured.
+    """
+    # implementation adapted from https://stackoverflow.com/a/64995801/9706217
+
+    # if we think of it as a range from -0.05 to 1.05,
+    # then we can work with evenly sized 0.1 bins
+    minval = -0.05
+    binwidth = 0.1
+    nbins = 11
+    # Determine which bin this risk level belongs in
+    binnum = int((risk_level - minval) // binwidth)  # // = floor division
+    # convert bin number to 0-based index
+    return min(nbins - 1, binnum)
+
+
+def agent_portrayal(agent):
+    # initial display
+    portrayal = {
+        # styles for mesa runserver
+        "Shape": "circle",
+        "Color": "gray",
+        "Filled": "true",
+        "Layer": 0,
+        "r": 0.5,
+        # styles for solara / jupyterviz
+        "size": 25,
+        "color": "tab:gray",
+    }
+
+    # color based on risk level, with ten bins
+    # convert 0.0 to 1.0 to 1 - 10
+    color_index = math.floor(agent.risk_level * 10)
+    portrayal["color"] = "%s" % divergent_colors[color_index]
+    # runserver requires uppercase; duplicate for now
+    portrayal["Color"] = portrayal["color"]
+
+    # size based on wealth within current distribution
+    max_wealth = agent.model.max_agent_wealth
+    wealth_index = math.floor(agent.wealth / max_wealth * 10)
+    # set radius based on wealth, but don't go smaller than 1 radius
+    # or too large to fit in the grid
+    portrayal["r"] = (wealth_index / 15) + 0.1
+    # size for solara / jupyterviz
+    portrayal["size"] = (wealth_index / 15) * 50
+
+    # TODO: change shape based on number of times risk level has been adjusted?
+    # can't find a list of available shapes; setting to triangle and square
+    # results in a 404 for a local custom url
+    # NOTE: matplotlib scatter supports different shapes/markers,
+    # but not in a single scatter plot; would need to be plotted in groups
+
+    return portrayal
+
+
+grid_size = 20
+
+
+# make model parameters user-configurable
+model_params = {
+    "grid_size": grid_size,  # mesa.visualization.StaticText(value=grid_size),
+    # "grid_size": mesa.visualization.Slider(
+    #     "Grid size",
+    #     value=20,
+    #     min_value=10,
+    #     max_value=100,
+    #     description="Grid dimension (n*n = number of agents)",
+    # ),
+    "risk_adjustment": mesa.visualization.Choice(
+        "Risk adjustment strategy",
+        value="adopt",
+        choices=["adopt", "average"],
+        description="How agents update their risk level",
+    ),
+}
+
+jupyterviz_params = {
+    # "grid_size": grid_size,
+    "grid_size": {
+        "type": "SliderInt",
+        "value": 20,
+        "label": "Grid Size",
+        "min": 10,
+        "max": 100,
+        "step": 1,
+    },
+    "risk_adjustment": {
+        "type": "Select",
+        "value": "adopt",
+        "values": ["adopt", "average"],
+        "description": "How agents update their risk level",
+    },
+}

simulatingrisk/risky_food/README.md

@@ -0,0 +1,32 @@
+# Risky Food Simulation
+
+## Summary
+
+Game: risky food source is 3 if **N**, 1 if **C**; safe source is 2
+
+- **N**: non-contaminated 
+- **C**: contaminated
+
+Every agent gets a parameter `r` between 0 and 1.  [or DISCRETE: 8 buckets etc.]
+
+EACH ROUND:
+- Nature selects a probability `p` for **N**
+- For each agent: if `r` > `p`, then they choose RISKY; else SAFE
+- Nature flips a coin with bias `p` for **N**, and announces **N** or **C**
+- If **N**: everyone who chose RISKY gets 3, everyone who chose SAFE gets 2
+- If **C**: everyone who chose RISKY gets 1, everyone SAFE 2
+- Reproduce in proportion to payoff
+  - Either agent gets # of offspring = payoff [they replace–original “dies off”]
+  - OR: take the total payoff for RISKYs over total for everyone, there are that proportion of RISKYs in the new population
+
+END ROUND
+
+SEE: We’ll see what are the risk attitudes that are replicated more and less over time
+
+## Running the simulation
+
+- Install python dependencies as described in the main project readme (requires mesa)
+- To run from the main `simulating-risk` project directory: 
+	- Configure python to include the current directory in import path; 
+	  for C-based shells, run `setenv PYTHONPATH .` ; for bash, run `export $PYTHONPATH=.`
+	- To run interactively with mesa runserver: `mesa runserver simulatingrisk/risky_food/`

simulatingrisk/risky_food/app.py

@@ -0,0 +1,19 @@
+# solara/jupyterviz app
+from mesa.experimental import JupyterViz
+
+from simulatingrisk.risky_food.model import RiskyFoodModel
+from simulatingrisk.risky_food.server import (
+    jupyterviz_params,
+    plot_total_agents,
+)
+from simulatingrisk.charts.histogram import plot_risk_histogram
+
+page = JupyterViz(
+    RiskyFoodModel,
+    jupyterviz_params,
+    measures=[plot_total_agents, plot_risk_histogram],
+    name="Risky Food",
+    space_drawer=False,  # no agent portrayal because this model does not use a grid
+)
+# required to render the visualization with Jupyter/Solara
+page

simulatingrisk/risky_food/model.py

@@ -0,0 +1,250 @@
+from collections import defaultdict
+from enum import Enum
+from functools import cached_property
+from statistics import mean
+
+import mesa
+
+from simulatingrisk.utils import coinflip
+
+
+class FoodChoice(Enum):
+    RISKY = "R"
+    SAFE = "S"
+
+
+class FoodStatus(Enum):
+    CONTAMINATED = "C"
+    NOTCONTAMINATED = "N"
+
+
+class Agent(mesa.Agent):
+    def __init__(self, unique_id, model, risk_level=None):
+        super().__init__(unique_id, model)
+        # get a random risk tolerance; returns a value between 0.0 and 1.0
+        if risk_level is None:  # only set randomly if None; allow zero risk
+            risk_level = self.random.random()
+        self.risk_level = risk_level
+        self.choice = None
+
+    def __repr__(self):
+        return f"<RiskyFoodAgent id={self.unique_id} risk_level={self.risk_level}>"
+
+    def step(self):
+        # choose food based on the probability not contaminated and risk tolerance
+        # lower risk level = risk seeking
+        # higher = risk averse
+        #   risk level 1.0 should always choose safe (not strictly greater)
+        if self.model.prob_notcontaminated > self.risk_level:
+            self.choice = FoodChoice.RISKY
+        else:
+            self.choice = FoodChoice.SAFE
+        self.payoff = self.model.payoff(self.choice)
+
+
+class RiskyFoodModel(mesa.Model):
+    prob_notcontaminated = None
+    running = True  # required for batch running
+
+    def __init__(self, n=110, mode="types"):
+        super().__init__()
+        self.num_agents = n
+        self.mode = mode
+        self.schedule = mesa.time.SimultaneousActivation(self)
+        # initialize agents for the first round
+
+        # when mode is types, initialize 10 agents each of 11 risk types
+        if mode == "types":
+            # currently ignores n...
+            # maybe n could be n per type when mode is types
+            for i in range(11):
+                risk_level = i / 10  # 0, 0.1, 0.2, 0.3, ... 1.0
+                for j in range(10):
+                    # agents need unique ids;
+                    # create them from type & index
+                    agent_id = f"{i}-{j}"
+                    a = Agent(agent_id, self, risk_level=risk_level)
+                    self.schedule.add(a)
+
+        else:
+            # when mode is not types, initialize risk level randomly
+            for i in range(self.num_agents):
+                a = Agent(i, self)
+                self.schedule.add(a)
+
+        self.nextid = self.num_agents + 1
+
+        model_data = {
+            "prob_notcontaminated": "prob_notcontaminated",
+            "contaminated": "contaminated",
+            "average_risk_level": "avg_risk_level",
+            "min_risk_level": "min_risk_level",
+            "max_risk_level": "max_risk_level",
+            "num_agents": "total_agents",
+        }
+        # # report percent agents by risk level
+        # for i in range(11):
+        #     risk_level = i / 10
+        #     model_data["pct_r%.1f" % risk_level] = lambda m: m.percent_agents_risk(
+        #         risk_level
+        #     )
+
+        self.datacollector = mesa.DataCollector(
+            model_reporters=model_data,
+            agent_reporters={"risk_level": "risk_level", "payoff": "payoff"},
+        )
+
+    def step(self):
+        """Advance the model by one step."""
+        # pick a probability for risky food being not contaminated this round
+        self.prob_notcontaminated = self.random.random()
+
+        self.risky_food_status = self.get_risky_food_status()
+
+        self.schedule.step()
+        self.datacollector.collect(self)
+
+        # setup agents for the next round
+        self.propagate()
+
+        # delete cached property before the next round
+        del self.agent_risk_levels
+
+    def get_risky_food_status(self):
+        # determine actual food status for this round,
+        # weighted by probability of non-contamination
+
+        # randomly choose status, with first choice weighted by
+        # current probability not contaminated
+        return coinflip(
+            choices=[FoodStatus.NOTCONTAMINATED, FoodStatus.CONTAMINATED],
+            weight=self.prob_notcontaminated,
+        )
+
+    def propagate(self):
+        # update agents based on payoff from the completed round
+
+        # when mode is types, payoff is based on number of each type of agent
+        if self.mode == "types":
+            self.propagate_types()
+            return
+
+        # otherwise, use previous logic
+
+        # get a generator of agents from the scheduler that
+        # will allow us to add and remove
+        for agent in self.schedule.agents:
+            # add offspring based on payoff; keep risk level
+            # logic is offspring = to payoff, original dies off,
+            # but for efficiency just add payoff - 1 and keep the  original
+            for i in range(agent.payoff - 1):
+                a = Agent(i + self.nextid, self, risk_level=agent.risk_level)
+                self.schedule.add(a)
+
+            self.nextid = self.total_agents + 1
+
+    def propagate_types(self):
+        for risk_level, agents in self.agents_by_risktype.items():
+            # adjust population based on payoff and number of agents
+            total = len(agents)
+            # calculate number of agents of this type for next round
+            # - convert to int so we can use for array slicing
+            new_total = int((total * agents[0].payoff) / 2)
+
+            # if new total is less, remove agents over the expected total
+            for agent in agents[new_total:]:
+                self.schedule.remove(agent)
+            # if new total is more, add new agents with same risk level
+            if new_total > total:
+                for i in range(new_total - total):
+                    a = Agent(self.nextid, self, risk_level)
+                    self.schedule.add(a)
+                    self.nextid += 1
+
+    @property
+    def contaminated(self):
+        # return a value for food status this round, for data collection
+        if self.risky_food_status == FoodStatus.CONTAMINATED:
+            return 1
+        return 0
+
+    @property
+    def agents(self):
+        # custom property to make it easy to access all current agents
+
+        # uses a generator of agents from the scheduler that
+        # will allow adding and removing agents from the scheduler
+        return self.schedule.agents
+
+    @property
+    def total_agents(self):
+        return self.schedule.get_agent_count()
+
+    def total_agents_risk(self, risk_level):
+        # total number of agents with a particular risk level
+        return len(self.agents_by_risktype[risk_level])
+        # return len([a for a in self.agents if a.risk_level == risk_level])
+
+    def percent_agents_risk(self, risk_level):
+        # # percent of agents with a particular risk level
+        risk_total = self.total_agents_risk(risk_level)
+        # print(
+        #     "risk %s total %s total agents %d percent %s"
+        #     % (
+        #         risk_level,
+        #         risk_total,
+        #         self.total_agents,
+        #         (risk_level / self.total_agents) * 100,
+        #     )
+        # )
+        return (risk_total / self.total_agents) * 100
+
+    @property
+    def agents_by_risktype(self):
+        # group agents by risk level for propagation
+        agents = defaultdict(list)
+        for a in self.agents:
+            agents[a.risk_level].append(a)
+        return agents
+
+    @cached_property
+    def agent_risk_levels(self) -> [float]:
+        # list of all risk levels for all current agents;
+        # property is cached but should be cleared in each new round
+
+        # NOTE: occasionally median method is complaining that this is empty
+        return [a.risk_level for a in self.agents]
+
+    @property
+    def avg_risk_level(self):
+        return mean(self.agent_risk_levels)
+
+    @property
+    def min_risk_level(self):
+        return min(self.agent_risk_levels)
+
+    @property
+    def max_risk_level(self):
+        return max(self.agent_risk_levels)
+
+    payoffs = {
+        "range": {"safe": 2, "not_contaminated": 3, "contaminated": 1},
+        "types": {"safe": 2, "not_contaminated": 4, "contaminated": 1},
+    }
+
+    def payoff(self, choice):
+        "Calculate the payoff for a given choice, based on current food status"
+
+        # safe food choice always has a payoff of 2
+        if choice == FoodChoice.SAFE:
+            # return 2
+            return self.payoffs[self.mode]["safe"]
+        # payoff for risky food choice depends on contamination
+        # - if not contaminated, payoff of 3
+        if self.risky_food_status == FoodStatus.NOTCONTAMINATED:
+            # return 3
+            return self.payoffs[self.mode]["not_contaminated"]
+
+        # otherwise only payoff of 1
+        return self.payoffs[self.mode]["contaminated"]
+        # return 1