{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Collect and Plotting Statistics" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This tutorial explains how to collect and plot runtime statistics in two ways:\n", "\n", "* [The Manual Approach](#The-Manual-Approach): Collecting fitness values directly from individuals.\n", "\n", "* [Automating with Watcher](#Automating-with-Watcher): Collecting and reporting fitness values using the `evokit.watch` module." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import random\n", "random.seed(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Construct an Algorithm\n", "\n", "For convenience, this tutorial uses a pre-built algorithm that uses the following components.\n", "\n", "| Component | Choice |\n", "| ---------- | -------------------- |\n", "| Individual | Binary string |\n", "| Evaluator | OneMax |\n", "| Selector | Elitist truncation |\n", "| Variator | Mutation ($p=0.2$) |\n", "\n", "To mimic the size of a practical problem, let's use the following hyperparameters. All choices are defined as constants in the following cell; please adjust them as you see fit.\n", "\n", "| Parameter | Choice |\n", "| --------------- | ------ |\n", "| Population size | 1000 |\n", "| Individual size | 10000 |\n", "| Epochs | 30 |" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "MUTATION_P: float = 0.2\n", "STEP_COUNT: int = 30\n", "POP_SIZE: int = 1000\n", "IND_SIZE: int = 10000\n", "\n", "from evokit.evolvables.prefabs import make_onemax" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Manual Approach\n", "\n", "Let's begin with collecting and plotting fitness values by hand. Recall (from the [Algorithm tutorial](./algorithm.ipynb)) how everything falls into place:\n", "\n", "* The algorithm returned by `make_onemax` is an instance of `HomogenousAlgorithm`, which means it has one `.population`.\n", "\n", "* The `.population` is an instance of `Population`, which means it is a collection of individuals.\n", "\n", "* Each individual is an instance of `BitString`, a subclass of `Individual`. All subclasses of `Individual` inherits the `.fitness` attribute.\n", "\n", "We want to plot the fitness value of the individual with the highest `.population`. `Population.best(...)` conveniently returns one such individual; we need only collect and plot its `.fitness`." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "best_fitnesses: list[float] = []\n", "\n", "algo = make_onemax(POP_SIZE,\n", " IND_SIZE,\n", " MUTATION_P,\n", " max_parents=0)\n", "\n", "for _ in range(STEP_COUNT):\n", " algo.step()\n", " best_fitnesses.append(algo.population.best().fitness[0])\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(range(STEP_COUNT), best_fitnesses)\n", "plt.xlabel(\"Generation\")\n", "plt.ylabel(\"Best Fitness in Generation\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Automating with Watcher\n", "\n", "The `evokit.watch` module can help collect and report runtime statistics. Compared to the manual, a `watch.Watcher` can run as soon as events happen, work with a wide range of algorithms, and report data in a easily comparable format.\n", "\n", "Components of the module fall into into three categories:\n", "\n", "1. The `Watcher` class, which can both\n", " \n", " a. be called to create simple watchers with custom handlers and\n", " \n", " b. serve as a base class for more complex watchers.\n", "\n", "2. The `.visualier` submodule, which contains tools for plotting collected records.\n", "\n", "3. Stock watchers that collect, for example, cpu and memory usage.\n", "\n", "This tutorial mainly discusses #1.a and #2." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inspecting Available Events\n", "\n", "The `watch` module performs its function with the `Watcher` class. A `Watcher` can be attached to an `Algorithm` and respond to certain events fired by the algorithm. Please see the [Algorithm tutorial](./algorithm.ipynb) for how an algorithm fires events.\n", "\n", "From the user's perspective, an algorithm can only fire events it declares in `.events` and `.automatic_events`. Let's check these!" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "events: ['POST_VARIATION', 'POST_EVALUATION', 'POST_SELECTION']; automatic events: ('POST_STEP',)\n" ] } ], "source": [ "algo_2 = make_onemax(POP_SIZE,\n", " IND_SIZE,\n", " MUTATION_P,\n", " max_parents=0)\n", "\n", "print(f\"events: {algo_2.events};\"\n", " f\" automatic events: {algo_2.automatic_events}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These attributes correspond to two sorts of events:\n", "\n", "* `.events` contain manual events. These events can be fired by calling `.update` (typically from inside `.step(...)`).\n", "\n", "* `.automatic_events` are fired regardless of how the algorithm is coded. For example, `POST_STEP` fires after `.step(...)` is called but before control returns to the caller.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Crafting an Watcher" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An watcher must be created with `accounting.Watcher`. The constructor can take five parameters:\n", "\n", "1. A list of `events` that can trigger collection.\n", "\n", "2. A callable `handler` that collects data from the associated algorithm\n", "\n", "3. An optional `stride` that can space out collections\n", "\n", "4. An optional, position-only `watch_post_step` that decides if the watcher triggers on `STEP_END`. The last parameter is there for convenience: setting `watch_post_step` to `True` has the same effect as adding `STEP_END` to `events`.\n", "\n", "5. An optional, keyword-only `timer`. The default `time.process_time`, while useful for HPC tasks, records the CPU time, which can be much shorter than the actual run time. Let's use `time.perf_counter` to drag things out a little.\n", "\n", "Let's declare an `Watcher` that collects the best fitness from a population only after a step ends. As the type hint shows, the watcher collects...\n", "\n", "* ... from a `SimpleLinearAlgorithm` of `BitString`s,\n", "\n", "* a fitness value of type `float`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from evokit.watch import Watcher\n", "from evokit.evolvables.algorithms import SimpleLinearAlgorithm\n", "from evokit.evolvables.bitstring import BitString\n", "import time\n", "\n", "fit_acc = Watcher[SimpleLinearAlgorithm[BitString], float](\n", " events=SimpleLinearAlgorithm.events,\n", " handler=lambda algo: algo.population.best().fitness[0],\n", " watch_post_step=True,\n", " timer=time.process_time)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Registering a Watcher\n", "\n", "Once constructed, the watcher can be registered with an algorithm by calling `Algorithm.register(...)`.\n", "\n", "Internally, `Algorithm.register(...)` calls `Watcher.subscribe(...)` so that the algorithm and the watcher reference each other [^1]. The following figure illustrates this:\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "algo_2.register(fit_acc)\n", "\n", "assert fit_acc in algo_2.watchers\n", "assert algo_2 is fit_acc.subject" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Collecting Statistics" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that everything is in place, let's run the algorithm and see what happens!\n", "\n", "When an event fires in the Algorithm, it calls `Algorithm.update` which calls `Watcher.update` for each watcher in the algorithm's `.watchers`. Then, the watcher collects statistics from its `.subject` only if either (a) the event is in its `.events` or (b) the watcher's `.watch_post_step` is `True` and the event is `POST_STEP`.\n", "\n", "\n", "\n", "Because `POST_STEP` triggers only at the end of each `.step(...)`, it's good practice to fire it at the beginning so that we know how things started. Here goes:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "algo_2.update(\"POST_STEP\")\n", "for _ in range(STEP_COUNT):\n", " algo_2.step()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To inspect what data the watcher has collected, call `Watcher.report(...)`. Note that records collected immediately after `POST_VARIATION` have `value=nan`. This is because the variator resets the fitness values of all." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[WatcherRecord(event='POST_STEP', generation=0, value=nan, time=0.6875),\n", " WatcherRecord(event='POST_VARIATION', generation=0, value=nan, time=0.6875),\n", " WatcherRecord(event='POST_EVALUATION', generation=0, value=5180, time=0.6875),\n", " WatcherRecord(event='POST_SELECTION', generation=0, value=5180, time=0.703125)]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fit_acc.report()[:4]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting\n", "\n", "The `watch.visual` module has tools to plot data from a `Watcher`. Give it a try! Note that data points are plotted against time. This should make it easier to compare performance.\n", "\n", "For simplicity, only end-of-generation fitness values are plotted here. The next section will be much more interesting." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from evokit.watch.visual import plot\n", "\n", "plot([x for x in fit_acc.report() if x.event == \"POST_STEP\"],\n", " show_generation=True,)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now the fun begins. Recall that this experiment uses a rather ambitious mutation rate and an elitist selector. The high mutation rate increases the possibility that offspring have a lower best fitness than the parents, but the elitist selector ensures that the best parent is always retained, preventing a generational decline in fitness.\n", "\n", "The following cell plots three figures to reflect this:\n", "\n", "* The first figure shows what could be collected with the manual approach. As we only have access to the population outside of `.step(...)`, there is not much chance to observe how an elitist selector operates.\n", "\n", "* The second figure plots all observed fitnesses. Here, each \"hockey stick\" shows where the elitist selector updates the population with the best parent.\n", "\n", "* The third figure, using `watch.visual.plot`, plots all data points against time. We see that generations often take different amounts of time, and that the elitist mechanism takes less time to run than what plot 2 suggests, " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "_, (ax1, ax2, ax3) = plt.subplots(nrows=3,\n", " ncols=1,\n", " layout='constrained')\n", "\n", "ax3.set_title(\"Plot `Watcher` data with `watch.visualiser.plot`\")\n", "plot(fit_acc.report(),\n", " show_generation=True,\n", " axes=ax3,\n", " use_line=True)\n", "ax3.set_ylabel(\"Fitness\")\n", "\n", "\n", "ax2.set_title(\"Manually plot `Watcher` data\")\n", "_data = [x.value for x in fit_acc.report()]\n", "ax2.plot(range(len(_data)), _data)\n", "ax2.set_xlabel(\"Observation\")\n", "ax2.set_ylabel(\"Fitness\")\n", "\n", "\n", "ax1.set_title(\"Manually plot manually collected data\")\n", "_data = [x.value for x in fit_acc.report() if x.event == \"POST_STEP\"]\n", "ax1.plot(range(len(_data)), _data)\n", "ax1.set_xlabel(\"Generation\")\n", "ax1.set_ylabel(\"Fitness\")\n", "\n", "plt.show()" ] } ], "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.12.10" } }, "nbformat": 4, "nbformat_minor": 2 }