simulatingrisk 1.0.0__py3-none-any.whl

simulatingrisk/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

simulatingrisk/about_app.md

@@ -0,0 +1,2 @@
+
+These simulations are associated with the CDH project [Simulating risk, risking simulations](https://cdh.princeton.edu/projects/simulating-risk/).

simulatingrisk/app.py

@@ -0,0 +1,50 @@
+import os.path
+
+import solara
+
+from simulatingrisk.hawkdove.app import page as hawkdove_page
+from simulatingrisk.hawkdovemulti.app import page as hawkdove_multi_page
+from simulatingrisk.risky_bet.app import page as riskybet_page
+from simulatingrisk.risky_food.app import page as riskyfood_page
+
+
+@solara.component
+def Home():
+    # load about markdown file in the same directory
+    with open(os.path.join(os.path.dirname(__file__), "about_app.md")) as readmefile:
+        return solara.Markdown("\n".join(readmefile.readlines()))
+
+
+@solara.component
+def hawkdove():
+    return hawkdove_page
+
+
+@solara.component
+def hawkdove_multi():
+    return hawkdove_multi_page
+
+
+@solara.component
+def riskybet():
+    return riskybet_page
+
+
+@solara.component
+def riskyfood():
+    return riskyfood_page
+
+
+routes = [
+    solara.Route(path="/", component=Home, label="Simulating Risk"),
+    solara.Route(
+        path="hawkdove-single", component=hawkdove, label="Hawk/Dove (single r)"
+    ),
+    solara.Route(
+        path="hawkdove-multiple",
+        component=hawkdove_multi,
+        label="Hawk/Dove (multiple r)",
+    ),
+    solara.Route(path="riskybet", component=riskybet, label="Risky Bet"),
+    solara.Route(path="riskyfood", component=riskyfood, label="Risky Food"),
+]

simulatingrisk/batch_run.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+
+import argparse
+import csv
+from datetime import datetime
+
+from mesa import batch_run
+
+from simulatingrisk.hawkdove.model import HawkDoveSingleRiskModel
+from simulatingrisk.hawkdovemulti.model import HawkDoveMultipleRiskModel
+from simulatingrisk.risky_bet.model import RiskyBetModel
+from simulatingrisk.risky_food.model import RiskyFoodModel
+
+
+def riskybet_batch_run(args=None):
+    results = batch_run(
+        RiskyBetModel,
+        parameters={
+            "grid_size": 30,  # [20, 30],  # 100],
+            # "risk_adjustment": ["adopt", "average"],
+            "risk_adjustment": "adopt",
+        },
+        iterations=5,
+        # TODO: vary how often they update strategy
+        # every 100, every 1 round?
+        max_steps=3000,  # at least 1000, maybe more to see where it converges
+        # try 10k to see
+        # add logic on the model to stop if risk levels converge to 90% in one bin
+        number_processes=1,  # set None to use all available; set 1 for jupyter
+        data_collection_period=1,
+        display_progress=True,
+    )
+    # returns a list of dictionaries from data collection across all runs
+    save_results("riskybet", results)
+
+
+def riskyfood_batch_run(args=None):
+    results = batch_run(
+        RiskyFoodModel,
+        # only parameter to this one currently is number of agents
+        parameters={"n": 110, "mode": "types"},
+        iterations=5,  # this one is faster, could run more iterations
+        max_steps=1000,
+        number_processes=1,  # set None to use all available; set 1 for jupyter
+        data_collection_period=1,
+        display_progress=True,
+    )
+    save_results("riskyfood", results)
+
+
+def hawkdove_singlerisk_batch_run(args):
+    # params are:
+    # grid_size,
+    # include_diagonals=True,
+    # agent_risk_level=None,
+    # hawk_odds=0.5,
+
+    params = {
+        "grid_size": 20,
+        "agent_risk_level": [0, 1, 2, 3, 4, 5, 6, 7, 8],
+    }
+    iterations = 1
+
+    results = batch_run(
+        HawkDoveSingleRiskModel,
+        # when including diagonals, risk levels go from 0 to 8;
+        # probably do not need to include the extremes for this analysis
+        parameters=params,
+        iterations=iterations,
+        number_processes=1,
+        data_collection_period=1,
+        display_progress=True,
+        max_steps=200,  # converges very quickly, so don't run 1000 times
+    )
+    # include the mode in the output filename
+    save_results("hawkdove_single", results)
+
+
+def hawkdove_multiplerisk_batch_run(args):
+    params = {
+        "grid_size": 10,
+        "risk_adjustment": "adopt",  # run adopt only for now
+    }
+    iterations = 100
+    results = batch_run(
+        HawkDoveMultipleRiskModel,
+        parameters=params,
+        iterations=iterations,
+        number_processes=1,
+        data_collection_period=1,
+        display_progress=True,
+        max_steps=250,  # converges fairly quickly, don't run 1000 times
+    )
+    # include the mode in the output filename
+    save_results("hawkdove_multiple", results)
+
+
+def save_results(simulation, results):
+    # save as csv for external analysis
+    # - use datetime to distinguish this run, but make nicer for filename
+    datestr = datetime.today().isoformat().replace(".", "_").replace(":", "")
+    output_filename = "%s_%s.csv" % (simulation, datestr)
+    print("Saving data collection results to: %s" % output_filename)
+    # get field names from last entry, since first entry is for the model
+    # and doesn't include agent-level data
+    fields = results[-1].keys()
+    with open(output_filename, "w", newline="") as output_file:
+        dict_writer = csv.DictWriter(output_file, fields)
+        dict_writer.writeheader()
+        dict_writer.writerows(results)
+
+    return output_filename
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog="simulatingrisk batch_run",
+        description="Run simulations in batch mode and save collected data",
+    )
+    # use subcommands so we can add model-specific options
+    subparsers = parser.add_subparsers(help="Help for model-specific options")
+    riskybet_parser = subparsers.add_parser("riskybet")
+    riskybet_parser.set_defaults(func=riskybet_batch_run)
+    riskyfood_parser = subparsers.add_parser("riskyfood")
+    riskyfood_parser.set_defaults(func=riskyfood_batch_run)
+    hawkdove_parser = subparsers.add_parser("hawkdove-single")
+    # will any subparser arguments be needed in future?
+    # hawkdove_parser.add_argument(
+    #     "-r",
+    #     "--risk-attitudes",
+    #     choices=["single", "variable"],
+    #     help="Mode for initializing agent risk attitudes",
+    # )
+    hawkdove_parser.set_defaults(func=hawkdove_singlerisk_batch_run)
+    hawkdove_multi_parser = subparsers.add_parser("hawkdove-multi")
+    hawkdove_multi_parser.set_defaults(func=hawkdove_multiplerisk_batch_run)
+
+    args = parser.parse_args()
+    # run appropriate function based on the selected subcommand
+    # if a subcommand is not specified, no function is set
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
+        exit(-1)

