From 509e2159b7b9e5a361cdb309550486bac9ecd523 Mon Sep 17 00:00:00 2001 From: Tyler Coles Date: Fri, 8 Mar 2024 17:52:59 -0700 Subject: [PATCH] Added context for collecting movement data. And a devlog demonstration. --- doc/devlog/2024-03-13.ipynb | 425 ++++++++++++++++++++++++ doc/devlog/README.md | 1 + epymorph/engine/mm_exec.py | 88 +++-- epymorph/engine/standard_sim.py | 33 +- epymorph/engine/test/world_list_test.py | 2 +- epymorph/engine/world.py | 4 +- epymorph/engine/world_hypercube.py | 13 +- epymorph/engine/world_list.py | 26 +- epymorph/event.py | 200 +++++++++++ epymorph/geo/dynamic.py | 4 +- epymorph/log/file.py | 102 ++++++ epymorph/log/messaging.py | 6 +- epymorph/log/movement.py | 135 ++++++++ epymorph/simulation.py | 81 +---- epymorph/util.py | 5 + 15 files changed, 985 insertions(+), 140 deletions(-) create mode 100644 doc/devlog/2024-03-13.ipynb create mode 100644 epymorph/event.py create mode 100644 epymorph/log/file.py create mode 100644 epymorph/log/movement.py diff --git a/doc/devlog/2024-03-13.ipynb b/doc/devlog/2024-03-13.ipynb new file mode 100644 index 00000000..abafc576 --- /dev/null +++ b/doc/devlog/2024-03-13.ipynb @@ -0,0 +1,425 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# devlog 2024-02-13\n", + "\n", + "_Author: Tyler Coles_\n", + "\n", + "Demonstration of how to use the new movement data collection feature to examine the operation of a movement model.\n", + "\n", + "## What data is there to collect?\n", + "\n", + "The execution of the movement model is really answering two questions every time a movement clause fires:\n", + "\n", + "1) how many individuals (regardless of IPM state) were _requested_ to move from every node to every other node, and\n", + "2) how many individuals (divided by IPM state) were _actually_ moved from every node to every other node.\n", + "\n", + "The total number of individuals involved in these two answers can vary, especially if there were not enough individuals in a source node to satisfy the requested movement.\n", + "\n", + "Requested movement (for user-defined clauses) is the direct result of the movement clause function. Return movement is done internally by epymorph, so the \"return clause\" is virtual, in a sense, though its data is also captured by this mechanism.\n", + "\n", + "In movement execution, the requested movement is converted into actual movement by performing random draws on the individuals present in a location. For example, if we request 100 people to move, we might choose 75 Susceptibles, 20 Infectious, and 5 Recovered (in an SIR model). If there are less than 100 people in that location, we will choose all of them, whichever IPM state they are in.\n", + "\n", + "## How do we collect movement data?\n", + "\n", + "If we run our simulation in a `movement_data` context, it will provide us a `MovementData` object which we can use to access both _requested_ and _actual_ movement flows by clause name or in total.\n", + "\n", + "Let's see an example: first we'll set up a simulation using the \"centroids\" movement model, then run it to collect movement data, and finally inspect the collected data to give you an idea of what you can do with it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pygris as pg\n", + "\n", + "from epymorph import *\n", + "from epymorph.geo.cache import load_from_cache\n", + "from epymorph.geo.geo import Geo\n", + "from epymorph.initializer import single_location\n", + "from epymorph.log.movement import movement_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running simulation (StandardSimulation):\n", + "• 2015-01-01 to 2015-04-11 (100 days)\n", + "• 158 geo nodes\n", + "|####################| 100% \n", + "Runtime: 6.332s\n" + ] + } + ], + "source": [ + "def load_geo(name: str) -> Geo:\n", + " cached = load_from_cache(name)\n", + " if not cached is None:\n", + " return cached\n", + " else:\n", + " return geo_library[name]()\n", + "\n", + "\n", + "geo = load_geo('us_sw_counties_2015')\n", + "ipm = ipm_library['sirs']()\n", + "mm = mm_library['centroids']()\n", + "\n", + "sim = StandardSimulation(\n", + " geo, ipm, mm,\n", + " params={\n", + " 'phi': 40.0,\n", + " 'beta': 0.4,\n", + " 'gamma': 1 / 5,\n", + " 'xi': 1 / 90,\n", + " },\n", + " time_frame=TimeFrame.of(\"2015-01-01\", 100),\n", + " initializer=partial(single_location, location=0, seed_size=1_000),\n", + " rng=default_rng(42),\n", + ")\n", + "\n", + "# Python lets us run code in a block with multiple context managers,\n", + "# so we'll do both the console messaging and collection of movement data.\n", + "# The `move_data` object returned by the movement_data context is where\n", + "# the movement data will be collected.\n", + "# NOTE: we should only access its data _after_ the context completes.\n", + "with (\n", + " sim_messaging(sim, True),\n", + " movement_data(sim) as move_data,\n", + "):\n", + " out = sim.run()\n", + "\n", + "# Now we're free to use `move_data`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Analysis\n", + "\n", + "1. Which counties \"exported\" the most infectious cases?\n", + "\n", + "To find out, we can sum all \"I\" individuals leaving each node across the whole time series. There's only one clause that is responsible for people leaving their home county, and that's \"centroids_commuters\", so we focus just on the actual movement from that clause." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
labelexported
0Maricopa County, Arizona790588
1Salt Lake County, Utah355211
2Clark County, Nevada274661
3El Paso County, Colorado238660
4Denver County, Colorado238172
5Bernalillo County, New Mexico229522
6Arapahoe County, Colorado219040
7Jefferson County, Colorado209478
8Pima County, Arizona190433
9Utah County, Utah185672
\n", + "
" + ], + "text/plain": [ + " label exported\n", + "0 Maricopa County, Arizona 790588\n", + "1 Salt Lake County, Utah 355211\n", + "2 Clark County, Nevada 274661\n", + "3 El Paso County, Colorado 238660\n", + "4 Denver County, Colorado 238172\n", + "5 Bernalillo County, New Mexico 229522\n", + "6 Arapahoe County, Colorado 219040\n", + "7 Jefferson County, Colorado 209478\n", + "8 Pima County, Arizona 190433\n", + "9 Utah County, Utah 185672" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get actual commuters movement flows\n", + "commuters = move_data.actual_by('centroids_commuters')\n", + "\n", + "# Select just the Infectious compartment\n", + "# NOTE: `compartments_by` returns a tuple, so this result still has 4 axes; we'll deal with it in the next step.\n", + "commuters_I = commuters[:, :, :, ipm.compartments_by('I')]\n", + "\n", + "# Compute the totals leaving each source node, regardless of destination node, and across time.\n", + "exported_I = commuters_I.sum(axis=(0, 2, 3))\n", + "\n", + "# `argsort` gives us the indices that would sort the array, so we can use this to subselect.\n", + "# Sort the negative of the array to get descending order.\n", + "top_ten = np.argsort(-exported_I)[0:10]\n", + "\n", + "# Chart of the top 10 \"exporters\"\n", + "# I think we can safely say the units for the exported column are \"people-days\",\n", + "# since each individual is counted every time they commute as long as they are infectious,\n", + "# but we know from the movement mechanics that they will only commute up to once per day.\n", + "# It's a little esoteric, but gives us a basis for comparison.\n", + "pd.DataFrame({\n", + " 'label': geo.labels[top_ten],\n", + " 'exported': exported_I[top_ten],\n", + "})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Let's draw a map.\n", + "\n", + "That isn't a question, but sure! Maybe we'd like to see which counties exported the most infectious person-days relative to the total person-days they exported." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "commuters = move_data.actual_by('centroids_commuters')\n", + "\n", + "df = pd.DataFrame({\n", + " 'GEOID': geo['geoid'],\n", + " 'I': commuters[..., ipm.compartments_by('I')].sum(axis=(0, 2, 3)),\n", + " 'N': commuters.sum(axis=(0, 2, 3)),\n", + "})\n", + "df['I:N'] = df['I'] / df['N']\n", + "\n", + "gdf_counties = pg.counties(cb=True, resolution='5m', cache=True, year=2020)\n", + "\n", + "gdf = pd.merge(\n", + " on=\"GEOID\",\n", + " how=\"right\",\n", + " left=gdf_counties[['GEOID', 'geometry']],\n", + " right=df,\n", + ")\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.axis('off')\n", + "ax.set_title(\"Exported person-days by county: ratio of infectious to total\")\n", + "gdf.plot(ax=ax, column='I:N', cmap='Purples', legend=True, vmin=0, vmax=0.06)\n", + "gdf.plot(ax=ax, color='none', edgecolor='white', linewidth=1, alpha=0.2)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. When are the most infectious individuals moving around?\n", + "\n", + "We could certainly sum across the geography and look at time-series data. This time we'll lump commuting movement and returning movement together -- we're interested in how many infectious individuals are moving even if they catch the infection \"at work\" and bring it home. Again, the units of this aren't easily applicable, but the magnitude is all we need for a comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "movers = move_data.actual_all()\n", + "\n", + "T, N, _, E = out.dim.TNCE\n", + "D = out.dim.days\n", + "taus = out.dim.tau_steps\n", + "\n", + "# Select infected movers and sum by simulation tick\n", + "movers_I = movers[..., ipm.compartments_by('I')].sum(axis=(1, 2, 3))\n", + "\n", + "# Then we group-and-sum to get a daily total\n", + "movers_I_per_day = movers_I.reshape((T // taus, taus)).sum(axis=1)\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.set_title(\"Total movement events involving infectious individuals\")\n", + "ax.set_xlabel('day')\n", + "ax.set_ylabel('movements')\n", + "ax.plot(np.arange(D), movers_I_per_day)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. How can we check that everyone who leaves due to the commuters clause returns home at the end of the day, like we expect?\n", + "\n", + "In other words: how do we know the centroids movement model works?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all equal!\n" + ] + } + ], + "source": [ + "# Commuters should be leaving their homes at the start of the day-time tau-step (tau-0)...\n", + "commuters = move_data.actual_by('centroids_commuters')\n", + "# And returning home at the end of the day (aka, the start of the night-time tau-step; tau-1).\n", + "returners = move_data.actual_by('return')\n", + "\n", + "# There are no other clauses in this movement model to worry about,\n", + "# but more complicated models may not be as easy as this to analyze.\n", + "\n", + "# Compare tau-0 to tau-1 for every day in the sim:\n", + "for t in range(0, out.dim.ticks, 2):\n", + " # Sum commuters by source node,\n", + " a = commuters[t + 0].sum(axis=(1, 2))\n", + " # But sum returners by destination node!\n", + " b = returners[t + 1].sum(axis=(0, 2))\n", + " # This way we're correctly comparing everyone who left with everyone who came back.\n", + "\n", + " # I use the sum here because the returners might not have the exact same IPM state distribution\n", + " # as when they left; the IPM execution may have transitioned some of them to different states.\n", + " # Only the count of individuals can be guaranteed to be the same.\n", + "\n", + " # We've found an error if there are any differences between `a` and `b`.\n", + " if not np.array_equal(a, b):\n", + " print(f\"not equal at {t}\")\n", + " break\n", + "else:\n", + " # Otherwise, no errors means success!\n", + " print(\"all equal!\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/devlog/README.md b/doc/devlog/README.md index d20d6294..47e09bd4 100644 --- a/doc/devlog/README.md +++ b/doc/devlog/README.md @@ -45,6 +45,7 @@ This folder is a handy place to put Jupyter notebooks or other documents which h | 2024-02-06.ipynb | Tyler | | Revisiting age-class IPMs, and thinking about modularity of approach. | | 2024-02-12.ipynb | Tyler | | Continued age-class IPM work, this time in more than one geo node. | | 2024-03-01.ipynb | Tyler | | Getting the indices of IPM events and compartments by name with wildcard support. | +| 2024-03-13.ipynb | Tyler | | Showing off movement data collection (NEW!) | ## Contributing diff --git a/epymorph/engine/mm_exec.py b/epymorph/engine/mm_exec.py index 3c4cbce4..cb2187f9 100644 --- a/epymorph/engine/mm_exec.py +++ b/epymorph/engine/mm_exec.py @@ -2,7 +2,6 @@ Movement executor classes handle the logic for processing the movement step of the simulation. """ from abc import ABC, abstractmethod -from logging import DEBUG, Logger, getLogger import numpy as np from numpy.typing import NDArray @@ -10,6 +9,8 @@ from epymorph.engine.context import RumeContext from epymorph.engine.world import World from epymorph.error import AttributeException, MmCompileException +from epymorph.event import (MovementEventsMixin, OnMovementClause, + OnMovementFinish, OnMovementStart) from epymorph.movement.compile import compile_spec from epymorph.movement.movement_model import (MovementModel, PredefParams, TravelClause) @@ -35,17 +36,17 @@ def apply(self, world: World, tick: Tick) -> None: ############################################################ -class StandardMovementExecutor(MovementExecutor): +class StandardMovementExecutor(MovementEventsMixin, MovementExecutor): """The standard implementation of movement model execution.""" _ctx: RumeContext - _log: Logger _model: MovementModel _clause_masks: dict[TravelClause, NDArray[np.bool_]] _predef: PredefParams = {} _predef_hash: int | None = None def __init__(self, ctx: RumeContext): + super().__init__() # If we were given a MovementSpec, we need to compile it to get its clauses. if isinstance(ctx.mm, MovementSpec): self._model = compile_spec(ctx.mm, ctx.rng) @@ -53,7 +54,6 @@ def __init__(self, ctx: RumeContext): self._model = ctx.mm self._ctx = ctx - self._log = getLogger('movement') self._clause_masks = {c: c.mask(ctx) for c in self._model.clauses} self._check_predef() @@ -76,11 +76,14 @@ def _check_predef(self) -> None: def apply(self, world: World, tick: Tick) -> None: """Applies movement for this tick, mutating the world state.""" - self._log.debug('Processing movement for day %s, step %s', tick.day, tick.step) + + self.on_movement_start.publish( + OnMovementStart(tick.index, tick.day, tick.step)) self._check_predef() # Process travel clauses. + total = 0 for clause in self._model.clauses: if not clause.predicate(self._ctx, tick): continue @@ -89,10 +92,30 @@ def apply(self, world: World, tick: Tick) -> None: returns = clause.returns(self._ctx, tick) return_tick = self._ctx.resolve_tick(tick, returns) world.apply_travel(travelers, return_tick) + total += travelers.sum() # Process return clause. - return_movers = world.apply_return(tick) - self._log.getChild('Return').debug("moved %d", return_movers) + # return_requested, return_actual, return_total = world.apply_return(tick) + return_movers = world.apply_return(tick, return_stats=True) + if return_movers is not None: + return_total = return_movers.sum() + total += return_total + + self.on_movement_clause.publish( + OnMovementClause( + tick.index, + tick.day, + tick.step, + "return", + return_movers, + return_movers, + return_total, + False, + ) + ) + + self.on_movement_finish.publish( + OnMovementFinish(tick.index, tick.day, tick.step, total)) def _travelers(self, clause: TravelClause, tick: Tick, local_cohorts: NDArray[SimDType]) -> NDArray[SimDType]: """ @@ -101,38 +124,35 @@ def _travelers(self, clause: TravelClause, tick: Tick, local_cohorts: NDArray[Si then selects exactly which individuals (by compartment) should move. Returns an (N,N,C) array; from-source-to-destination-by-compartment. """ - clause_log = self._log.getChild(clause.name) _, N, C, _ = self._ctx.dim.TNCE - requested_movers = clause.requested(self._ctx, self._predef, tick) - np.fill_diagonal(requested_movers, 0) - requested_sum = requested_movers.sum(axis=1, dtype=SimDType) + clause_movers = clause.requested(self._ctx, self._predef, tick) + np.fill_diagonal(clause_movers, 0) + clause_sum = clause_movers.sum(axis=1, dtype=SimDType) available_movers = local_cohorts * self._clause_masks[clause] available_sum = available_movers.sum(axis=1, dtype=SimDType) - # If requested total is greater than the total available, + # If clause requested total is greater than the total available, # use mvhg to select as many as possible. - throttled = False - for src in range(N): - if requested_sum[src] > available_sum[src]: - msg = " movement throttled for insufficient population at %d" - clause_log.debug(msg, src) - requested_movers[src, :] = self._ctx.rng.multivariate_hypergeometric( - colors=requested_movers[src, :], - nsample=available_sum[src] - ) - throttled = True - - # Update sum if it changed in the previous step. - if throttled: + if not np.any(clause_sum > available_sum): + throttled = False + requested_movers = clause_movers + requested_sum = clause_sum + else: + throttled = True + requested_movers = clause_movers.copy() + for src in range(N): + if clause_sum[src] > available_sum[src]: + requested_movers[src, :] = self._ctx.rng.multivariate_hypergeometric( + colors=requested_movers[src, :], + nsample=available_sum[src] + ) requested_sum = requested_movers.sum(axis=1, dtype=SimDType) # The probability a mover from a src will go to a dst. requested_prb = row_normalize(requested_movers, requested_sum, dtype=SimDType) - clause_log.debug("requested_movers:\n%s", requested_movers) - travelers_cs = np.zeros((N, N, C), dtype=SimDType) for src in range(N): if requested_sum[src] == 0: @@ -151,7 +171,17 @@ def _travelers(self, clause: TravelClause, tick: Tick, local_cohorts: NDArray[Si requested_prb[src, :] ).T.astype(SimDType) - if clause_log.isEnabledFor(DEBUG): - clause_log.debug("moved %d", requested_sum.sum()) + self.on_movement_clause.publish( + OnMovementClause( + tick.index, + tick.day, + tick.step, + clause.name, + clause_movers, + travelers_cs, + requested_sum.sum(), + throttled, + ) + ) return travelers_cs diff --git a/epymorph/engine/standard_sim.py b/epymorph/engine/standard_sim.py index d66994c8..085fb021 100644 --- a/epymorph/engine/standard_sim.py +++ b/epymorph/engine/standard_sim.py @@ -16,14 +16,15 @@ from epymorph.error import (AttributeException, CompilationException, InitException, IpmSimException, MmSimException, ValidationException, error_gate) +from epymorph.event import (MovementEventsMixin, OnStart, OnTick, + SimulationEventsMixin) from epymorph.geo.geo import Geo from epymorph.initializer import DEFAULT_INITIALIZER, Initializer from epymorph.movement.movement_model import MovementModel, validate_mm from epymorph.movement.parser import MovementSpec from epymorph.params import ContextParams, Params -from epymorph.simulation import (OnStart, SimDimensions, SimDType, SimTick, - SimulationEvents, TimeFrame) -from epymorph.util import Event +from epymorph.simulation import SimDimensions, SimDType, TimeFrame +from epymorph.util import Subscriber @dataclass @@ -88,13 +89,12 @@ def ticks_in_days(self) -> NDArray[np.float64]: return np.cumsum(np.tile(self.dim.tau_step_lengths, self.dim.days), dtype=np.float64) -class StandardSimulation(SimulationEvents): +class StandardSimulation(SimulationEventsMixin, MovementEventsMixin): """Runs singular simulation passes, producing time-series output.""" _config: RumeConfig _params: ContextParams | None = None geo: Geo - on_tick: Event[SimTick] # this class supports on_tick; so narrow the type def def __init__(self, geo: Geo, @@ -104,6 +104,9 @@ def __init__(self, time_frame: TimeFrame, initializer: Initializer | None = None, rng: Callable[[], np.random.Generator] | None = None): + SimulationEventsMixin.__init__(self) + MovementEventsMixin.__init__(self) + self.geo = geo if initializer is None: initializer = DEFAULT_INITIALIZER @@ -112,11 +115,6 @@ def __init__(self, self._config = RumeConfig(geo, ipm, mm, params, time_frame, initializer, rng) - # events - self.on_start = Event() - self.on_tick = Event() - self.on_end = Event() - def validate(self) -> None: """Validate the simulation.""" with error_gate("validating the simulation", ValidationException, CompilationException): @@ -148,11 +146,22 @@ def run(self) -> Output: Run the simulation. It is safe to call this multiple times to run multiple independent simulations with the same configuraiton. """ + event_subs = Subscriber() + with error_gate("compiling the simulation", CompilationException): ctx = RumeContext.from_config(self._config) ipm_exec = StandardIpmExecutor(ctx) movement_exec = StandardMovementExecutor(ctx) + # Proxy the movement_exec's events, if anyone is listening for them. + if MovementEventsMixin.has_subscribers(self): + event_subs.subscribe(movement_exec.on_movement_start, + self.on_movement_start.publish) + event_subs.subscribe(movement_exec.on_movement_clause, + self.on_movement_clause.publish) + event_subs.subscribe(movement_exec.on_movement_finish, + self.on_movement_finish.publish) + with error_gate("initializing the simulation", InitException): ini = ctx.initialize() world = ListWorld.from_initials(ini) @@ -173,9 +182,11 @@ def run(self) -> Output: out.prevalence[tick.index] = tick_prevalence t = tick.index - self.on_tick.publish(SimTick(t, (t + 1) / ctx.dim.ticks)) + self.on_tick.publish(OnTick(t, (t + 1) / ctx.dim.ticks)) self.on_end.publish(None) + + event_subs.unsubscribe() return out diff --git a/epymorph/engine/test/world_list_test.py b/epymorph/engine/test/world_list_test.py index 014a4005..1c7805f1 100644 --- a/epymorph/engine/test/world_list_test.py +++ b/epymorph/engine/test/world_list_test.py @@ -216,7 +216,7 @@ def test_return(self): Cohort(np.array([19]), 0, 2), ]]) - world.apply_return(Tick(1, 1, date(2023, 1, 1), 0, 1.0)) + world.apply_return(Tick(1, 1, date(2023, 1, 1), 0, 1.0), return_stats=False) self.assertWorld( world.locations, diff --git a/epymorph/engine/world.py b/epymorph/engine/world.py index eb3c4cc0..d9eb4d09 100644 --- a/epymorph/engine/world.py +++ b/epymorph/engine/world.py @@ -46,7 +46,9 @@ def apply_travel(self, travelers: NDArray[SimDType], return_tick: int) -> None: """ @abstractmethod - def apply_return(self, tick: Tick) -> int: + def apply_return(self, tick: Tick, *, return_stats: bool) -> NDArray[SimDType] | None: """ Modify the world state as a result of returning all movers that are ready to be returned home. + If `return_stats` is True, returns an NxNxC array containing the individuals moved during the return. + Otherwise returns None. """ diff --git a/epymorph/engine/world_hypercube.py b/epymorph/engine/world_hypercube.py index 47f0c7d3..1cbbb377 100644 --- a/epymorph/engine/world_hypercube.py +++ b/epymorph/engine/world_hypercube.py @@ -107,11 +107,14 @@ def apply_travel(self, travelers: NDArray[SimDType], return_tick: int) -> None: self.ledger[return_tick + 1, :, :, :] += travelers self.time_frontier = max(self.time_frontier, return_tick + 2) - def apply_return(self, tick: Tick) -> int: - total = self.ledger[self.time_offset + 1, :, :, :].sum(dtype=SimDType) - movers = self.ledger[self.time_offset + 1, :, :, :].sum( + def apply_return(self, tick: Tick, *, return_stats: bool) -> NDArray[SimDType] | None: + # we have to transpose the movers "stats" result since they're being stored here as + # (home, visiting) and our result needs to be + # (moving from "visiting", moving to "home") + movers = self.ledger[self.time_offset + 1, :, :, :].transpose((1, 0, 2)).copy() + movers_by_home = self.ledger[self.time_offset + 1, :, :, :].sum( axis=1, dtype=SimDType) * self._ident - self.ledger[self.time_offset + 1, :, :, :] = movers + \ + self.ledger[self.time_offset + 1, :, :, :] = movers_by_home + \ self.ledger[self.time_offset, :, :, :] self.time_offset += 1 # assumes there's only ever one return clause per tick - return total + return movers if return_stats else None diff --git a/epymorph/engine/world_list.py b/epymorph/engine/world_list.py index c6772951..7ccbb2bb 100644 --- a/epymorph/engine/world_list.py +++ b/epymorph/engine/world_list.py @@ -1,6 +1,6 @@ """World implementation: ListWorld.""" from operator import attrgetter -from typing import Iterable, Self +from typing import Any, Iterable, Self import numpy as np from numpy.typing import NDArray @@ -64,6 +64,7 @@ class ListWorld(World): """The value of a population's `return_tick` when the population is home.""" nodes: int + compartments: int locations: list[list[Cohort]] @classmethod @@ -79,6 +80,7 @@ def from_initials(cls, initial_compartments: NDArray[SimDType]) -> Self: def __init__(self, locations: list[list[Cohort]]): self.nodes = len(locations) + self.compartments = len(locations[0][0].compartments) self.locations = locations def normalize(self) -> None: @@ -133,22 +135,28 @@ def apply_travel(self, travelers: NDArray[SimDType], return_tick: int) -> None: self.normalize() - def apply_return(self, tick: Tick) -> int: - total_movers = 0 + def apply_return(self, tick: Tick, *, return_stats: bool) -> NDArray[SimDType] | None: + movers: Any = None + if return_stats: + size = (self.nodes, self.nodes, self.compartments) + movers = np.zeros(size, dtype=SimDType) + next_locations = [[locals] for locals in self.get_local_cohorts()] - for loc_index, loc in enumerate(self.locations): - for cohort in loc: + for i, location in enumerate(self.locations): + for cohort in location: if cohort.return_tick == ListWorld.HOME_TICK: # locals are already where they need to be continue elif cohort.return_tick == tick.index: # cohort ready to go home, merge with locals - next_locations[cohort.return_location][0].compartments += cohort.compartments - total_movers += cohort.compartments.sum() + j = cohort.return_location + next_locations[j][0].compartments += cohort.compartments + if return_stats: + movers[i, j, :] = cohort.compartments else: # cohort staying - next_locations[loc_index].append(cohort) + next_locations[i].append(cohort) self.locations = next_locations self.normalize() - return total_movers + return movers if return_stats else None diff --git a/epymorph/event.py b/epymorph/event.py new file mode 100644 index 00000000..5680f459 --- /dev/null +++ b/epymorph/event.py @@ -0,0 +1,200 @@ +""" +epymorph's event frameworks. +The idea is to have a set of classes which define event protocols for +logical components of epymorph. +""" +from typing import NamedTuple, Protocol, runtime_checkable + +from numpy.typing import NDArray + +from epymorph.simulation import SimDimensions, SimDType, TimeFrame +from epymorph.util import Event + +# Simulation Events + + +class OnStart(NamedTuple): + """The payload of a Simulation on_start event.""" + dim: SimDimensions + time_frame: TimeFrame + + +class OnTick(NamedTuple): + """The payload of a Simulation tick event.""" + tick_index: int + percent_complete: float + + +@runtime_checkable +class SimulationEvents(Protocol): + """ + Protocol for Simulations that support lifecycle events. + For correct operation, ensure that `on_start` is fired first, + then `on_tick` at least once, then finally `on_end`. + """ + + on_start: Event[OnStart] + """ + Event fires at the start of a simulation run. Payload is a subset of the context for this run. + """ + + on_tick: Event[OnTick] + """ + Event which fires after each tick has been processed. + Event payload is a tuple containing the tick index just completed (an integer), + and the percentage complete (a float). + """ + + # TODO: rename `on_end` to `on_finish`. + + on_end: Event[None] + """ + Event fires after a simulation run is complete. + """ + + +class SimulationEventsMixin(SimulationEvents): + """A mixin implementation of the SimulationEvents protocol which initializes the events.""" + + def __init__(self): + self.on_start = Event() + self.on_tick = Event() + self.on_end = Event() + + def has_subscribers(self) -> bool: + """True if there is at least one subscriber on any simulation event.""" + return self.on_start.has_subscribers \ + or self.on_tick.has_subscribers \ + or self.on_end.has_subscribers + + +# Movement Events + + +class OnMovementStart(NamedTuple): + """The payload for the event when movement processing starts for a tick.""" + tick: int + """Which simulation tick.""" + day: int + """Which simulation day.""" + step: int + """Which tau step (by index).""" + + +class OnMovementClause(NamedTuple): + """The payload for the event when a single movement clause has been processed.""" + tick: int + """Which simulation tick.""" + day: int + """Which simulation day.""" + step: int + """Which tau step (by index).""" + clause_name: str + """The clause processed.""" + requested: NDArray[SimDType] + """ + The number of individuals this clause 'wants' to move, that is, the values returned by its clause funcction. + (An NxN array.) + """ + actual: NDArray[SimDType] + """The actual number of individuals moved, by source, destination, and compartment. (An NxNxC array.)""" + total: int + """The number of individuals moved by this clause.""" + is_throttled: bool + """Did the clause request to move more people than were available (at any location)?""" + + +class OnMovementFinish(NamedTuple): + """The payload for the event when movement processing finishes for one simulation tick.""" + tick: int + """Which simulation tick.""" + day: int + """Which simulation day.""" + step: int + """Which tau step (by index).""" + total: int + """The total number of individuals moved during this tick.""" + + +@runtime_checkable +class MovementEvents(Protocol): + """ + Mixin for Simulations that support movement events. + For correct operation, ensure that `on_movement_start` is fired first, + then `on_movement_clause` any number of times, then finally `on_movement_finish`. + """ + + on_movement_start: Event[OnMovementStart] + """ + Event fires at the start of the movement processing phase for every simulation tick. + """ + + on_movement_clause: Event[OnMovementClause] + """ + Event fires after every movement clause has been processed, excluding clauses that are not triggered in this tick. + """ + + on_movement_finish: Event[OnMovementFinish] + """ + Event fires at the end of the movement processing phase for every simulation tick. + """ + + +class MovementEventsMixin(MovementEvents): + """A mixin implementation of the MovementEvents protocol which initializes the events.""" + + def __init__(self): + self.on_movement_start = Event() + self.on_movement_clause = Event() + self.on_movement_finish = Event() + + def has_subscribers(self) -> bool: + """True if there is at least one subscriber on any movement event.""" + return self.on_movement_start.has_subscribers \ + or self.on_movement_clause.has_subscribers \ + or self.on_movement_finish.has_subscribers + + +class SimWithEvents(SimulationEvents, MovementEvents, Protocol): + """Intersection type of SimulationEvents and MovementEvents""" + + +# Geo/ADRIO Events + + +class FetchStart(NamedTuple): + """The payload of a DynamicGeo fetch_start event.""" + adrio_len: int + + +class AdrioStart(NamedTuple): + """The payload of a DynamicGeo adrio_start event.""" + attribute: str + index: int | None + """An index assigned to this ADRIO if fetching ADRIOs as a batch.""" + adrio_len: int | None + """The total number of ADRIOs being fetched if fetching ADRIOs as a batch.""" + + +@runtime_checkable +class DynamicGeoEvents(Protocol): + """ + Protocol for DynamicGeos that support lifecycle events. + For correct operation, ensure that `fetch_start` is fired first, + then `adrio_start` any number of times, then finally `fetch_end`. + """ + + fetch_start: Event[FetchStart] + """ + Event that fires when geo begins fetching attributes. Payload is the number of ADRIOs. + """ + + adrio_start: Event[AdrioStart] + """ + Event that fires when an individual ADRIO begins data retreival. Payload is the attribute name and index. + """ + + fetch_end: Event[None] + """ + Event that fires when data retreival is complete. + """ diff --git a/epymorph/geo/dynamic.py b/epymorph/geo/dynamic.py index c9183c83..1d2084be 100644 --- a/epymorph/geo/dynamic.py +++ b/epymorph/geo/dynamic.py @@ -11,12 +11,12 @@ from numpy.typing import NDArray from epymorph.error import AttributeException, GeoValidationException +from epymorph.event import AdrioStart, DynamicGeoEvents, FetchStart from epymorph.geo.adrio.adrio import ADRIO, ADRIOMaker, ADRIOMakerLibrary from epymorph.geo.geo import Geo from epymorph.geo.spec import (LABEL, AttribDef, DynamicGeoSpec, validate_geo_values) -from epymorph.simulation import (AdrioStart, AttributeArray, DynamicGeoEvents, - FetchStart) +from epymorph.simulation import AttributeArray from epymorph.util import Event, MemoDict diff --git a/epymorph/log/file.py b/epymorph/log/file.py new file mode 100644 index 00000000..ea8451ef --- /dev/null +++ b/epymorph/log/file.py @@ -0,0 +1,102 @@ +"""For logging epymorph simulations to a file.""" +from contextlib import contextmanager +from logging import (BASIC_FORMAT, DEBUG, NOTSET, FileHandler, Formatter, + getLogger) +from time import perf_counter +from typing import Generator + +from epymorph.event import (AdrioStart, DynamicGeoEvents, OnMovementClause, + OnMovementFinish, OnMovementStart, OnStart, OnTick, + SimWithEvents) +from epymorph.util import subscriptions + + +@contextmanager +def file_log( + sim: SimWithEvents, + log_file: str = 'debug.log', + log_level: str | int = DEBUG, +) -> Generator[None, None, None]: + """Attach file logging to a simulation.""" + + log_handler = FileHandler(log_file, "w", "utf8") + log_handler.setFormatter(Formatter(BASIC_FORMAT)) + + epy_log = getLogger('epymorph') + epy_log.addHandler(log_handler) + epy_log.setLevel(log_level) + + sim_log = epy_log.getChild('sim') + geo_log = epy_log.getChild('geo') + mm_log = epy_log.getChild('movement') + + # Define handlers for each of the events we're interested in. + + start_time: float | None = None + + def on_start(ctx: OnStart) -> None: + start_date = ctx.time_frame.start_date + duration_days = ctx.time_frame.duration_days + end_date = ctx.time_frame.end_date + + sim_log.info(f"Running simulation ({sim.__class__.__name__}):") + sim_log.info(f"- {start_date} to {end_date} ({duration_days} days)") + sim_log.info(f"- {ctx.dim.nodes} geo nodes") + + nonlocal start_time + start_time = perf_counter() + + def on_tick(tick: OnTick) -> None: + sim_log.info("Completed simulation tick %d", tick.tick_index) + + def on_end(_: None) -> None: + sim_log.info('Complete.') + end_time = perf_counter() + if start_time is not None: + sim_log.info(f"Runtime: {(end_time - start_time):.3f}s") + + def adrio_start(adrio: AdrioStart) -> None: + geo_log.debug( + "Uncached geo attribute requested: %s. Retreiving now.", adrio.attribute) + + def on_movement_start(e: OnMovementStart) -> None: + mm_log.info("Processing movement for day %d, step %d.", e.day, e.step) + + def on_movement_clause(e: OnMovementClause) -> None: + cl_log = mm_log.getChild(e.clause_name) + if e.total > 0: + cl_log.debug("requested:\n%s", e.requested) + if e.is_throttled: + cl_log.debug( + "WARNING: movement is throttled due to insufficient population") + cl_log.debug("moved:\n%s", e.actual) + cl_log.info("moved %d individuals", e.total) + + def on_movement_finish(e: OnMovementFinish) -> None: + mm_log.info(f"Moved a total of {e.total} individuals.") + + # Set up a subscriptions context, subscribe our handlers, + # then yield to the outer context (where the sim should be run). + with subscriptions() as subs: + # Simulation logging + subs.subscribe(sim.on_start, on_start) + if sim.on_tick is not None: + subs.subscribe(sim.on_tick, on_tick) + subs.subscribe(sim.on_end, on_end) + + # Geo logging will be attached if it makes sense. + sim_geo = getattr(sim, 'geo', None) + if isinstance(sim_geo, DynamicGeoEvents): + geo_log.info( + "Geo not loaded from cache; attributes will be lazily loaded during simulation run.") + subs.subscribe(sim_geo.adrio_start, adrio_start) + + # Movement logging + subs.subscribe(sim.on_movement_start, on_movement_start) + subs.subscribe(sim.on_movement_clause, on_movement_clause) + subs.subscribe(sim.on_movement_finish, on_movement_finish) + + yield # to outer context + + epy_log.removeHandler(log_handler) + epy_log.setLevel(NOTSET) diff --git a/epymorph/log/messaging.py b/epymorph/log/messaging.py index 70e65965..a242e4e6 100644 --- a/epymorph/log/messaging.py +++ b/epymorph/log/messaging.py @@ -2,8 +2,8 @@ from time import perf_counter from typing import Generator -from epymorph.simulation import (AdrioStart, DynamicGeoEvents, FetchStart, - OnStart, SimTick, SimulationEvents) +from epymorph.event import (AdrioStart, DynamicGeoEvents, FetchStart, OnStart, + OnTick, SimulationEvents) from epymorph.util import progress, subscriptions @@ -49,7 +49,7 @@ def on_start(ctx: OnStart) -> None: nonlocal start_time start_time = perf_counter() - def on_tick(tick: SimTick) -> None: + def on_tick(tick: OnTick) -> None: print(progress(tick.percent_complete), end='\r') def adrio_start(adrio: AdrioStart) -> None: diff --git a/epymorph/log/movement.py b/epymorph/log/movement.py new file mode 100644 index 00000000..45fa9ee3 --- /dev/null +++ b/epymorph/log/movement.py @@ -0,0 +1,135 @@ +"""For capturing extremely detailed movement data from a simulation.""" +from abc import abstractmethod +from contextlib import contextmanager +from typing import Generator, NamedTuple, Protocol + +import numpy as np +from numpy.typing import NDArray + +from epymorph.event import OnMovementClause, OnStart, SimWithEvents +from epymorph.simulation import SimDimensions, SimDType +from epymorph.util import subscriptions + + +class MovementData(Protocol): + """ + A data collection of simulation movement data. + Run the simulation inside a `movement_data` context and + an instance of this class will be returned. After the simulation + has completed, you can use this object to retrieve movement data + either by clause or in aggregate across all clauses. + + A note about axis ordering: both `requested` and `actual` data + includes a pair of axes that are the length of the number of geo nodes + in the simulation (N). Because these data represent movement flows we + use the convention that the first N represents where the movement is "from" and + the second N represents where the movement is "to". This is true regardless + of which clause is responsible. Returning movement from the return clause is treated + no differently than outgoing movement from a user-defined clause. + """ + + @abstractmethod + def requested_by(self, clause: str) -> NDArray[SimDType]: + """The time series of requested movement by clause. Array shape: (T,N,N)""" + + @abstractmethod + def actual_by(self, clause: str) -> NDArray[SimDType]: + """The time series of actual movement by clause. Array shape: (T,N,N,C)""" + + @abstractmethod + def requested_all(self) -> NDArray[SimDType]: + """The time series of requested movement for all clauses. Array shape: (T,N,N)""" + + @abstractmethod + def actual_all(self) -> NDArray[SimDType]: + """The time series of actual movement for all clauses. Array shape: (T,N,N,C)""" + + +class _Entry(NamedTuple): + """The data associated with a movement clause firing on a given tick.""" + name: str + tick: int + data: NDArray[SimDType] + + +class _MovementDataBuilder(MovementData): + """ + The mechanics of a context require that, in order to return a value, we have to + supply that value at the time we yield to the context body. Therefore we need + this builder object so we can provide a stand-in that will be populated as the + context body runs. We keep a `ready` flag to prevent access to the data before + the simulation (and the context) has completed. + """ + + ready: bool + dim: SimDimensions | None + requested: list[_Entry] + actual: list[_Entry] + + def __init__(self): + self.ready = False + self.dim = None + self.requested = [] + self.actual = [] + + def _get_dim(self) -> SimDimensions: + """Checks that the class is in a valid state and, if so, returns SimDimensions.""" + if not self.ready or self.dim is None: + msg = "Invalid state: MovementData cannot be accessed until the simulation is complete." + raise RuntimeError(msg) + return self.dim + + def requested_by(self, clause: str) -> NDArray[SimDType]: + T, N, _, _ = self._get_dim().TNCE + result = np.zeros((T, N, N), dtype=SimDType) + for (name, tick, data) in self.requested: + if name == clause: + result[tick, :, :] = data + return result + + def actual_by(self, clause: str) -> NDArray[SimDType]: + T, N, C, _ = self._get_dim().TNCE + result = np.zeros((T, N, N, C), dtype=SimDType) + for (name, tick, data) in self.actual: + if name == clause: + result[tick, :, :, :] = data + return result + + def requested_all(self) -> NDArray[SimDType]: + T, N, _, _ = self._get_dim().TNCE + result = np.zeros((T, N, N), dtype=SimDType) + for (_name, tick, data) in self.requested: + result[tick, :, :] += data + return result + + def actual_all(self) -> NDArray[SimDType]: + T, N, C, _ = self._get_dim().TNCE + result = np.zeros((T, N, N, C), dtype=SimDType) + for (_name, tick, data) in self.actual: + result[tick, :, :, :] += data + return result + + +@contextmanager +def movement_data(sim: SimWithEvents) -> Generator[MovementData, None, None]: + """ + Run a simulation in this context in order to collect detailed movement data + throughout the simulation run. This returns a MovementData object which + can be used -- after this context is exits -- to retrieve the movement data. + """ + md = _MovementDataBuilder() + + def on_start(e: OnStart): + nonlocal md + md.dim = e.dim + + def on_clause(e: OnMovementClause): + nonlocal md + md.requested.append(_Entry(e.clause_name, e.tick, e.requested)) + md.actual.append(_Entry(e.clause_name, e.tick, e.actual)) + + with subscriptions() as sub: + sub.subscribe(sim.on_start, on_start) + sub.subscribe(sim.on_movement_clause, on_clause) + yield md + md.ready = True diff --git a/epymorph/simulation.py b/epymorph/simulation.py index cd85bf76..dac8f641 100644 --- a/epymorph/simulation.py +++ b/epymorph/simulation.py @@ -5,15 +5,14 @@ from datetime import date, timedelta from functools import partial from importlib import reload -from typing import (Any, Callable, NamedTuple, Protocol, Self, Sequence, - runtime_checkable) +from typing import Any, Callable, NamedTuple, Protocol, Self, Sequence import numpy as np from numpy.random import SeedSequence from numpy.typing import NDArray from epymorph.code import ImmutableNamespace, base_namespace -from epymorph.util import Event, pairwise_haversine, row_normalize +from epymorph.util import pairwise_haversine, row_normalize SimDType = np.int64 """ @@ -132,82 +131,6 @@ def build(cls, tau_step_lengths: Sequence[float], days: int, nodes: int, compart """ -class OnStart(NamedTuple): - """The payload of a Simulation on_start event.""" - dim: SimDimensions - time_frame: TimeFrame - - -class SimTick(NamedTuple): - """The payload of a Simulation tick event.""" - tick_index: int - percent_complete: float - - -class FetchStart(NamedTuple): - """The payload of a DynamicGeo fetch_start event.""" - adrio_len: int - - -class AdrioStart(NamedTuple): - """The payload of a DynamicGeo adrio_start event.""" - attribute: str - index: int | None - """An index assigned to this ADRIO if fetching ADRIOs as a batch.""" - adrio_len: int | None - """The total number of ADRIOs being fetched if fetching ADRIOs as a batch.""" - - -@runtime_checkable -class SimulationEvents(Protocol): - """ - Protocol for Simulations that support lifecycle events. - For correct operation, ensure that `on_start` is fired first, - then `on_tick` at least once, then finally `on_end`. - """ - - on_start: Event[OnStart] - """ - Event fires at the start of a simulation run. Payload is a subset of the context for this run. - """ - - on_tick: Event[SimTick] | None - """ - Optional event which fires after each tick has been processed. - Event payload is a tuple containing the tick index just completed (an integer), - and the percentage complete (a float). - """ - - on_end: Event[None] - """ - Event fires after a simulation run is complete. - """ - - -@runtime_checkable -class DynamicGeoEvents(Protocol): - """ - Protocol for DynamicGeos that support lifecycle events. - For correct operation, ensure that `fetch_start` is fired first, - then `adrio_start` any number of times, then finally `fetch_end`. - """ - - fetch_start: Event[FetchStart] - """ - Event that fires when geo begins fetching attributes. Payload is the number of ADRIOs. - """ - - adrio_start: Event[AdrioStart] - """ - Event that fires when an individual ADRIO begins data retreival. Payload is the attribute name and index. - """ - - fetch_end: Event[None] - """ - Event that fires when data retreival is complete. - """ - - def enable_logging(filename: str = 'debug.log', movement: bool = True) -> None: """Enable simulation logging to file.""" reload(logging) diff --git a/epymorph/util.py b/epymorph/util.py index c2807636..66bd1c39 100644 --- a/epymorph/util.py +++ b/epymorph/util.py @@ -305,6 +305,11 @@ def publish(self, event: T) -> None: for subscriber in self._subscribers: subscriber(event) + @property + def has_subscribers(self) -> bool: + """True if at least one listener is subscribed to this event.""" + return len(self._subscribers) > 0 + class Subscriber: """