first draft of the ants TP

Author: parmentelat

notebooks/myst-toc.yml

@@ -72,6 +72,7 @@ project:
       - file: tps/metro/README-metro-nb.md
       - pattern: tps/pagerank-thrones/README*-nb.md
       - pattern: tps/puzzle8/README-*-nb.md
+      - file: tps/ants/README-ants-nb.md
 
     - title: TPs visu & games
       children:

notebooks/tps/ants/.teacher/README-ants-corrige-nb.md

@@ -0,0 +1,215 @@
+---
+jupytext:
+  formats: md:myst
+  text_representation:
+    extension: .md
+    format_name: myst
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+language_info:
+  name: python
+  nbconvert_exporter: python
+  pygments_lexer: ipython3
+---
+
+# ants: a genetic algorithm
+
++++ {"tags": ["prune-cell"]}
+
+````{admonition} nothing to prune
+:class: warning
+
+there are no difference - apart from this very cell - between the teacher and the student version, but the notebook is duplicated in .teacher for consistency
+````
+
++++ {"slideshow": {"slide_type": ""}, "tags": ["prune-cell"]}
+
+```{admonition} grab the zip for starters
+
+{download}`you will need the zipfile that you can find here<./ARTEFACTS-ants.zip>`
+```
+
++++
+
+## problem statement
+
+our goal in this activity is to implement an optimization algorithm that is an example of a *genetic algorithm*  
+it turns out this algorithm can solve two equivalent problems
+
+### traveling salesman
+
+specifically, we consider a famous problem, which is of great importance for everything logistics, and is known as **the *"traveling salesman"* problem**  
+consider for example a truck that needs to deliver parcels in several locations  
+the problem is to find **the shortest path** (or more accurately, a reasonably short path)
+
+- that starts from the warehouse
+- goes through all the locations
+- and returns to the warehouse
+
+### ants colony problem
+
+the traveling salesman problem is in fact equivalent to the one known as the **the *"ants colony"* problem**, where the colony needs to find the best route from the ant hill and back, that goes through the spots where food has been found  
+
+this latter metaphor is **a little more helpful** though in the context of the genetic algorithm, because the algorithm indeed mimicks the existence of several ants that concurrently walk the graph, and leave pheromons to keep track of the past
+
+```{admonition} not *the* shortest path
+is has been shown that finding *the* shortest path is an NP-problem, so it's untractable  
+but as explained in the video, the genetic algorithm finds reasonable paths, in that they do not differ much from the optimal one
+```
+
++++
+
+## ACO: a super useful resource
+
+the YouTube video below gives a 20' introduction on the algorithm known as *Ants Colony Optimization (ACO)*, and explains essentially all the logic and formulas needed to implement it  
+```{iframe} https://www.youtube.com/embed/u7bQomllcJw?rel=0&amp;controls=1
+```
+so it is a **highly recommended** resource to get started with the details of the algorithm
+
+```{admonition} not a video fan ?
+
+[I found this one helpful too, in a totally different style](https://perso.liris.cnrs.fr/christine.solnon/publications/cpaior.pdf)
+
+and there's plenty others around as well, google for 'ACO algorithm'
+```
+
++++
+
+## useful data
+
+in the zip file you will find:
+
++++
+
+### `data/*.csv`
+
+we provide a few datafiles in the `data/` folder, made from some graphs that appear in the video  
+these use a simple csv format that should be self explanatory (just forget the `radius` column)
+
+| name | timestamp in video | # nodes |
+|-|-|-|
+| data/video-50.csv | 1:17 | 50 |
+| data/video-30.csv | 3:14 | 30 |
+| data/video-04.csv | 8:57 | 4 |
+| data/video-10.csv | 11:25 | 10 |
+| data/video-06.csv | 14:54 | 6 |
+| data/video-66.csv | 17:44 | 66 |
+
+plus for convenience some polygon-like shapes in `poly*.csv`
+
++++
+
+### `data/*.path`
+
+here we provide the results found by our own implementation; this in particular is used by the 'Cheat' button in `ui.py` - see below
+
++++
+
+## problem.py
+
+also provided in the zip, you can use `problem.py` like so:
+
+```{code-cell} ipython3
+from problem import Problem2D
+
+problem = Problem2D("data/video-06.csv")
+```
+
+```{code-cell} ipython3
+# how many nodes
+len(problem)
+```
+
+```{code-cell} ipython3
+# to iterate over nodes
+
+for node in problem:
+    print(node)
+```
+
+```{code-cell} ipython3
+# or rather
+
+for index, node in enumerate(problem):
+    print(f"{index}-th node is {node}")
+```
+
+```{code-cell} ipython3
+# get distance between 2 nodes
+
+problem.distance(0, 2)
+```
+
+```{code-cell} ipython3
+# what it says
+
+problem.distance_along_path([0, 1, 2, 3, 0])
+```
+
+#### displaying the graphs
+
++++
+
+we've also coded some display featured for your convenience
+
+1st off, **provided that you have `graphviz` installed**
+
+```{code-cell} ipython3
+# you can do display it with graphviz like this
+
+problem.to_graphviz()
+```
+
+```{code-cell} ipython3
+# or this if you prefer
+
+problem.to_graphviz(show_distances=False)
+```
+
+```{code-cell} ipython3
+# prune-cell
+# sub-optimal for big graphs though
+Problem2D("data/video-50.csv").to_graphviz(show_distances=False)
+```
+
+#### if you prefer plotly
+
+and there again, **provided that you have `plotly` installed** you could do
+
+```{code-cell} ipython3
+import plotly.io as pio
+
+# Try one of these depending on your setup:
+pio.renderers.default = "notebook"     # for classic Jupyter Notebook
+```
+
+```{code-cell} ipython3
+problem.to_plotly()
+```
+
+```{code-cell} ipython3
+# prune-cell 
+
+Problem2D("data/video-50.csv").to_plotly(show_distances=False)
+```
+
+```{code-cell} ipython3
+# prune-begin
+
+p6 = Problem2D("data/video-06.csv")
+p6.print_distances()
+```
+
+## `ui.py`
+
+might come in handy too, it is a simple `flet` UI that lets you visualize your work; you might consider
+
+- reading its code
+- make sure your `solver.py` code fits the expected interface - or tweak `ui.py` according to your own interface
+- run it with
+```bash
+flet run -d ui.py
+```
+so that the UI will hot reload upon any change you make in `solver.py`

