{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"# Cellular automata III: Ants\n",
"\n",
"---\n",
"\n",
"\n",
"\n",
"This notebook is licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load packages"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"%matplotlib inline\n",
"\n",
"import matplotlib.pyplot as plt\n",
"from matplotlib import animation, rc\n",
"from matplotlib.colors import LinearSegmentedColormap\n",
"import numpy as np\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"from IPython.display import HTML\n",
"\n",
"rc(\"animation\", html=\"html5\")\n",
"\n",
"np.random.seed(11897733)"
]
},
{
"cell_type": "markdown",
"metadata": {
"ein.tags": "worksheet-0",
"slideshow": {
"slide_type": "-"
}
},
"source": [
"## Initializing the System"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"def init_ants(n, prob_ant):\n",
" \"\"\"Initialize an n ⨉ n grid of ants.\n",
" \n",
" Parameters\n",
" ----------\n",
" n : int\n",
" Number of rows and columns in the grid\n",
"\n",
" prob_tree : float\n",
" Probability to initialize a cell with an ant\n",
" \n",
" Returns\n",
" -------\n",
" ants : np.array\n",
" Grid of integers defining the ant population\n",
" \"\"\"\n",
" ants = np.zeros(shape=(n, n), dtype=np.int)\n",
"\n",
" ant_cells = np.random.uniform(low=0, high=1, size=(n, n)) < prob_ant\n",
" number_ants = np.sum(ant_cells)\n",
"\n",
" ants[ant_cells] = np.random.randint(low=1, high=5, size=number_ants)\n",
"\n",
" return ants"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def init_pheromones(n, max_pheromone, trail_length, trail_start):\n",
" \"\"\"Initialize an n ⨉ n grid of pheromones.\n",
" \n",
" Parameters\n",
" ----------\n",
" n : int\n",
" Number of rows and columns in the grid\n",
"\n",
" max_pheromone : float\n",
" \n",
" trail_length : int\n",
" \n",
" trail_start : list-like\n",
" \n",
" Returns\n",
" -------\n",
" pheromones : np.array\n",
" Grid of floats defining the ant pheromones\n",
" \"\"\"\n",
" pheromones = np.zeros(shape=(n, n), dtype=np.float)\n",
"\n",
" trail_row = trail_start[0]\n",
" trail_start_column = trail_start[1]\n",
" trail_end_column = trail_start[1] + trail_length\n",
" \n",
" pheromones[trail_row, trail_start_column:trail_end_column] = np.linspace(\n",
" start=0,\n",
" stop=max_pheromone,\n",
" num=trail_end_column - trail_start_column)\n",
" \n",
" return pheromones"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's test that the above function creates the ants and pheromones grids, assuming that we have a 17 ⨉ 17 grid, a 10% chance that any given cell starts with an ant, and that a pheromone trail is laid down in the center row of the grid with values linearly increasing from 0 to 50 when going from the first column to the last column."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"ants = init_ants(17, 0.1)\n",
"pheromones = init_pheromones(17, 50, 17, [8, 0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To inspect that the grids were constructed correctly, we will utilize a heat map visualization.\n",
"For the ant grid, empty squares will be black, squares with ants will be orange, and border squares (not yet defined) will be gray.\n",
"For the pheromones grid, we apply the *viridis* colormap scheme."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def visualize_grid(grid, grid_type, fig_width=6, fig_height=6, dpi=120):\n",
" \"\"\"Visualize a 2D numpy array using a heatmap.\n",
"\n",
" Parameters\n",
" ----------\n",
" grid : np.array\n",
" A two-dimensional array representing the cellular automata grid\n",
" \n",
" grid_type : str\n",
" Sets the appropriate colormap by using 'discrete' or 'continuous'\n",
" \n",
" fig_width : float\n",
" Figure width in inches\n",
" \n",
" fig_height : float\n",
" Figure height in inches\n",
" \n",
" Returns\n",
" -------\n",
" fig, ax : tuple of plt.figure and plt.subplot\n",
" Matplotlib figure and subplot axis objects\n",
" \n",
" .. _colormaps: https://matplotlib.org/examples/color/colormaps_reference.html \n",
" \"\"\"\n",
" # grid dimensions\n",
" m, n = grid.shape\n",
"\n",
" # create matplotlib figure and subplot objects\n",
" fig, ax = plt.subplots(figsize=(fig_width, fig_height), dpi=dpi)\n",
"\n",
" # Define a custom color map, with 0 being black, 1 being tab:blue, and\n",
" # 2 being tab:orange\n",
" # imshow visualizes array as a two-dimensionl uniform grid\n",
" if grid_type == \"discrete\":\n",
" cmap = LinearSegmentedColormap.from_list(\n",
" 'ants', ['black', 'tab:orange', 'tab:orange', 'tab:orange',\n",
" 'tab:orange', 'tab:orange', 'gray'])\n",
" im = ax.imshow(grid, cmap=cmap, interpolation=\"nearest\", vmin=0,\n",
" vmax=6)\n",
" elif grid_type == \"continuous\":\n",
" cmap = \"viridis\"\n",
" im = ax.imshow(grid, cmap=cmap, interpolation=\"nearest\")\n",
"\n",
" # find the starting and ending coordinates for heatmap for creating\n",
" # grid lines\n",
" xticks_start, xticks_end = ax.get_xlim();\n",
" yticks_start, yticks_end = ax.get_ylim();\n",
"\n",
" # separate grid cells by white lines\n",
" ax.xaxis.set_ticks(np.linspace(xticks_start, xticks_end, n + 1),\n",
" minor=False);\n",
" ax.yaxis.set_ticks(np.linspace(yticks_start, yticks_end, m + 1),\n",
" minor=False);\n",
" ax.axes.grid(True, linestyle=\"-\", linewidth=0.3, color=\"white\",\n",
" which=\"major\");\n",
" \n",
" # we don't need ticks and tick labels because we have grid lines\n",
" ax.tick_params(labelbottom = False, labelleft=False, bottom=False,\n",
" left=False);\n",
" \n",
" # Return matplotlib figure and subplot objects\n",
" return fig, ax"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So, for our example, we get the following heatmap for the ants grid:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 576x576 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_grid(ants, \"discrete\", dpi=96);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And we get the following heatmap for the pheromones grid:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 576x576 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_grid(pheromones, \"continuous\", dpi=96);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is exactly what we expected to see."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boundary Conditions\n",
"\n",
"For the ants, we will implement **absorbing boundary conditions** using the standard **ghost cells** approach.\n",
"The following function sets up the ghost cells in `numpy`:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def boundary_condition(grid, constant_values, condition=\"absorbing\"):\n",
" \"\"\"Wrap grid with ghost cells for boundary condition.\n",
" \n",
" Parameters\n",
" ----------\n",
" grid : np.array\n",
" 2D Grid of integers or floats\n",
" \n",
" condition : str, optional\n",
" The boundary condition to use when creating ghost cells.\n",
" \"\"\"\n",
" if condition == \"absorbing\":\n",
" grid_with_border = np.pad(\n",
" array=grid, pad_width=(1, 1), mode='constant',\n",
" constant_values=constant_values)\n",
"\n",
" else:\n",
" raise ValueError(\n",
" \"{0} is not a valid boundary condition\".format(condition))\n",
"\n",
" return grid_with_border"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's test that the ghost cells work as expected.\n",
"We wish to wrap the `ants` grid with cells equal to `6`, which indicates the presence of a border.\n",
"We also wish to wrap the `pheromones` grid with cells equal to `-0.01`, which will prevent ants from entering a border cell."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"ants_extended = boundary_condition(ants, constant_values=6)\n",
"pheromones_extended = boundary_condition(pheromones, constant_values=-0.01)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To check that it worked, we visualize the ants grid with a border:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 576x576 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_grid(ants_extended, \"discrete\", dpi=96);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And we also visualize the pheromones grid:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 576x576 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"visualize_grid(pheromones_extended, \"continuous\", dpi=96);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Finding neighbors\n",
"\n",
"This simulation makes use of both the **Moore neighborhood** and the **von Neumann neighborhood**, with the diffusion of pheromones using **Moore** and an ant's sensing and walking stages using **von Neumann**.\n",
"We define a function that allows us to return both kinds of neighborhoods:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"def get_neighbors(extended_grid,\n",
" neighborhood,\n",
" ghost_width=(1, 1)):\n",
" \"\"\"Get the cellular state of each site's neighbors in a single sweep.\n",
" \n",
" Paramters\n",
" ---------\n",
" extended_grid : np.array\n",
" Grid defining states in a cellular automata simulation\n",
" \n",
" neighborhood : str, optional\n",
" Determines which cells will be counted as neighbors, set to either\n",
" 'moore' or 'von_neumann'\n",
" \n",
" ghost_width : array-like, optional\n",
" A number pair that specifies how many rows and columns make up the\n",
" ghost cell region\n",
" \n",
" Returns\n",
" -------\n",
" grid_with_neighbors : np.array\n",
" Grid containing the states of each cell's neighbors\n",
" \"\"\"\n",
" m_extended, n_extended = extended_grid.shape\n",
" m, n = (m_extended - ghost_width[0], n_extended - ghost_width[1])\n",
" \n",
" if neighborhood == \"von_neumann\":\n",
" grid_with_neighbors = np.array([\n",
" np.roll(\n",
" extended_grid, shift=(0, 1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(-1, 0),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(0, -1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(1, 0),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n]])\n",
"\n",
" elif neighborhood == \"moore\":\n",
" grid_with_neighbors = np.array([\n",
" np.roll(\n",
" extended_grid, shift=(1, 1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(0, 1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(-1, 1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(1, 0),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(-1, 0),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(-1, -1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(0, -1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n],\n",
" np.roll(\n",
" extended_grid, shift=(1, -1),\n",
" axis=(1, 0))[ghost_width[0]:m, ghost_width[1]:n]])\n",
"\n",
" else:\n",
" raise ValueError(\n",
" \"{0} is not a valid type of neighborhood\".format(neighborhood))\n",
"\n",
" return grid_with_neighbors"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Diffusion of pheromones"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"def diffusion(grid, neighbors, diffusion_rate):\n",
" \"\"\"Diffuse cells in grid for a single time step.\n",
" \n",
" Parameters\n",
" ----------\n",
" grid : np.array\n",
"\n",
" grid_neighbors : np.array\n",
" An array of temperatures for each site and its neighbors\n",
"\n",
" diffusion_rate : float\n",
" Sets ease of flow from high to low value cells in grid\n",
" \n",
" Returns\n",
" -------\n",
" grid_update : np.array\n",
" Updated grid after applying diffusion to all cells\n",
" \"\"\"\n",
" num_neighbors, m, n = neighbors.shape\n",
" \n",
" grid_update = (\n",
" (1 - num_neighbors * diffusion_rate) * grid +\n",
" diffusion_rate * np.sum(a=neighbors, axis=0))\n",
" grid_update[grid_update < 0] = 0\n",
"\n",
" return grid_update"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ant Movement\n",
"\n",
"Moving the ants around the grid occurs in two stages:\n",
"\n",
"1. Sensing stage: the ants sense the pheromones in the neighboring cells and change the direction they're facing\n",
"2. Walking stage: the ants move on the grid according to the direction selected in the sensing stage\n",
"\n",
"There are a set of rules governing each stage."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Sensing stage"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"During the sensing stage, the ants update their state according to the following rules:\n",
"\n",
"1. An empty cell does not point toward any direction\n",
"2. An ant does not turn to a cell from which the creature just came\n",
"3. An ant does not turn to a location that is a border site\n",
"4. An ant does not turn to a location that currently contains an ant\n",
"5. Otherwise, an ant turns in the direction of the neighboring available cell (not the previous, an occupied, or a border cell) with the greatest amount of chemical pheromone.\n",
" In the case of more than one neighbor having the maximum amount, the ant turns at random towards one of these cells.\n",
"6. If no neighboring cell is available, the ant will not move"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def sense_find_ants(ants, ants_neighbors, pheromones_neighbors):\n",
" m, n = ants.shape\n",
" previous_ants_state = ants.copy()\n",
" II, JJ = np.meshgrid(\n",
" np.arange(m), np.arange(n), indexing='ij')\n",
" ant_cells = np.logical_and(ants != 0, ants != 6)\n",
" ants_ij = np.column_stack((II[ant_cells], JJ[ant_cells]))\n",
" \n",
" return previous_ants_state, ants_ij"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"def sense_no_backtrack(ants, pheromones_neighbors, ij):\n",
" map_van_neumann_to_moore = {1: 1, 2: 4, 3: 6, 4: 3}\n",
" ant_state = ants[ij[0], ij[1]]\n",
" \n",
" if ant_state != 5:\n",
" pheromones_direction = map_van_neumann_to_moore[ant_state]\n",
" pheromones_neighbors[pheromones_direction, ij[0], ij[1]] = -2"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"def sense_detect_neighbors(ants, ants_neighbors, pheromones_neighbors, ij):\n",
" map_van_neumann_to_moore = {1: 1, 2: 4, 3: 6, 4: 3}\n",
" for direction, ant_neighbor in enumerate(ants_neighbors, start=1):\n",
" check_neighbor = ant_neighbor[ij[0], ij[1]]\n",
" ant_present = check_neighbor != 0\n",
" if ant_present:\n",
" pheromones_direction = map_van_neumann_to_moore[direction]\n",
" pheromones_neighbors[pheromones_direction, ij[0], ij[1]] = -2"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"def sense_detect_pheromones(pheromones_neighbors, ij):\n",
" pheromone_sense_list = np.array([\n",
" [1, pheromones_neighbors[1, ij[0], ij[1]]],\n",
" [2, pheromones_neighbors[4, ij[0], ij[1]]],\n",
" [3, pheromones_neighbors[6, ij[0], ij[1]]],\n",
" [4, pheromones_neighbors[3, ij[0], ij[1]]]\n",
" ])\n",
" \n",
" return pheromone_sense_list"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"def sense_choose_direction(pheromone_sense_list):\n",
" nesw_ant_directions = pheromone_sense_list[:, 0]\n",
" maximum_value = np.max(pheromone_sense_list[:, 1])\n",
" rows_containing_maximum_value = (\n",
" np.isclose(maximum_value, pheromone_sense_list[:, 1]))\n",
" directions_to_choose_from = (\n",
" nesw_ant_directions[rows_containing_maximum_value])\n",
" update_state = (\n",
" directions_to_choose_from\n",
" if directions_to_choose_from.shape[0] == 1\n",
" else np.random.choice(directions_to_choose_from))\n",
" \n",
" return np.int(update_state)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"def sense(ants, ants_neighbors, pheromones_neighbors):\n",
" previous_ants_state, ants_ij = (\n",
" sense_find_ants(ants, ants_neighbors, pheromones_neighbors))\n",
" \n",
" for ij in ants_ij:\n",
" sense_no_backtrack(ants, pheromones_neighbors, ij)\n",
" sense_detect_neighbors(ants, ants_neighbors, pheromones_neighbors, ij)\n",
" \n",
" pheromone_sense_list = sense_detect_pheromones(pheromones_neighbors, ij)\n",
" all_negative_pheromones_test = np.all(pheromone_sense_list < 0)\n",
" \n",
" if all_negative_pheromones_test:\n",
" update_state = 5\n",
" else:\n",
" update_state = sense_choose_direction(pheromone_sense_list)\n",
" \n",
" ants[ij[0], ij[1]] = update_state"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Walking stage\n",
"\n",
"After the sensing stage, the ants will then walk.\n",
"The pheromone grid will also receive an update prior to running the diffusion step.\n",
"The rules are as follows:\n",
"\n",
"1. For a cell that remains empty, the amount of chemical pheromone decrements by a constant amount `evaporate`, but does not fall below 0.\n",
" Thus, the new amount is the maximum of 0 and the current amount minus `evaporate`.\n",
"2. An ant facing in a certain direction will move into that neighboring cell as long as no other ant has already moved there\n",
"3. Otherwise, the ant will stay in its current cell\n",
"4. If an ant leaves a cell that has pheromone above a certain threshold, `threshold`, the amount of chemical pheromone increments by a set amount, `deposit`, to reinforce the trail\n",
"5. If an ant stays in a cell, the amount of chemical remains the same\n",
"6. After moving to a new location, the ant faces towards the cell from which the animal just came"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"def walk_find_ants(extended_ants):\n",
" m, n = extended_ants.shape\n",
" previous_ants_state = extended_ants.copy()\n",
" II, JJ = np.meshgrid(\n",
" np.arange(m), np.arange(n), indexing='ij')\n",
" moving_ant_cells = (\n",
" np.logical_and(extended_ants != 0, np.logical_and(extended_ants != 5, extended_ants != 6)))\n",
" extended_ants_ij = np.column_stack((II[moving_ant_cells], JJ[moving_ant_cells]))\n",
" np.random.shuffle(extended_ants_ij)\n",
" \n",
" return previous_ants_state, extended_ants_ij"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"def evaporate_pheromones(ants, previous_ants_state, pheromones, evaporate):\n",
" cells_remained_empty = np.logical_and(previous_ants_state == 0, ants == 0)\n",
" number_remaining_empty = np.sum(cells_remained_empty)\n",
" pheromones[cells_remained_empty] -= evaporate\n",
" pheromones[cells_remained_empty] = (\n",
" np.maximum(np.zeros(number_remaining_empty),\n",
" pheromones[cells_remained_empty]))"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"def deposit_pheromone(pheromones, ij, threshold, deposit):\n",
" if pheromones[ij[0], ij[1]] > threshold:\n",
" pheromones[ij[0], ij[1]] += deposit"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"def movement(ant_state, ij):\n",
" if ant_state == 1:\n",
" update_ij = ij + np.array([-1, 0])\n",
" elif ant_state == 2:\n",
" update_ij = ij + np.array([0, 1])\n",
" elif ant_state == 3:\n",
" update_ij = ij + np.array([1, 0])\n",
" elif ant_state == 4:\n",
" update_ij = ij + np.array([0, -1])\n",
" else:\n",
" raise ValueError(\n",
" \"{0} is not a valid ant state\".format(ant_state))\n",
" \n",
" return update_ij"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"def turn_around(ant_state):\n",
" if ant_state == 1:\n",
" new_state = 3\n",
" elif ant_state == 2:\n",
" new_state = 4\n",
" elif ant_state == 3:\n",
" new_state = 1\n",
" elif ant_state == 4:\n",
" new_state = 2\n",
" else:\n",
" raise ValueError(\n",
" \"{0} is not a valid ant state\".format(ant_state))\n",
" \n",
" return new_state"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"def walk(ants, pheromones, evaporate, threshold, deposit):\n",
" \"\"\"Update the ants and pheromones grids based on sensing step.\n",
" \n",
" \"\"\"\n",
" extended_ants = boundary_condition(ants, 6, condition=\"absorbing\")\n",
" extended_pheromones = boundary_condition(pheromones, -0.01, condition=\"absorbing\")\n",
" previous_ants_state, ants_ij = walk_find_ants(extended_ants)\n",
"\n",
" for ij in ants_ij:\n",
" ant_state = extended_ants[ij[0], ij[1]]\n",
" update_ij = movement(ant_state, ij)\n",
" neighboring_block = extended_ants[update_ij[0], update_ij[1]]\n",
" ant_blocking_move = neighboring_block != 0 & neighboring_block != 6\n",
"\n",
" if ant_blocking_move:\n",
" extended_ants[ij[0], ij[1]] = 5\n",
" else:\n",
" extended_ants[ij[0], ij[1]] = 0\n",
" deposit_pheromone(extended_pheromones, ij, threshold, deposit)\n",
" extended_ants[update_ij[0], update_ij[1]] = turn_around(ant_state)\n",
"\n",
" evaporate_pheromones(extended_ants, previous_ants_state, extended_pheromones, evaporate)\n",
" m, n = extended_ants.shape\n",
" ants[:, :] = extended_ants[1:(m - 1), 1:(n - 1)]\n",
" pheromones[:, :] = extended_pheromones[1:(m - 1), 1:(n - 1)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we sweep over all lattice points.\n",
"In addition to the spread routine defined above, we also append the updated grid to the `simulation_history` list so that we can animate the diffusion simulation."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Define a full time step\n",
"\n",
"Now we combine all our previous functions to define a single time step for the ants simulation:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"def time_step(ants, pheromones, evaporate, threshold, deposit, diffusion_rate,\n",
" nstep, simulation_history):\n",
" \"\"\"Execute a time step and update the ants and pheromones grids.\n",
" \n",
" Parameters\n",
" ----------\n",
" ants : np.array\n",
" \n",
" pheromones : np.array\n",
" \n",
" max_pheromones : float\n",
" \n",
" evaporate : float\n",
" \n",
" threshold : float\n",
" \n",
" deposit : float\n",
" \n",
" nstep : int\n",
" The current time step number for the simulation\n",
"\n",
" simulation_history : list\n",
" Time-step history for the simulation's run.\n",
" \"\"\"\n",
" extended_ants = boundary_condition(ants, constant_values=6)\n",
" extended_pheromones = boundary_condition(\n",
" pheromones, constant_values=-0.01)\n",
" ants_neighbors = get_neighbors(\n",
" extended_ants, neighborhood=\"von_neumann\")\n",
" pheromones_neighbors = get_neighbors(\n",
" extended_pheromones, neighborhood=\"moore\")\n",
"\n",
" sense(ants, ants_neighbors, pheromones_neighbors)\n",
" walk(ants, pheromones, evaporate, threshold, deposit)\n",
" pheromones[:, :] = diffusion(\n",
" pheromones, pheromones_neighbors, diffusion_rate)\n",
" \n",
" simulation_history.append([nstep, ants.copy(), pheromones.copy()])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Simulation Program\n",
"\n",
"Finally, we bring it all together into a function that runs the full simulation from start to finish.\n",
"This is where we put our `for` loop over time."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"def ants_simulation(number_time_steps, n, prob_ant, max_pheromone,\n",
" trail_length, trail_start, evaporate, threshold, deposit,\n",
" diffusion_rate):\n",
" \"\"\"Run the ants simulation.\n",
" \n",
" Parameters\n",
" ----------\n",
" number_time_steps : int\n",
" Sets the number of time steps over which to run a simulation.\n",
"\n",
" n : int\n",
" Number of rows and columns in the grid\n",
"\n",
" prob_ant : float\n",
"\n",
" max_pheromone : float\n",
" \n",
" trail_length : int\n",
" \n",
" trail_start : list-like\n",
" \n",
" evaporate : float\n",
" \n",
" threshold : float\n",
" \n",
" deposit : float\n",
"\n",
" Returns\n",
" -------\n",
" simulation_history : list\n",
" \"\"\"\n",
" # Initialize ants and pheromones according to parameters\n",
" ants = init_ants(n, prob_ant)\n",
" pheromones = init_pheromones(n, max_pheromone, trail_length, trail_start)\n",
"\n",
" # Initialize record keeper for the simulation history\n",
" simulation_history = [[0, ants.copy(), pheromones.copy()]]\n",
"\n",
" # Run simulation for specified number of time steps\n",
" for nstep in np.arange(number_time_steps):\n",
" time_step(ants, pheromones, evaporate, threshold, deposit,\n",
" diffusion_rate, nstep, simulation_history) \n",
"\n",
" return simulation_history"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Display Simulation\n",
"\n",
"Having successfully run our simulation, now we would like to see it in action!\n",
"We advance each frame of the animation by incrementing the index on `simulation_history` by 1."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"def ca_animation(simulation_history, fig_width=6, fig_height=6, dpi=120):\n",
" \"\"\"Animate the cellular automata simulation using Matplotlib.\n",
"\n",
" Parameters\n",
" ----------\n",
" simulation_history : list\n",
" Time-step history for the simulation's run.\n",
" \n",
" cmap : str, optional\n",
" Color scheme for the heatmap scale, see colormaps_ reference.\n",
" \n",
" fig_width : float, optional\n",
" Figure width in inches\n",
" \n",
" fig_height : float, optional\n",
" Figure height in inches\n",
" \n",
" Returns\n",
" -------\n",
" anim : matplotlib.animation.FuncAnimation\n",
" Animated object for the simulation run.\n",
" \n",
" .. _colormaps: https://matplotlib.org/examples/color/colormaps_reference.html \n",
" \"\"\"\n",
" # grid dimensions\n",
" m, n = simulation_history[0][1].shape\n",
"\n",
" # create matplotlib figure and subplot objects\n",
" fig, ax = plt.subplots(figsize=(fig_width, fig_height), dpi=dpi)\n",
"\n",
" # imshow visualizes array as a two-dimensionl uniform grid\n",
" cmap = LinearSegmentedColormap.from_list(\n",
" 'ants', [(0, 0, 0, 0), 'tab:orange', 'tab:orange', 'tab:orange',\n",
" 'tab:orange', 'tab:orange', 'gray'])\n",
" cmap2 = \"viridis\"\n",
" im2 = ax.imshow(simulation_history[0][2], cmap=cmap2, interpolation=\"nearest\", vmin=0)\n",
" im = ax.imshow(\n",
" simulation_history[0][1], cmap=cmap,interpolation=\"nearest\", alpha=0.8,\n",
" vmin=0, vmax=6)\n",
"\n",
" # find the starting and ending coordinates for heatmap for creating\n",
" # grid lines\n",
" xticks_start, xticks_end = ax.get_xlim();\n",
" yticks_start, yticks_end = ax.get_ylim();\n",
"\n",
" # separate grid cells by white lines\n",
" ax.xaxis.set_ticks(np.linspace(xticks_start, xticks_end, n + 1),\n",
" minor=False);\n",
" ax.yaxis.set_ticks(np.linspace(yticks_start, yticks_end, m + 1),\n",
" minor=False);\n",
" ax.axes.grid(True, linestyle=\"-\", linewidth=0.3, color=\"white\",\n",
" which=\"major\");\n",
" \n",
" # we don't need ticks and tick labels because we have grid lines\n",
" ax.tick_params(labelbottom = False, labelleft=False, bottom=False,\n",
" left=False);\n",
" \n",
" # Initialization function, clears out the data on the im object\n",
" def init():\n",
" im2.set_array(np.array([[]]))\n",
" im.set_array(np.array([[]]))\n",
" return (im, im2, )\n",
"\n",
"\n",
" # Animation function. Input i is the frame number of the animation, and is\n",
" # to be used for referencing how the data changes over time\n",
" def animate(i):\n",
" # Get the simulation history at time step i and set as the underlying\n",
" # data for the im object\n",
" ants_i = simulation_history[i][1]\n",
" pheromones_i = simulation_history[i][2]\n",
" im2.set_array(pheromones_i)\n",
" im.set_array(ants_i)\n",
"\n",
" return (im, im2, )\n",
"\n",
" # Suppress static matplotlib window\n",
" plt.close()\n",
" \n",
" # Use animation.FuncAnimation to put the animation together.\n",
" # frames controls the number of frames in the movie.\n",
" # interval controls the delay in milliseconds inbetween each frame\n",
" # blit optimizes the animation size by only storing the changes between\n",
" # frames instead of as a series of full plots\n",
" anim = animation.FuncAnimation(fig=fig, func=animate,\n",
" frames=len(simulation_history),\n",
" init_func=init, interval=500, blit=True);\n",
"\n",
" return anim"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example Run\n",
"\n",
"Now that all the pieces are in place, let's run the simulation with the following initial parameters, which match the parameters suggested in the textbook."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"number_time_steps = 30\n",
"n = 17\n",
"prob_ant = 0.1\n",
"max_pheromone = 50\n",
"trail_length = 17\n",
"trail_start = [8, 0]\n",
"evaporate = 1\n",
"deposit = 2\n",
"threshold = 0\n",
"diffusion_rate = 0.01\n",
"simulation_history = ants_simulation(\n",
" number_time_steps, n, prob_ant, max_pheromone,\n",
" trail_length, trail_start, evaporate, threshold, deposit,\n",
" diffusion_rate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We then build our animation:"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"anim = ca_animation(simulation_history, dpi=120)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And view it:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"HTML(anim.to_html5_video())"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.6.5"
},
"latex_envs": {
"LaTeX_envs_menu_present": true,
"autocomplete": true,
"bibliofile": "biblio.bib",
"cite_by": "apalike",
"current_citInitial": 1,
"eqLabelWithNumbers": true,
"eqNumInitial": 1,
"hotkeys": {
"equation": "Ctrl-E",
"itemize": "Ctrl-I"
},
"labels_anchors": false,
"latex_user_defs": false,
"report_style_numbering": false,
"user_envs_cfg": false
},
"name": "module_10-3_spreading_of_fire.ipynb",
"varInspector": {
"cols": {
"lenName": 16,
"lenType": 16,
"lenVar": 40
},
"kernels_config": {
"python": {
"delete_cmd_postfix": "",
"delete_cmd_prefix": "del ",
"library": "var_list.py",
"varRefreshCmd": "print(var_dic_list())"
},
"r": {
"delete_cmd_postfix": ") ",
"delete_cmd_prefix": "rm(",
"library": "var_list.r",
"varRefreshCmd": "cat(var_dic_list()) "
}
},
"position": {
"height": "750px",
"left": "2190px",
"right": "20px",
"top": "121px",
"width": "362px"
},
"types_to_exclude": [
"module",
"function",
"builtin_function_or_method",
"instance",
"_Feature"
],
"window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}