simulatingrisk 1.0.0__py3-none-any.whl

simulatingrisk/risky_food/run.py

@@ -0,0 +1,20 @@
+import mesa
+
+from simulatingrisk.risky_food.model import RiskyFoodModel
+from simulatingrisk.risky_food.server import (
+    chart,
+    risk_chart,
+    total_agent_chart,
+    histogram,
+)
+
+
+server = mesa.visualization.ModularServer(
+    RiskyFoodModel,
+    # [chart, risk_chart, agent_risk_chart, total_agent_chart],
+    [chart, risk_chart, total_agent_chart, histogram],
+    "Risky Food",
+    {"n": 20, "mode": "types"},
+)
+server.port = 8521  # The default
+server.launch()

simulatingrisk/risky_food/server.py

@@ -0,0 +1,78 @@
+import mesa
+import solara
+from matplotlib.figure import Figure
+
+from simulatingrisk.charts.histogram import RiskHistogramModule
+from simulatingrisk.utils import labelLabel
+
+
+chart = mesa.visualization.ChartModule(
+    labelLabel(
+        [
+            {"Label": "prob_notcontaminated", "Color": "blue"},
+            {"Label": "contaminated", "Color": "red"},
+        ]
+    ),
+    data_collector_name="datacollector",
+    canvas_height=100,  # default height is 200
+)
+risk_chart = mesa.visualization.ChartModule(
+    labelLabel(
+        [
+            {"Label": "average_risk_level", "Color": "blue"},
+            {"Label": "min_risk_level", "Color": "green"},
+            {"Label": "max_risk_level", "Color": "orange"},
+        ]
+    ),
+    data_collector_name="datacollector",
+    canvas_height=100,
+)
+
+total_agent_chart = mesa.visualization.ChartModule(
+    labelLabel(
+        [
+            {"Label": "num_agents", "Color": "gray"},
+        ]
+    ),
+    data_collector_name="datacollector",
+    canvas_height=100,
+)
+
+
+# bins for risk levels to chart as histogram
+# match types used in the class, i.e. 0, 0.1, 0.2, 0.3, ... 1.0
+# NOTE: if we don't include 1.1, np.histogram groups 0.9 with 1.0
+risk_bins = [r / 10 for r in range(12)]
+histogram = RiskHistogramModule(risk_bins, 200, 500, "risk levels")
+
+# server is initialized in run.py
+# jupyterviz is initialized in app.py
+
+
+jupyterviz_params = {
+    "n": {
+        "type": "SliderInt",
+        "value": 20,
+        "label": "Number of starting agents",
+        "min": 10,
+        "max": 50,
+        "step": 1,
+    },
+    "mode": {
+        "type": "Select",
+        "value": "types",
+        "values": ["types", "random"],
+        "description": "Risk types of random risk level distribution",
+    },
+}
+
+
+def plot_total_agents(model):
+    """plot total agents over time to provide an indicator of population size"""
+    fig = Figure()
+    ax = fig.subplots()
+    # generate a line plot of total number of agents
+    model_df = model.datacollector.get_model_vars_dataframe()
+    ax.plot(model_df.num_agents)
+    ax.set_title("total agents")
+    solara.FigureMatplotlib(fig)

simulatingrisk/stag_hunt/README.md

@@ -0,0 +1,15 @@
+# Stag Hunt Simulation
+
+## Summary
+
+This is a preliminary, incomplete implementation of the Stag Hunt game, drawing on Skyrms' _The stag hunt and the evolution of social structure_ (2004).
+
+With the current implementation and payoff scheme, it converges to everyone hunting stag fairly quickly, and is probably not very interesting; but it may useful as a reference with mesa simulations, or for further refinement and experimentation.
+
+## 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/stag_hunt/`

simulatingrisk/stag_hunt/model.py