notebooks/tps/ants/.teacher/data

@@ -0,0 +1 @@
+../data/

notebooks/tps/ants/.teacher/gridsearch.py

@@ -0,0 +1,95 @@
+"""
+do a gridsearch on the solver meta-parameters
+"""
+
+import math
+from itertools import product
+
+from problem import Problem2D
+from solver import Solver
+
+ITERATIONS = 10
+
+# ALPHAS = [0.1, 0.5, 1, 2, 5]
+ALPHAS = [1]
+# BETAS = [0.1, 0.5, 1, 2, 5]
+BETAS = [1]
+# VAPORIZATIONS = [0.1, 0.5, 0.9]
+VAPORIZATIONS = [0.64]
+# PHERO_INITS = [0.1, 0.5, 1, 2, 5]
+PHERO_INITS = [1]
+
+def use_default_parameters():
+    global ALPHAS, BETAS, VAPORIZATIONS, PHERO_INITS
+    from solver import ALPHA, BETA, VAPORISATION, PHERO_INIT
+    ALPHAS = [ALPHA]
+    BETAS = [BETA]
+    VAPORIZATIONS = [VAPORISATION]
+    PHERO_INITS = [PHERO_INIT]
+
+
+def gridsearch(filename, iterations):
+    p = Problem2D(filename)
+    best_distance = math.inf
+    best_path = None
+    best_params = None
+
+    CUBE = (ALPHAS, BETAS, VAPORIZATIONS, PHERO_INITS)
+    nb_combinations = len(ALPHAS) * len(BETAS) * len(VAPORIZATIONS) * len(PHERO_INITS)
+
+    for index, hyper_params in enumerate(product(*CUBE), 1):
+        (alpha, beta, vaporization, phero_init) = hyper_params
+        s = Solver(p, alpha=alpha, beta=beta, vaporisation=vaporization,
+                   phero_init=phero_init)
+        path, distance = s.solve(iterations)
+        print(
+            f"{index}/{nb_combinations} "
+            f"alpha={alpha} beta={beta} vaporization={vaporization} phero_init={phero_init}"
+            f"path={path} distance={distance}")
+        if distance < best_distance:
+            best_distance = distance
+            best_path = path
+            best_params = hyper_params
+
+    print(f"best path={best_path} distance={best_distance} with params={best_params}")
+    # save in .path file
+    # compute max euclidian diameter
+    max_diameter = max(p.distance(i, j)
+                       for i, j in product(range(len(p)), repeat=2) if i != j)
+    for i in range(len(p)):
+        for j in range(i+1, len(p)):
+            d = p.distance(i, j)
+            if d > max_diameter:
+                max_diameter = d
+    cheated_filename = filename.replace(".csv", ".path")
+    with open(cheated_filename, "w") as f:
+        import json
+        print(f"saving best path to {cheated_filename}")
+        json.dump(dict(
+            path=best_path,
+            distance=best_distance,
+            params=best_params,
+            iterations=iterations,
+            diameter=max_diameter,
+        ), f)
+
+from argparse import ArgumentParser
+def main():
+    parser = ArgumentParser()
+    parser.add_argument("filenames", nargs="+",help="the problem filename (csv)")
+    parser.add_argument(
+        "-i", "--iterations", type=int, default=ITERATIONS,
+        help=f"number of iterations per run (default: {ITERATIONS})")
+    # useful only to recompute the .path files
+    parser.add_argument(
+        "-d", "--default-parameters", action="store_true",
+        help="use the default parameters from solver.py instead of the gridsearch")
+
+    args = parser.parse_args()
+    if args.default_parameters:
+        use_default_parameters()
+    for filename in args.filenames:
+        gridsearch(filename, args.iterations)
+
+if __name__ == "__main__":
+    main()

notebooks/tps/ants/.teacher/main.py

@@ -0,0 +1,11 @@
+from problem import Problem2D
+
+from solver import Solver
+
+def demo_solver():
+    p = Problem2D("data/video-10.csv")
+    s = Solver(p)
+    path, distance = s.solve(20)
+    print("found path=", path, "distance=", p.distance_along_path(path))
+
+demo_solver()

notebooks/tps/ants/.teacher/media

@@ -0,0 +1 @@
+../media/

notebooks/tps/ants/.teacher/problem.py

@@ -0,0 +1 @@
+../problem.py