simulatingrisk/charts/histogram.js

@@ -0,0 +1,51 @@
+const HistogramModule = function(bins, canvas_width, canvas_height, label) {
+   // Create the canvas object:
+    const canvas = document.createElement("canvas");
+    Object.assign(canvas, {
+      width: canvas_width,
+      height: canvas_height,
+      style: "border:1px dotted",
+    });
+  // Append it to #elements:
+  const elements = document.getElementById("elements");
+  elements.appendChild(canvas);
+
+  // Create the context and the drawing controller:
+  const context = canvas.getContext("2d");
+
+  // Prep the chart properties and series:
+  const datasets = [{
+    label: label,
+    fillColor: "rgba(151,187,205,0.5)",
+    strokeColor: "rgba(151,187,205,0.8)",
+    highlightFill: "rgba(151,187,205,0.75)",
+    highlightStroke: "rgba(151,187,205,1)",
+    data: []
+  }];
+
+  // Add a zero value for each bin
+  for (var i in bins)
+    datasets[0].data.push(0);
+
+  const data = {
+    labels: bins,
+    datasets: datasets
+  };
+
+  const options = {
+    scaleBeginsAtZero: true
+  };
+
+  // Create the chart object
+  let chart = new Chart(context, {type: 'bar', data: data, options: options});
+
+this.render = function(data) {
+    datasets[0].data = data;
+    chart.update();
+  };
+
+  this.reset = function() {
+    chart.destroy();
+    chart = new Chart(context, {type: 'bar', data: data, options: options});
+  };
+};

