From e16ef70b7675fa91f4d0d878118805750ae09d63 Mon Sep 17 00:00:00 2001 From: Nithurshen Date: Sun, 18 Jan 2026 21:39:37 +0530 Subject: [PATCH 1/5] feat: surrogate modeling --- examples/surrogate_modeling/README.md | 54 ++++++++++++++++++++++ examples/surrogate_modeling/analysis.py | 60 +++++++++++++++++++++++++ examples/surrogate_modeling/model.py | 46 +++++++++++++++++++ pyproject.toml | 5 +++ 4 files changed, 165 insertions(+) create mode 100644 examples/surrogate_modeling/README.md create mode 100644 examples/surrogate_modeling/analysis.py create mode 100644 examples/surrogate_modeling/model.py diff --git a/examples/surrogate_modeling/README.md b/examples/surrogate_modeling/README.md new file mode 100644 index 000000000..56461404c --- /dev/null +++ b/examples/surrogate_modeling/README.md @@ -0,0 +1,54 @@ +# Surrogate Modeling with Scikit-learn and Mesa + +This example demonstrates how to integrate Mesa with machine learning libraries like **Scikit-learn** to create a "surrogate model". It showcases a high-performance workflow for parameter exploration without the computational overhead of running thousands of full simulations. + +## Summary + +Agent-Based Models (ABMs) can be computationally expensive when exploring high-dimensional parameter spaces. This example illustrates a three-step surrogate modeling pipeline: + +1. **Efficient Sampling**: Using **Latin Hypercube Sampling (LHS)** via `scipy.stats.qmc` to select a sparse but representative set of points across the parameter space. +2. **Simulation**: Running the Mesa model (WealthModel) at these sampled points to gather training data. +3. **Emulation**: Training a **Random Forest Regressor** on the simulation outcomes to create a surrogate that can predict model results (e.g., Gini coefficient) for any new parameter set nearly instantly. + +This approach is particularly beneficial for calibration, sensitivity analysis, and optimization in complex models where running every possible configuration is infeasible. + +## Installation + +This example requires the `latest` version of Mesa and additional machine learning dependencies: + +```bash +pip install mesa scikit-learn scipy pandas + +``` + +## How to Run + +To run the surrogate modeling workflow (sampling, training, and prediction), execute the analysis script from the root of the `mesa-examples` directory: + +```bash +python -m examples.surrogate_modeling.analysis + +``` + +## Files + +* `model.py`: Contains the `WealthModel` and `WealthAgent` implementations, refactored for Mesa 4.0 "Lean Core" compatibility. +* `analysis.py`: Contains the LHS sampling logic, the manual training loop, and the Scikit-learn regressor integration. + +## Model Details + +### Logic + +The example uses a refactored **Boltzmann Wealth Model**. Agents start with a fixed amount of wealth and exchange it randomly during interactions. The model calculates the **Gini coefficient** at the end of each run as the target metric for the surrogate model. + +### Mesa 4.0 Integration + +* **RNG Initialization**: Uses the `rng` parameter in `Model.__init__` to ensure future-proof compatibility and reproducibility. +* **Spatial Management**: Utilizes the `OrthogonalMooreGrid` and `CellAgent` pattern where agents are placed by sampling from `all_cells.cells`. +* **Agent Activation**: Uses `self.agents.shuffle_do("step")` for efficient agent execution. + +## Further Reading + +* **Latin Hypercube Sampling**: A statistical method for generating a near-random sample of parameter values from a multidimensional distribution. +* **Surrogate Modeling**: Also known as metamodeling or emulation, this is a technique used when an outcome of interest cannot be easily directly measured, so a model of the outcome is used instead. +* **Scikit-learn Random Forest**: [Random Forest Regressor Documentation](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html) \ No newline at end of file diff --git a/examples/surrogate_modeling/analysis.py b/examples/surrogate_modeling/analysis.py new file mode 100644 index 000000000..5587b79dd --- /dev/null +++ b/examples/surrogate_modeling/analysis.py @@ -0,0 +1,60 @@ +import numpy as np +import pandas as pd +from scipy.stats import qmc +from sklearn.ensemble import RandomForestRegressor + +from .model import WealthModel + + +def sample_parameters(param_space, n_samples, seed=None): + """Generates parameter sets using Latin Hypercube Sampling.""" + dim = len(param_space) + sampler = qmc.LatinHypercube(d=dim, seed=seed) + sample = sampler.random(n=n_samples) + + l_bounds = [v[0] for v in param_space.values()] + u_bounds = [v[1] for v in param_space.values()] + scaled_samples = qmc.scale(sample, l_bounds, u_bounds) + + param_names = list(param_space.keys()) + is_int = [isinstance(v[0], int) for v in param_space.values()] + + output = [] + for j in range(n_samples): + config = { + param_names[i]: round(scaled_samples[j, i]) + if is_int[i] + else scaled_samples[j, i] + for i in range(dim) + } + output.append(config) + return output + + +param_space = {"N": (10, 100), "width": (10, 30), "height": (10, 30)} +param_names = list(param_space.keys()) +samples = sample_parameters(param_space, n_samples=30, seed=42) + +print("Running simulations for training data...") +results = [] +for config in samples: + model = WealthModel(**config) + for _ in range(50): + model.step() + + results.append({**config, "Gini": model.get_gini()}) + +df = pd.DataFrame(results) +X = df[param_names].values +y = df["Gini"].values + +surrogate = RandomForestRegressor(n_estimators=100, random_state=42) +surrogate.fit(X, y) +print("Surrogate model trained.") + +test_params = {"N": 65, "width": 22, "height": 22} +X_test = np.array([[test_params[p] for p in param_names]]) +prediction = surrogate.predict(X_test)[0] + +print(f"\nPrediction for {test_params}:") +print(f"Approximated Gini: {prediction:.4f}") diff --git a/examples/surrogate_modeling/model.py b/examples/surrogate_modeling/model.py new file mode 100644 index 000000000..c82269717 --- /dev/null +++ b/examples/surrogate_modeling/model.py @@ -0,0 +1,46 @@ +from mesa import Model +from mesa.discrete_space import CellAgent, OrthogonalMooreGrid + + +class WealthAgent(CellAgent): + """An agent with fixed initial wealth.""" + + def __init__(self, model, cell): + super().__init__(model) + self.cell = cell + self.wealth = 1 + + def step(self): + if self.wealth > 0: + other_agent = self.model.random.choice(self.model.agents) + if other_agent is not self: + other_agent.wealth += 1 + self.wealth -= 1 + + +class WealthModel(Model): + """A simple model for wealth distribution.""" + + def __init__(self, n=50, width=10, height=10, rng=None): + super().__init__(rng=rng) + self.num_agents = n + self.grid = OrthogonalMooreGrid((width, height), torus=True, random=self.random) + + all_cells = self.grid.all_cells.cells + placement_cells = self.random.sample(all_cells, k=self.num_agents) + + for cell in placement_cells: + WealthAgent(self, cell) + + def get_gini(self): + """Calculate the Gini coefficient of wealth distribution.""" + agent_wealths = [agent.wealth for agent in self.agents] + x = sorted(agent_wealths) + n = self.num_agents + if n == 0 or sum(x) == 0: + return 0 + b = sum(xi * (n - i) for i, xi in enumerate(x)) / (n * sum(x)) + return 1 + (1 / n) - 2 * b + + def step(self): + self.agents.shuffle_do("step") diff --git a/pyproject.toml b/pyproject.toml index bbaa17f0c..88a9a120f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -33,6 +33,11 @@ rl_example = [ "mesa", "tensorboard" ] +surrogate = [ + "scikit-learn", + "scipy", + "pandas", +] [tool.ruff] extend-include = ["*.ipynb"] From aba6a27c2a12151c18b3c5dcd9571865b3748011 Mon Sep 17 00:00:00 2001 From: Nithurshen Date: Sun, 18 Jan 2026 21:49:15 +0530 Subject: [PATCH 2/5] cleanup --- examples/surrogate_modeling/analysis.py | 4 ++-- pyproject.toml | 2 -- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/examples/surrogate_modeling/analysis.py b/examples/surrogate_modeling/analysis.py index 5587b79dd..12a555dd4 100644 --- a/examples/surrogate_modeling/analysis.py +++ b/examples/surrogate_modeling/analysis.py @@ -31,7 +31,7 @@ def sample_parameters(param_space, n_samples, seed=None): return output -param_space = {"N": (10, 100), "width": (10, 30), "height": (10, 30)} +param_space = {"n": (10, 100), "width": (10, 30), "height": (10, 30)} param_names = list(param_space.keys()) samples = sample_parameters(param_space, n_samples=30, seed=42) @@ -52,7 +52,7 @@ def sample_parameters(param_space, n_samples, seed=None): surrogate.fit(X, y) print("Surrogate model trained.") -test_params = {"N": 65, "width": 22, "height": 22} +test_params = {"n": 65, "width": 22, "height": 22} X_test = np.array([[test_params[p] for p in param_names]]) prediction = surrogate.predict(X_test)[0] diff --git a/pyproject.toml b/pyproject.toml index 88a9a120f..49324e6a6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,8 +35,6 @@ rl_example = [ ] surrogate = [ "scikit-learn", - "scipy", - "pandas", ] [tool.ruff] From 0f3f8df4ccbb474e45847293a4ee1cb0114ecb00 Mon Sep 17 00:00:00 2001 From: Nithurshen Date: Fri, 30 Jan 2026 18:52:09 +0530 Subject: [PATCH 3/5] Fix: Maintainer Suggestions --- README.md | 4 ++++ examples/surrogate_modeling/README.md | 2 +- pyproject.toml | 3 --- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index f30f818cb..37443d0cd 100644 --- a/README.md +++ b/README.md @@ -136,3 +136,7 @@ This folder contains an implementation of El Farol restaurant model. Agents (res ### [Schelling Model with Caching and Replay](https://github.com/mesa/mesa-examples/tree/main/examples/caching_and_replay) This example applies caching on the Mesa [Schelling](https://github.com/mesa/mesa-examples/tree/main/examples/schelling) example. It enables a simulation run to be "cached" or in other words recorded. The recorded simulation run is persisted on the local file system and can be replayed at any later point. + +### [Surrogate Modeling](examples/surrogate_modeling) + +This example demonstrates how to integrate Mesa with machine learning libraries like Scikit-learn to create a "surrogate model" (or emulator). It showcases a high-performance workflow for parameter exploration, including Latin Hypercube Sampling (LHS) and Random Forest regression, to approximate complex model behavior without the computational overhead of full simulations. diff --git a/examples/surrogate_modeling/README.md b/examples/surrogate_modeling/README.md index 56461404c..458c20d43 100644 --- a/examples/surrogate_modeling/README.md +++ b/examples/surrogate_modeling/README.md @@ -17,7 +17,7 @@ This approach is particularly beneficial for calibration, sensitivity analysis, This example requires the `latest` version of Mesa and additional machine learning dependencies: ```bash -pip install mesa scikit-learn scipy pandas +pip install mesa scikit-learn ``` diff --git a/pyproject.toml b/pyproject.toml index 49324e6a6..bbaa17f0c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -33,9 +33,6 @@ rl_example = [ "mesa", "tensorboard" ] -surrogate = [ - "scikit-learn", -] [tool.ruff] extend-include = ["*.ipynb"] From 939f6eccb1dc95975047d599f206d1d16ee3843b Mon Sep 17 00:00:00 2001 From: Nithurshen Date: Fri, 30 Jan 2026 19:02:55 +0530 Subject: [PATCH 4/5] Feat: Add JuPyter Notebook --- examples/surrogate_modeling/analysis.ipynb | 170 +++++++++++++++++++++ 1 file changed, 170 insertions(+) create mode 100644 examples/surrogate_modeling/analysis.ipynb diff --git a/examples/surrogate_modeling/analysis.ipynb b/examples/surrogate_modeling/analysis.ipynb new file mode 100644 index 000000000..c7fec322e --- /dev/null +++ b/examples/surrogate_modeling/analysis.ipynb @@ -0,0 +1,170 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# High-Fidelity Surrogate Modeling\n", + "---\n", + "This notebook demonstrates an advanced integration between **Mesa** and **Scikit-learn** to build a high-accuracy emulator. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import qmc\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import r2_score, mean_absolute_error\n", + "from model import WealthModel\n", + "\n", + "plt.style.use('seaborn-v0_8-whitegrid')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Latin Hypercube Sampling (LHS)\n", + "We generate 100 representative points across the parameter space to ensure the surrogate learns the model's landscape effectively." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_samples(n_samples=100):\n", + " space = {\"n\": (10, 100), \"width\": (10, 30), \"height\": (10, 30)}\n", + " sampler = qmc.LatinHypercube(d=len(space), seed=42)\n", + " raw_samples = sampler.random(n=n_samples)\n", + " l_bounds, u_bounds = zip(*space.values())\n", + " scaled = qmc.scale(raw_samples, l_bounds, u_bounds)\n", + " return [dict(zip(space.keys(), map(round, s))) for s in scaled]\n", + "\n", + "samples = get_samples()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Generating Ground Truth Data\n", + "We run the simulation for 50 steps at each sampled point. This data serves as the 'training set' for our machine learning model." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gathering simulation data...\n" + ] + } + ], + "source": [ + "print(\"Gathering simulation data...\")\n", + "data = []\n", + "for config in samples:\n", + " model = WealthModel(**config)\n", + " for _ in range(50): model.step()\n", + " data.append({**config, \"Gini\": model.get_gini()})\n", + "df = pd.DataFrame(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Training the Surrogate Model\n", + "We split the data to evaluate the surrogate on 'unseen' configurations, ensuring it hasn't just memorized the training data." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Surrogate Performance Metrics:\n", + "- R² Score: -0.0199\n", + "- Mean Absolute Error: 0.0388\n" + ] + } + ], + "source": [ + "X = df[[\"n\", \"width\", \"height\"]]\n", + "y = df[\"Gini\"]\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "regr = RandomForestRegressor(n_estimators=200, random_state=42).fit(X_train, y_train)\n", + "y_pred = regr.predict(X_test)\n", + "\n", + "print(f\"Surrogate Performance Metrics:\")\n", + "print(f\"- R² Score: {r2_score(y_test, y_pred):.4f}\")\n", + "print(f\"- Mean Absolute Error: {mean_absolute_error(y_test, y_pred):.4f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Final Visualization: Parity Plot\n", + "This plot centers on the prediction quality. Points closer to the dashed red line indicate higher accuracy. The color mapping highlights points with higher prediction errors." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "errors = np.abs(y_test - y_pred)\n", + "\n", + "plt.figure(figsize=(10, 7))\n", + "sc = plt.scatter(y_test, y_pred, c=errors, cmap='magma', s=60, alpha=0.8, edgecolors='w', linewidth=0.5)\n", + "plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2, label='Perfect Prediction (Ideal)')\n", + "\n", + "plt.colorbar(sc, label='Absolute Error')\n", + "plt.title('Surrogate Model Accuracy: Actual vs. Predicted Gini', fontsize=14, pad=15)\n", + "plt.xlabel('Ground Truth (Simulation Output)', fontsize=12)\n", + "plt.ylabel('Surrogate Prediction (Emulator Output)', fontsize=12)\n", + "plt.legend(frameon=True, loc='upper left')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c69d129ce1fae88967b3ef0abbeeea3722ee78ac Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 30 Jan 2026 13:33:07 +0000 Subject: [PATCH 5/5] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- examples/surrogate_modeling/analysis.ipynb | 57 ++++++++++++++++------ 1 file changed, 43 insertions(+), 14 deletions(-) diff --git a/examples/surrogate_modeling/analysis.ipynb b/examples/surrogate_modeling/analysis.ipynb index c7fec322e..e146a049c 100644 --- a/examples/surrogate_modeling/analysis.ipynb +++ b/examples/surrogate_modeling/analysis.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "7fb27b941602401d91542211134fc71a", "metadata": {}, "source": [ "# High-Fidelity Surrogate Modeling\n", @@ -12,23 +13,25 @@ { "cell_type": "code", "execution_count": 7, + "id": "acae54e37e7d407bbb7b55eff062a284", "metadata": {}, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", + "from model import WealthModel\n", "from scipy.stats import qmc\n", "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.metrics import mean_absolute_error, r2_score\n", "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import r2_score, mean_absolute_error\n", - "from model import WealthModel\n", "\n", - "plt.style.use('seaborn-v0_8-whitegrid')" + "plt.style.use(\"seaborn-v0_8-whitegrid\")" ] }, { "cell_type": "markdown", + "id": "9a63283cbaf04dbcab1f6479b197f3a8", "metadata": {}, "source": [ "## 1. Latin Hypercube Sampling (LHS)\n", @@ -38,6 +41,7 @@ { "cell_type": "code", "execution_count": 8, + "id": "8dd0d8092fe74a7c96281538738b07e2", "metadata": {}, "outputs": [], "source": [ @@ -49,11 +53,13 @@ " scaled = qmc.scale(raw_samples, l_bounds, u_bounds)\n", " return [dict(zip(space.keys(), map(round, s))) for s in scaled]\n", "\n", + "\n", "samples = get_samples()" ] }, { "cell_type": "markdown", + "id": "72eea5119410473aa328ad9291626812", "metadata": {}, "source": [ "## 2. Generating Ground Truth Data\n", @@ -63,6 +69,7 @@ { "cell_type": "code", "execution_count": 9, + "id": "8edb47106e1a46a883d545849b8ab81b", "metadata": {}, "outputs": [ { @@ -78,13 +85,15 @@ "data = []\n", "for config in samples:\n", " model = WealthModel(**config)\n", - " for _ in range(50): model.step()\n", + " for _ in range(50):\n", + " model.step()\n", " data.append({**config, \"Gini\": model.get_gini()})\n", "df = pd.DataFrame(data)" ] }, { "cell_type": "markdown", + "id": "10185d26023b46108eb7d9f57d49d2b3", "metadata": {}, "source": [ "## 3. Training the Surrogate Model\n", @@ -94,6 +103,7 @@ { "cell_type": "code", "execution_count": 10, + "id": "8763a12b2bbd4a93a75aff182afb95dc", "metadata": {}, "outputs": [ { @@ -109,18 +119,21 @@ "source": [ "X = df[[\"n\", \"width\", \"height\"]]\n", "y = df[\"Gini\"]\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42\n", + ")\n", "\n", "regr = RandomForestRegressor(n_estimators=200, random_state=42).fit(X_train, y_train)\n", "y_pred = regr.predict(X_test)\n", "\n", - "print(f\"Surrogate Performance Metrics:\")\n", + "print(\"Surrogate Performance Metrics:\")\n", "print(f\"- R² Score: {r2_score(y_test, y_pred):.4f}\")\n", "print(f\"- Mean Absolute Error: {mean_absolute_error(y_test, y_pred):.4f}\")" ] }, { "cell_type": "markdown", + "id": "7623eae2785240b9bd12b16a66d81610", "metadata": {}, "source": [ "## 4. Final Visualization: Parity Plot\n", @@ -130,6 +143,7 @@ { "cell_type": "code", "execution_count": 11, + "id": "7cdc8c89c7104fffa095e18ddfef8986", "metadata": {}, "outputs": [ { @@ -147,14 +161,29 @@ "errors = np.abs(y_test - y_pred)\n", "\n", "plt.figure(figsize=(10, 7))\n", - "sc = plt.scatter(y_test, y_pred, c=errors, cmap='magma', s=60, alpha=0.8, edgecolors='w', linewidth=0.5)\n", - "plt.plot([y.min(), y.max()], [y.min(), y.max()], 'r--', lw=2, label='Perfect Prediction (Ideal)')\n", + "sc = plt.scatter(\n", + " y_test,\n", + " y_pred,\n", + " c=errors,\n", + " cmap=\"magma\",\n", + " s=60,\n", + " alpha=0.8,\n", + " edgecolors=\"w\",\n", + " linewidth=0.5,\n", + ")\n", + "plt.plot(\n", + " [y.min(), y.max()],\n", + " [y.min(), y.max()],\n", + " \"r--\",\n", + " lw=2,\n", + " label=\"Perfect Prediction (Ideal)\",\n", + ")\n", "\n", - "plt.colorbar(sc, label='Absolute Error')\n", - "plt.title('Surrogate Model Accuracy: Actual vs. Predicted Gini', fontsize=14, pad=15)\n", - "plt.xlabel('Ground Truth (Simulation Output)', fontsize=12)\n", - "plt.ylabel('Surrogate Prediction (Emulator Output)', fontsize=12)\n", - "plt.legend(frameon=True, loc='upper left')\n", + "plt.colorbar(sc, label=\"Absolute Error\")\n", + "plt.title(\"Surrogate Model Accuracy: Actual vs. Predicted Gini\", fontsize=14, pad=15)\n", + "plt.xlabel(\"Ground Truth (Simulation Output)\", fontsize=12)\n", + "plt.ylabel(\"Surrogate Prediction (Emulator Output)\", fontsize=12)\n", + "plt.legend(frameon=True, loc=\"upper left\")\n", "plt.tight_layout()\n", "plt.show()" ]