@@ -0,0 +1,123 @@
+from enum import Enum
+from functools import partial
+
+import mesa
+
+HuntChoice = Enum("Hunt", ["STAG", "HARE"])
+choices = [HuntChoice.STAG, HuntChoice.HARE]
+
+
+class StagHuntAgent(mesa.Agent):
+    """An hunter agent who hunts stag or hare."""
+
+    def __init__(self, unique_id, model):
+        super().__init__(unique_id, model)
+        # self.wealth = 1
+        # initialize hunt choice randomly for now
+        self.hunting = self.random.choices(list(HuntChoice), weights=[15, 85])[0]
+        # print("%s hunting %s" % (unique_id, self.hunting))
+        # self.hunting = self.random.choice(choices)
+        self.last_payoff = None
+
+    def payoff(self, other_agent):
+        # hunting hare has a payoff of 3 no matter what the other agent does
+        if self.hunting == HuntChoice.HARE:
+            return 3
+
+        # if both hunt stag, payoff is 4
+        if other_agent.hunting == HuntChoice.STAG:
+            return 4
+
+        # hunting stag alone payoff is zero
+        return 0
+
+    def get_neighbors(self):
+        # use moore neighborhood (include diagonals), don't include self
+        return self.model.grid.get_neighbors(self.pos, True, False)
+
+    def choose(self):
+        # decide on hunting strategy
+        # for first hunt, use initial strategy
+
+        # if this is not the first time hunting,
+        # compare our payoff to neighbors
+        if self.last_payoff is not None:
+            neighbors = self.get_neighbors()
+            # update strategy for next time based on neighbors
+            # sort neighbors by their last payoff
+            neighbor_success = sorted(
+                neighbors, key=lambda n: n.last_payoff, reverse=True
+            )
+            most_successful = neighbor_success[0]
+            if most_successful.last_payoff > self.last_payoff:
+                print(
+                    "most successful neighbor: %s payoff=%s hunting=%s"
+                    % (
+                        most_successful.unique_id,
+                        most_successful.last_payoff,
+                        most_successful.hunting,
+                    )
+                )
+                self.hunting = most_successful.hunting
+
+    def hunt(self):
+        # how to pair up agents? for now use random?
+
+        neighbors = self.get_neighbors()
+        # choose hunting partner from neighbors randomly
+        other_agent = self.random.choice(neighbors)
+
+        # other_agent = self.random.choice(self.model.schedule.agents)
+        self.last_payoff = self.payoff(other_agent)
+        # print("%s payoff %s" % (self.unique_id, self.last_payoff))
+
+
+def count_stag_hunters(model):
+    return len(
+        [agent for agent in model.schedule.agents if agent.hunting == HuntChoice.STAG]
+    )
+
+
+def num_hunting_choice(model, hunting):
+    return len(
+        [hunter for hunter in model.schedule.agents if hunter.hunting == hunting]
+    )
+
+
+class StagHuntModel(mesa.Model):
+    """A model with some number of stag-hunt agents."""
+
+    # def __init__(self, N):
+    # self.num_agents = N
+    def __init__(self, width, height):
+        self.num_agents = width * height
+        self.grid = mesa.space.SingleGrid(width, height, True)
+        self.schedule = mesa.time.StagedActivation(self, ["choose", "hunt"])
+        # Create agents
+        for i in range(self.num_agents):
+            a = StagHuntAgent(i, self)
+            self.schedule.add(a)
+            # place randomly in an empty spot
+            self.grid.move_to_empty(a)
+
+        # self.datacollector = mesa.DataCollector(
+        #     model_reporters={"stag hunters": count_stag_hunters},
+        #     agent_reporters={"Hunting": "hunting", "Payoff": "last_payoff"},
+        # )
+
+        self.datacollector = mesa.DataCollector(
+            model_reporters={
+                "stag_hunters": partial(
+                    num_hunting_choice, self, hunting=HuntChoice.STAG
+                ),
+                "hare_hunters": partial(
+                    num_hunting_choice, self, hunting=HuntChoice.HARE
+                ),
+            }
+        )
+        self.datacollector.collect(self)
+
+    def step(self):
+        """Advance the model by one step."""
+        self.datacollector.collect(self)
+        self.schedule.step()

simulatingrisk/stag_hunt/run.py

@@ -0,0 +1,45 @@
+import mesa
+from simulatingrisk.stag_hunt.model import StagHuntModel
+
+
+def agent_portrayal(agent):
+    # TODO: figure out where Mesa wants this import to happen
+    # (expects model and server nested deeper than run?)
+    from simulatingrisk.stag_hunt.model import HuntChoice
+
+    portrayal = {
+        "Shape": "circle",
+        "Color": "gray",
+        "Filled": "true",
+        "Layer": 0,
+        "r": 0.2,
+    }
+
+    if agent.hunting == HuntChoice.STAG:
+        portrayal["Color"] = "green"
+    else:
+        portrayal["Color"] = "blue"
+
+    if agent.last_payoff == 0:
+        portrayal["r"] = 0.2
+    elif agent.last_payoff == 3:
+        portrayal["r"] = 0.4
+    elif agent.last_payoff == 4:
+        portrayal["r"] = 0.7
+    return portrayal
+
+
+grid = mesa.visualization.CanvasGrid(agent_portrayal, 20, 20, 500, 500)
+chart = mesa.visualization.ChartModule(
+    [
+        {"Label": "stag_hunters", "Color": "green"},
+        {"Label": "hare_hunters", "Color": "blue"},
+    ],
+    data_collector_name="datacollector",
+)
+
+server = mesa.visualization.ModularServer(
+    StagHuntModel, [grid, chart], "Stag Hunt Model", {"width": 20, "height": 20}
+)
+server.port = 8521  # The default
+server.launch()