simulatingrisk/charts/histogram.py

@@ -0,0 +1,72 @@
+import os
+
+import numpy as np
+import solara
+from matplotlib.figure import Figure
+
+
+from mesa.visualization.ModularVisualization import VisualizationElement, CHART_JS_FILE
+
+
+# histogram chart from mesa tutorial
+# https://mesa.readthedocs.io/en/stable/tutorials/adv_tutorial_legacy.html
+class HistogramModule(VisualizationElement):
+    """histogram plot of agent risk levels; for use with mesa runserver"""
+
+    package_includes = [CHART_JS_FILE]
+    local_includes = ["histogram.js"]
+    # javascript is located in the same file as this python file
+    local_dir = os.path.dirname(os.path.realpath(__file__))
+
+    def __init__(self, bins, canvas_height, canvas_width, label, agent_attr):
+        self.canvas_height = canvas_height
+        self.canvas_width = canvas_width
+        self.bins = bins
+        self.agent_attr = agent_attr
+        new_element = "new HistogramModule({}, {}, {}, {})"
+        new_element = new_element.format(
+            bins, canvas_width, canvas_height, '"%s"' % label
+        )
+        self.js_code = "elements.push(" + new_element + ");"
+
+    def render(self, model):
+        agent_values = [
+            getattr(agent, self.agent_attr) for agent in model.schedule.agents
+        ]
+        # generate a histogram of risk levels based on the specified bins
+        hist = np.histogram(agent_values, bins=self.bins)[0]
+        return [int(x) for x in hist]
+
+
+class RiskHistogramModule(HistogramModule):
+    """special case: risk_level histogram"""
+
+    def __init__(self, bins, canvas_height, canvas_width, label="risk levels"):
+        super().__init__(
+            bins, canvas_height, canvas_width, label, agent_attr="risk_level"
+        )
+
+
+# generate bins for histogram, capturing 0-0.5 and 0.95-1.0
+risk_bins = []
+r = 0.05
+while r < 1.05:
+    risk_bins.append(round(r, 2))
+    r += 0.1
+
+
+def plot_risk_histogram(model):
+    """histogram plot of agent risk levels; for use with jupyterviz/solara"""
+
+    # adapted from mesa visualiation tutorial
+    # https://mesa.readthedocs.io/en/stable/tutorials/visualization_tutorial.html#Building-your-own-visualization-component
+
+    # Note: per Mesa docs, has to be initialized using this method instead of
+    # plt.figure(), for thread safety purpose
+    fig = Figure()
+    ax = fig.subplots()
+    # generate a histogram of current risk levels
+    risk_levels = [agent.risk_level for agent in model.schedule.agents]
+    ax.hist(risk_levels, bins=risk_bins)
+    ax.set_title("risk levels")
+    solara.FigureMatplotlib(fig)

simulatingrisk/hawkdove/README.md

@@ -0,0 +1,106 @@
+# Hawk-Dove with risk attitudes
+
+Hawk/Dove game with risk attitudes
+
+## Game description
+
+This is a variant of the Hawk/Dove Game: https://en.wikipedia.org/wiki/Chicken_(game)
+
+| | H | D|
+|-|-|-|
+| H | 0, 0 | 3, 1|
+| D |1, 3| 2, 2|
+
+BACKGROUND: An unpublished paper by Simon Blessenohl shows that the equilibrium in this game is different for EU maximizers than for REU maximizers (all with the same risk-attitude), and that REU maximizers do better as a population (basically, play DOVE more often)
+
+We want to know: what happens when different people have _different_ risk-attitudes.
+(See also variant simulation [Hawk/Dove game with multiple risk attitudes](../hawkdovemulti/). )
+
+GAME: Hawk-Dove with risk-attitudes
+
+Players arranged on a lattice [options for both 4 neighbors (AYBD) and 8 neighbors (XYZABCDE)]
+
+| | | |
+|-|-|-|
+| X | Y |Z |
+|A | **I** |  B |
+| C | D | E |
+
+- Payoffs are determined as follows:
+   -  Look at what each neighbor did, then:
+   -  If I play HAWK and neighbor plays DOVE: 3
+   -  If I play DOVE and neighbor plays DOVE: 2
+   -  If I play DOVE and neighbor plays HAWK: 1
+   - If I play HAWK and neighbor plays HAWK: 0
+
+Each player on a lattice (grid in Mesa):
+- Has parameter $r$ [from 0 to 9]
+- Let `d` be the number of neighbors who played DOVE during the previous round. If $d >= r$, then play HAWK. Otherwise play DOVE. (Agents who are risk-avoidant only play HAWK if there are a lot of doves around them. More risk-avoidance requires a higher number of doves to get an agent to play HAWK.)
+- The proportion of neighbors who play DOVE corresponds to your probability of encountering a DOVE when playing a randomly-selected neighbor. The intended interpretation is that you maximize REU for this probability of your opponent playing DOVE. Thus, $r$ corresponds to the probability above which playing HAWK maximizes REU.
+  - Choice of play for the first round:
+    - Who is a HAWK and who is a DOVE is randomly determined; proportion set at the beginning of each simulation. E.g. 30% are HAWKS; if we have 100 players, then each player has a 30% chance of being HAWK;
+   - This initial parameter is called HAWK-ODDS; default is 50/50
+
+
+## Payoffs and risk attitudes
+
+This game has a discrete set of options instead of probability, so instead of defining `r` as a value between 0.0 and 1.0, we use discrete values based on the choices. For the game that includes diagonal neighbors when agents play all neighbors:
+
+<table>
+   <tr><th>r</th></th><th>0</th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th><th>7</th><th>8</th><th>9</th></tr>
+   <tr>
+      <th>Plays H when:</th>
+      <td>always</td>
+      <td>$\geq1$ D</td>
+      <td>$\geq2$ D</td>
+      <td>$\geq3$ D</td>
+      <td>$\geq4$ D</td>
+      <td>$\geq5$ D</td>
+      <td>$\geq6$ D</td>
+      <td>$\geq7$ D</td>
+      <td>$\geq8$ D</td>
+      <td>never</td>
+   </tr>
+   <tr><td></td>
+      <td colspan="4">risk seeking</td>
+      <td>EU maximizer<br>(risk neutral)</td>
+      <td>EU maximizer<br>(risk neutral)</td>
+   <td colspan="4">risk avoidant</td>
+   </tr>
+</table>
+
+
+An REU maximizer will play HAWK when
+```math
+r(p) > \frac{(D,H)-(H,H)}{(H,D)-(D,D)}
+```
+In other words, when $r(p) > 0.52$. An EU maximizer, with $r(p) = p$, will play HAWK when $p > 0.52$, e.g., when more than 4 out of 8 neighbors play DOVE. Thus, $r = 4$ corresponds to risk-neutrality (EU maximization), $r < 4$ corresponds to risk-inclination, and $r > 4$ corresponds to risk-avoidance.
+
+Payoffs were chosen to avoid the case in which two choices had equal expected utility for some number of neighbors. For example, if the payoff of $(D,D)$ was $(2,2)$, then at $p = 0.5$ (4 of 8 neighbors), then EU maximizers would be indifferent between HAWK and DOVE; in this case, no r-value would correspond to EU maximization, since $r = 4$ strictly prefers DOVE and $r = 3$ strictly prefers HAWK.
+
+Another way to visualize the risk attitudes and choices in this game is this table, which shows when agents will play Hawk or Dove based on their risk attitudes (going down on the left side) and the number of neighbors playing Dove (across the top).
+
+<table>
+   <tr><td colspan="2"></td><th colspan="9"># of neighors playing DOVE</thr></tr>
+   <tr><td><th>r</th><td>0</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr>
+   <tr><td rowspan="4">risk seeking</td><th>0</th><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><th>1</th><td>D</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><th>2</th><td>D</td><td>D</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><th>3</th><td>D</td><td>D</td><td>D</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><td rowspan="2">neutral</td></td><th>4</th><td>D</td><td>D</td><td>D</td><td>D</td><td>H</td><td>H</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><th>5</th><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>H</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><td rowspan="4">risk avoidant</td><th>6</th><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>H</td><td>H</td><td>H</td></tr>
+   <tr><th>7</th><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>H</td><td>H</td></tr>
+   <tr><th>8</th><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>H</td></tr>
+   <tr><th>9</th><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td><td>D</td></tr>
+</table>
+
+## Convergence
+
+The model is configured to stop automatically when it has stabilized. Convergence is based on a stable rolling average of the percent of agents in the simulation playing hawk.
+
+A rolling average of the percent of agents playing hawk is calculated every round based on the percent for the last **30** rounds.  The rolling average is not calculated until after at least **15** rounds.
+
+When we have collected the rolling average for at least **15** rounds and the last **30** rolling averages are the same when rounded to 2 percentage points, we consider the simulation converged.
+
+