simulatingrisk/utils.py

@@ -0,0 +1,31 @@
+import random
+
+
+def coinflip(choices: [any, any] = [0, 1], weight: float = 0.5) -> any:
+    """Flip a coin with an optional weight between 0.0 and 1.0 for the
+    first choice. If no  weight is specified, a choice is made with
+    equal probability.
+
+    :param choices: list of coin flip options, defaults to [0, 1]
+    :type choices: [any, any] (optional)
+    :param weight: optional weight between 0.0-1.0 for the first
+        choice, defaults to 0.5
+    :type weight: float (optional)
+
+    :return: selected choice
+    :rtype: any
+    """
+    # adapted from https://stackoverflow.com/a/477248/9706217
+    # random.random is apparently faster than
+    selection = 0 if random.random() < weight else 1
+    return choices[selection]
+
+
+def labelLabel(fields):
+    # some kind of a bug in current (forked) version of Mesa or
+    # a conflict with tornado version on field labels;
+    # display is undefined without lowercase but server requires uppercase
+    # for now, just copy them
+    for item in fields:
+        item["label"] = item["Label"]
+    return fields

simulatingrisk-1.0.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: simulatingrisk
+Version: 1.0.0
+Summary: Agent-based modeling for simulations related to risk and rationality
+License: Apache-2
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: mesa==2.1.5
+Requires-Dist: matplotlib
+Requires-Dist: altair>5.0.1
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Provides-Extra: analysis
+Requires-Dist: jupyterlab; extra == "analysis"
+Requires-Dist: polars; extra == "analysis"
+Requires-Dist: hvplot; extra == "analysis"
+Requires-Dist: pyarrow; extra == "analysis"
+Requires-Dist: altair; extra == "analysis"
+Requires-Dist: scipy; extra == "analysis"
+Requires-Dist: scikit-learn; extra == "analysis"
+Requires-Dist: seaborn; extra == "analysis"
+Requires-Dist: vegafusion[embed]>=1.5.0; extra == "analysis"
+Requires-Dist: vl-convert-python; extra == "analysis"
+Requires-Dist: great-tables; extra == "analysis"
+Dynamic: license-file
+
+# Simulating Risk
+
+[![DH community code review: June 2024](https://img.shields.io/badge/DHCodeReview-June_2024-blue)](https://github.com/DHCodeReview/simulating-risk/pull/1) [![unit tests](https://github.com/Princeton-CDH/simulating-risk/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/Princeton-CDH/simulating-risk/actions/workflows/unit_tests.yml)
+
+The code in this repository is associated with the CDH project [Simulating risk, risking simulations](https://cdh.princeton.edu/projects/simulating-risk/).
+
+Simulations are implemented with [Mesa](https://mesa.readthedocs.io/en/stable/), using Agent Based Modeling to explore risk attitudes within populations.
+
+---- 
+
+## Simulations with agent interaction
+
+- [Hawk/Dove with risk attitudes](simulatingrisk/hawkdove)
+- [Hawk/Dove with multiple risk attitudes and adjustment](simulatingrisk/hawkdovemulti)
+
+The code for **Hawk/Dove with risk attitudes** and **Hawk/Dove with multiple risk attitudes** in this codebase was [reviewed](https://github.com/DHCodeReview/simulating-risk/pull/1) in June 2024 by [Scott Foster](https://github.com/sgfost) and [Malte Vogl](https://github.com/maltevogl) (Senior Research Fellow, Max Planck Institute of Geoanthropology) via [DHTech Community Code Review](https://dhcodereview.github.io/); review was faciliated by [Cole Crawford](https://github.com/ColeDCrawford) (Senior Software Engineer, Harvard Arts and Humanities Research Computing).
+
+
+View an interactive version of the [Hawk/Dove with multiple risk attitudes](https://py.cafe/rlskoeser/simulatingrisk-hawk-dove-multirisk) simulation online.
+
+The simulation can also be run in a Jupyter notebook: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Princeton-CDH/simulating-risk.git/HEAD?urlpath=%2Fdoc%2Ftree%2Fsimulatingrisk%2Fhawkdovemulti%2Frun_simulation.ipynb)
+
+## Simulations with risky choices (environment)
+
+- [Risky Food](simulatingrisk/risky_food)
+- [Risky Bet](simulatingrisk/risky_bet)
+
+## Risk attitude definitions
+
+Across simulations, we define agents with risk attitudes tracked via a numeric `r` or `risk_level` 0.0 - 1.0, where `r` is that agent's minimum acceptable risk level for taking the risky bet. When the probability 'p' of the risky bet paying off is greater than an agent's 'r', that agent will take the bet. An agent with `r=1` will always take the safe option (no risk is acceptable); an agent with `r=0` will always take the risky choice (any risk is acceptable). Notice that the agent is never indifferent; allowing indifference would require introducing a tie-breaking rule, which would be a further parameter.
+
+When the risky bet might be better or worse than the safe bet by the same amount (for example, the risky bet yields 3 or 1 and the safe bet yields 2), an agent who maximizes expected utility will prefer the risky bet when p > 0.5 and will prefer the safe bet when 'p < 0.5'; and they will be indifferent between the risky bet and the safe bet. Thus, r = 0.5 corresponds to expected utility maximization except in the case in which the probability is exactly 0.5 (or, we might say, a point epsilon units to the left of 0.5, where epsilon is smaller than the fineness of our random number generator, corresponds to expected utility maximization). These complications make no difference in practice, so we can simply say that r = 0.5 corresponds to expected utility maximization.
+
+
+## Development instructions
+
+Initial setup and installation:
+
+- *Recommmended*: create and activate a Python 3.12 virtualenv:
+
+```sh
+python3 -m venv simrisk
+source simrisk/bin/activate
+```
+
+- Install the package, dependencies, and development dependencies:
+
+```sh
+pip install -e .
+pip install -e ".[dev]"
+```
+
+To run the Solara app with tabs for all simulations that are available as Solara apps:
+```sh
+solara run simulatingrisk/app.py
+```
+
+To run a single simulation, run Solara with the model-specific app file:
+```sh
+solara run simulatingrisk/hawkdovemulti/app.py
+```
+
+An interactive version of the [Solara app with tabs for all simulations](https://py.cafe/app/rlskoeser/simulatingrisk) 
+is available online.
+
+
+### Running the simulations  (non-solara versions)
+
+- Simulations can be run interactively with mesa runserver by specifying
+  the path to the model, e.g. `mesa runserver simulatingrisk/risky_bet/`
+  Refer to the readme for each model for more details.
+- Simulations can be run in batches to aggregate data across multiple
+  runs and different parameters. For example,
+  `./simulatingrisk/batch_run.py riskyfood`
+  
+  
+### Install pre-commit hooks
+
+Install pre-commit hooks (currently [black](https://github.com/psf/black) and [ruff](https://beta.ruff.rs/docs/)):
+
+```sh
+pre-commit install
+```

simulatingrisk-1.0.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+simulatingrisk/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+simulatingrisk/about_app.md,sha256=wJIhaaiqiS5qn-_y7-tkYPhzmrLCGm3cuqTFppPRizY,148
+simulatingrisk/app.py,sha256=yd5TVDbVUEyTQ38fAQYw5bnGaArE6gHJY0P7afdB0D0,1263
+simulatingrisk/batch_run.py,sha256=ZB18m46wjkwwsMpMZmMh17F5ZxiONKUXB-OmSdVStJE,5113
+simulatingrisk/utils.py,sha256=NfbKWkKdO8UksNpy9JmqtWCtQOcqVxztnMD7TzasUwI,1065
+simulatingrisk/charts/histogram.js,sha256=fE_npwxCWMEs7tBpHaTAwi4C2kWSb-yhduHh5R2eZUw,1311
+simulatingrisk/charts/histogram.py,sha256=m_v-imNd4nPrd-0H5DtlKpTcIGREwtquGX5ZHJ6HPbM,2499
+simulatingrisk/hawkdove/README.md,sha256=G4gZsv8QTs9UMEJdBn76JKFh9qvO8gxf39e1r02rH9Y,6170
+simulatingrisk/hawkdove/app.py,sha256=XjmP-ofdG4tpGQhIMghGWDc43ejoGwKpg0i0DHIPqqE,2702
+simulatingrisk/hawkdove/model.py,sha256=jP8QGTQVSacFngD56vRf08HZ_X8srjQQ-MiXF4BiiEs,13734
+simulatingrisk/hawkdove/run.py,sha256=5bNwwbthwhStOZlu9Frmd9nw--CyPw991QCUfziBAak,840
+simulatingrisk/hawkdove/server.py,sha256=zBDM1lbjwUJJ6lmpudpqmO5iOO7nI1F5nKh5egRYvZ4,5784
+simulatingrisk/hawkdovemulti/README.md,sha256=WCIHEPEsNVV9Z3cJsFjh6BgGZlrUS-TVHOTGsUWPj30,3672
+simulatingrisk/hawkdovemulti/analysis_utils.py,sha256=mPHqhvTS3C79tbvcEyjkunfJcKHJtkdei4xra8xD66o,2774
+simulatingrisk/hawkdovemulti/app.py,sha256=PXlfyyLSAqyQb0UDeVlUNdk3zYp2cZee3mkb5kPRIgU,8239
+simulatingrisk/hawkdovemulti/batch_run.py,sha256=VsUoLkd-iyCqL1RvJEhWprbP3YnX6TRMWbfVDWXfVIU,11176
+simulatingrisk/hawkdovemulti/model.py,sha256=lcDgPqT5tC9wYmc7jwPmb-hz6-YrZTpZ0oJ0q61MoKc,18429
+simulatingrisk/hawkdovemulti/run_simulation.ipynb,sha256=a8YqveMmbVXVR1RUUsjZZp-aEFexJI_PSu7egF2XSzs,1224
+simulatingrisk/hawkdovemulti/simrisk_batch.slurm,sha256=j7uCmMTK5xrDQgONWI6qU47YV2V6MCJuevi9BkYprZc,1922
+simulatingrisk/risky_bet/README.md,sha256=BuSg7zaM1uu2AFFvMX33im_P-oQK0oVce0KRu40nwIk,2152
+simulatingrisk/risky_bet/app.py,sha256=9n8i4XcbDRXVUzgNVe_mX6k_3dUUtY_brIQ1FgvEOtw,490
+simulatingrisk/risky_bet/model.py,sha256=JD5JpIaSFNQ4cJtEKOrpPL-lcBRvwoCnnT6DYtUPSQA,8257
+simulatingrisk/risky_bet/run.py,sha256=02KKzo_aqV6T0ZHeDySg3yAnZAFnSm3y8y5v0yzfbOE,1422
+simulatingrisk/risky_bet/server.py,sha256=9XluBwI3XXR1qkrJY_VRSlcfO3b0m_8X64olxbIhDvs,3175
+simulatingrisk/risky_food/README.md,sha256=tR3QvRDRmDo1X0HFz1Q-isD38AIbF5s2xOwrfzd8ztU,1344
+simulatingrisk/risky_food/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simulatingrisk/risky_food/app.py,sha256=z_ofGHX5UoU9fI93GovHH9p4IjYZJQWbth9MgFnLAGY,576
+simulatingrisk/risky_food/model.py,sha256=zFjqa4ZFTJyQuGYzruXMw9uXtx-PUcbabhEXc2DzjR8,8776
+simulatingrisk/risky_food/run.py,sha256=_5PYfNGa8NmDr-I0Obr6CdMH1S2pgBP639VpWz8KyxY,472
+simulatingrisk/risky_food/server.py,sha256=RrO6GpAbMlsKbwguXcz9SqmLogszvnsJ9L4h0FXeH3c,2126
+simulatingrisk/stag_hunt/README.md,sha256=hrxBs1wKuutZJNQMB-_cYWKBy52OTXsA9XZWkU1akyc,857
+simulatingrisk/stag_hunt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simulatingrisk/stag_hunt/model.py,sha256=HJGJOXcgLWnIpixFlx1PiZGI9I1G53MJn4g_AccaLMo,4202
+simulatingrisk/stag_hunt/run.py,sha256=N-gC9FbkcEv23g98aGVliFSRSZr6c-rW24Rl4SbrIpg,1200
+simulatingrisk-1.0.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+simulatingrisk-1.0.0.dist-info/METADATA,sha256=EPp7h1mVhvXTKyAtw9-tg0-Hxbd9HUGqQjewY9CZcvQ,5794
+simulatingrisk-1.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+simulatingrisk-1.0.0.dist-info/entry_points.txt,sha256=Wfr2ZZhtNf0-DKKXYJy45kUs_NEmFNqM0bP8c5fZuzE,95
+simulatingrisk-1.0.0.dist-info/top_level.txt,sha256=73FkHL2uA7XLFVhk-vvXVyMnhBN6TW-oD944TY0vbo8,15
+simulatingrisk-1.0.0.dist-info/RECORD,,

simulatingrisk-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simulatingrisk-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simrisk-hawkdovemulti-batchrun = simulatingrisk.hawkdovemulti.batch_run:main