simulatingrisk/hawkdove/app.py

@@ -0,0 +1,90 @@
+# solara/jupyterviz app
+from mesa.experimental import JupyterViz
+import pandas as pd
+import altair as alt
+import solara
+
+
+from simulatingrisk.hawkdove.model import HawkDoveSingleRiskModel
+from simulatingrisk.hawkdove.server import (
+    agent_portrayal,
+    jupyterviz_params,
+    draw_hawkdove_agent_space,
+)
+
+
+def plot_wealth(model):
+    """histogram plot of agent wealth levels across risk levels;
+    for use with jupyterviz/solara"""
+
+    # generate a histogram of points across risk levels
+    risk_wealth = [(agent.risk_level, agent.points) for agent in model.schedule.agents]
+    df = pd.DataFrame(risk_wealth, columns=["risk_level", "wealth"])
+
+    chart = (
+        alt.Chart(df)
+        .mark_bar()
+        .encode(y="wealth", x=alt.X("risk_level", title="risk attitude"))
+    )
+    return solara.FigureAltair(chart)
+
+
+def plot_hawks(model):
+    """plot percent of agents who chose hawk over last several rounds;
+    for use with jupyterviz/solara"""
+
+    model_df = model.datacollector.get_model_vars_dataframe().reset_index()
+
+    # limit to last N rounds (how many ?)
+    last_n_rounds = model_df.tail(50)
+    # determine domain of the chart;
+    # starting domain 0-50 so it doesn't jump / expand as much
+    max_index = max(model_df.last_valid_index() or 0, 50)
+    min_index = max(max_index - 50, 0)
+
+    bar_chart = (
+        alt.Chart(last_n_rounds)
+        .mark_bar(color="orange")
+        .encode(
+            x=alt.X(
+                "index", title="Step", scale=alt.Scale(domain=[min_index, max_index])
+            ),
+            y=alt.Y(
+                "percent_hawk",
+                title="Percent who chose hawk",
+                scale=alt.Scale(domain=[0, 1]),
+            ),
+        )
+    )
+    # graph rolling average as a line over the bar chart,
+    # once we have enough rounds
+    if model_df.rolling_percent_hawk.any():
+        line = (
+            alt.Chart(last_n_rounds)
+            .mark_line(color="blue")
+            .encode(
+                x=alt.X("index", title="Step"),
+                y=alt.Y(
+                    "rolling_percent_hawk",
+                    title="% hawk (rolling average)",
+                    scale=alt.Scale(domain=[0, 1]),
+                ),
+            )
+        )
+        # add the rolling average line on top of the bar chart
+        bar_chart += line
+
+    return solara.FigureAltair(bar_chart)
+
+
+page = JupyterViz(
+    HawkDoveSingleRiskModel,
+    jupyterviz_params,
+    measures=[plot_hawks],
+    name="Hawk/Dove game with risk attitudes; all agents have the same risk attitude",
+    agent_portrayal=agent_portrayal,
+    space_drawer=draw_hawkdove_agent_space,
+)
+
+# required to render the visualization with Jupyter/Solara
+page