GAMaster_MPBLabSem-20220504.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import os, shutil, shlex\n",
    "import json, io\n",
    "from subprocess import Popen, PIPE, STDOUT\n",
    "from contextlib import redirect_stdout, redirect_stderr\n",
    "from datetime import datetime\n",
    "import pandas\n",
    "import matplotlib as mpl\n",
    "from matplotlib import pyplot\n",
    "from ipywidgets.widgets.interaction import show_inline_matplotlib_plots\n",
    "import glob\n",
    "from collections import OrderedDict\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gahyparopt.gahyperopt import *\n",
    "from gahyparopt.GAUtilities import *\n",
    "from gahyparopt.parameters import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Model(object):\n",
    "    generation_performance = {}\n",
    "    population=None\n",
    "    generations={}\n",
    "    index=0\n",
    "    ga=None\n",
    "    \n",
    "    def setup_ga(self):\n",
    "        self.ga = GADriver(\n",
    "            layer_counts=HIDDEN_LAYER_COUNT,\n",
    "            no_neurons=HIDDEN_LAYER_NEURONS,\n",
    "            rates=HIDDEN_LAYER_RATE,\n",
    "            activations=HIDDEN_LAYER_ACTIVATIONS,\n",
    "            layer_types=HIDDEN_LAYER_TYPE,\n",
    "            optimizers=MODEL_OPTIMIZER,\n",
    "            population_size=self.population_size,\n",
    "            best_candidates_count=max(1, self.population_size//3),\n",
    "            random_candidates_count=self.population_size//3,\n",
    "            optimizer_mutation_probability=OPTIMIZER_MUTATION_PROBABILITY,\n",
    "            layer_mutation_probability=HIDDEN_LAYER_MUTATION_PROBABILITY,\n",
    "        )\n",
    "        \n",
    "    def load_population(self):\n",
    "        json_fnames = glob.glob(\"*.json\")\n",
    "        population = []\n",
    "        names = []\n",
    "\n",
    "        for j in json_fnames:\n",
    "            name = j.split(\".\")[0]\n",
    "            names.append(name)\n",
    "            individuum = read_chromosome(j.split('.')[0])\n",
    "            population.append(individuum)\n",
    "\n",
    "        population = OrderedDict(zip(names, population))\n",
    "        for name, pop in population.items():\n",
    "            if pop.accuracy is None:\n",
    "                population[name].accuracy = 0.0\n",
    "        \n",
    "        self.population=OrderedDict(sorted(population.items(),key=lambda x: x[1].accuracy, reverse=True))\n",
    "        \n",
    "        self.population_size = len(self.population)\n",
    "        \n",
    "        if self.ga is None:\n",
    "            self.setup_ga()\n",
    "        \n",
    "    def setup_plots(self):\n",
    "        cmap = pyplot.cm.nipy_spectral  # define the colormap\n",
    "        # extract all colors from the .jet map\n",
    "        cmaplist = [cmap(i) for i in range(cmap.N)]\n",
    "\n",
    "        # create the new map\n",
    "        segmented_cmap = mpl.colors.LinearSegmentedColormap.from_list(\n",
    "            'Custom cmap', cmaplist, self.population_size)\n",
    "\n",
    "        segmented_cmap_list = [segmented_cmap(i) for i in range(segmented_cmap.N)]\n",
    "\n",
    "        # define the bins and normalize\n",
    "        bounds = np.linspace(0, self.population_size, self.population_size+1)\n",
    "        norm = mpl.colors.BoundaryNorm(bounds, self.population_size)\n",
    "\n",
    "        players = model.population.keys()\n",
    "        color_player_dict = dict(zip(segmented_cmap_list, players))\n",
    "        player_color_dict = dict(zip(players, segmented_cmap_list))\n",
    "        # Add \"0\" for 0 generation\n",
    "        player_color_dict['0'] = \"k\"\n",
    "        \n",
    "        self.player_color_dict = player_color_dict\n",
    "        self.color_player_dict = color_player_dict\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_accuracy_plot(df):\n",
    "    fig, ax = pyplot.subplots(2,1,sharex=True,figsize=(7,8))\n",
    "    mn = df.accuracy.min()*0.9\n",
    "    mx = min(df.accuracy.max()*1.1, 1.0)\n",
    "    bar_width = 0.8\n",
    "    df = df.sort_values('accuracy', ascending=True)\n",
    "    color = dict([(model.player_color_dict[name], name)  for name in df['name'].values])\n",
    "    df.plot.barh(x='name',\n",
    "                                 y='accuracy',\n",
    "                                 ax=ax[0],\n",
    "                                 grid=True,\n",
    "                                 color=color,\n",
    "                                 )\n",
    "    df['accuracy'].plot.hist(ax=ax[1],\n",
    "                             grid=True,\n",
    "                             bins=model.population_size,\n",
    "                             range=(mn,mx),\n",
    "                             rwidth=bar_width,\n",
    "                            )\n",
    "    ax[1].set_xlim([mn,mx])\n",
    "   \n",
    "    return fig, ax\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build graph\n",
    "def get_tree(model, max_generation):\n",
    "    \n",
    "    graph = nx.DiGraph()\n",
    "    graph.add_node(\"X-0\", layer=0, player=\"0\")\n",
    "    \n",
    "    for g,generation in model.generations.items():\n",
    "        \n",
    "        if g > max_generation:\n",
    "            break\n",
    "        for player, chrm in generation.items():\n",
    "            graph.add_node(\"{}-{}\".format(chrm.id, g), layer=g, player=player)\n",
    "\n",
    "    edges = []\n",
    "\n",
    "    for g,generation in model.generations.items():\n",
    "        if g > max_generation:\n",
    "            break\n",
    "            \n",
    "        for chrm in generation.values():\n",
    "            parent_a = chrm.parent_a\n",
    "            parent_b = chrm.parent_b\n",
    "            id = chrm.id\n",
    "\n",
    "            # if parent_a is None and parent_b is None:\n",
    "            #     parent_a = id\n",
    "            #     parent_b = id\n",
    "\n",
    "            if g == 1:\n",
    "                parent_a = \"X\"\n",
    "                parent_b = \"X\"\n",
    "\n",
    "            parent_a = \"{}-{}\".format(parent_a, g-1) \n",
    "            parent_b = \"{}-{}\".format(parent_b, g-1) \n",
    "\n",
    "            # if parent_a not in graph.nodes:\n",
    "            #     parent_a = \"{}-{}\".format(id, g-1)\n",
    "            # if parent_b not in graph.nodes:\n",
    "            #     parent_b = \"{}-{}\".format(id, g-1)\n",
    "\n",
    "            id = \"{}-{}\".format(id, g)\n",
    "\n",
    "            edges.append((parent_a, id))\n",
    "            edges.append((parent_b, id))\n",
    "\n",
    "\n",
    "    graph.add_edges_from(edges)\n",
    "\n",
    "    nodes_to_remove = []\n",
    "    for node,data in graph.nodes(data=True):\n",
    "        if \"layer\" not in data.keys():\n",
    "            nodes_to_remove.append(node)\n",
    "\n",
    "    graph.remove_nodes_from(nodes_to_remove)\n",
    "\n",
    "    pos = nx.multipartite_layout(graph, subset_key=\"layer\")\n",
    "\n",
    "    return graph,pos"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "tags": []
   },
   "source": [
    "[(v, data) for v, data in graph.nodes(data=True)]\n",
    "\n",
    "model.player_color_dict\n",
    "\n",
    "color\n",
    "\n",
    "fig, ax = pyplot.subplots(1,1, figsize=(7,8))\n",
    "graph, pos = get_tree(model, 2)\n",
    "color = [model.player_color_dict[data[\"player\"]] for v, data in graph.nodes(data=True)]\n",
    "_ = nx.draw(graph, pos, ax, node_color=color)      \n",
    "\n",
    "graph.nodes\n",
    "\n",
    "graph.edges\n",
    "\n",
    "[(name, chrm.id, chrm.accuracy, chrm.parent_a, chrm.parent_b) for name,chrm in model.population.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pull button\n",
    "pull_button = widgets.Button(description=\"Generation aktualisieren\")\n",
    "def pull_button_clicked(b):\n",
    "    log_widget.clear_output()\n",
    "    with log_widget:\n",
    "        sync_remote_to_local('all')\n",
    "        \n",
    "pull_button.on_click(pull_button_clicked)\n",
    "#################################################################\n",
    "#\n",
    "# Generation count\n",
    "generation_count = widgets.BoundedIntText(value=0, min=0, max=0)\n",
    "\n",
    "def on_generation_count_change(change):\n",
    "    log_widget.clear_output()\n",
    "    with log_widget:\n",
    "        df = model.generation_performance[change['new']]\n",
    "        \n",
    "    plot_accuracy_vs_name(df)\n",
    "    plot_generation_tree()\n",
    "    \n",
    "generation_count.observe(on_generation_count_change, names=['value'])    \n",
    "#################################################################\n",
    "#\n",
    "# Generation load button\n",
    "generation_button = widgets.Button(description=\"Generation laden\")\n",
    "\n",
    "def generation_button_clicked(b):\n",
    "    log_widget.clear_output()\n",
    "    with log_widget:\n",
    "        model.load_population()\n",
    "\n",
    "        df = pandas.DataFrame([\n",
    "            {'name': key,\n",
    "             'loss': model.population[key].loss,\n",
    "             'accuracy': model.population[key].accuracy\n",
    "            } for key in model.population.keys()\n",
    "        ])\n",
    "        model.index = model.index + 1\n",
    "        model.generation_performance.update({model.index: df})\n",
    "        model.generations.update({model.index: model.population})\n",
    "        \n",
    "        model.setup_plots()\n",
    "        \n",
    "        generation_count.max = model.index\n",
    "        generation_count.min = 1\n",
    "        generation_count.value = model.index\n",
    "    \n",
    "generation_button.on_click(generation_button_clicked)\n",
    "#################################################################\n",
    "#\n",
    "# Evolve button\n",
    "evolve_button = widgets.Button(description=\"Evolution!\")\n",
    "def evolve_button_clicked(b):\n",
    "    log_widget.clear_output()\n",
    "    with log_widget:\n",
    "        new_chromosomes = model.ga.evolve_population(list(model.population.values()))\n",
    "        model.population = OrderedDict(zip(model.population.keys(), new_chromosomes))\n",
    "        \n",
    "evolve_button.on_click(evolve_button_clicked)\n",
    "#################################################################\n",
    "#\n",
    "# Distribute button\n",
    "distribute_button = widgets.Button(description=\"Generation verteilen\")\n",
    "\n",
    "def distribute_button_clicked(b):\n",
    "    log_widget.clear_output()\n",
    "    with log_widget:\n",
    "        for name,individuum in model.population.items():\n",
    "            print(name, individuum)\n",
    "            write_chromosome(name=name,chromosome=individuum)\n",
    "            sync_local_to_remote(name)\n",
    "            \n",
    "distribute_button.on_click(distribute_button_clicked)\n",
    "#################################################################\n",
    "#\n",
    "# Plot widgets\n",
    "accuracy_plot_widget = widgets.Output(layout={'border': '1px solid black', 'width':'50%', 'scroll':'true'})\n",
    "generation_tree_widget = widgets.Output(layout={'border': '1px solid black', 'width':'50%', 'scroll':'true'})\n",
    "log_widget = widgets.Output(layout={'border': '1px solid black', 'width':'80%', 'scroll':'true'})\n",
    "\n",
    "def plot_accuracy_vs_name(df):\n",
    "    accuracy_plot_widget.clear_output()\n",
    "    with accuracy_plot_widget:\n",
    "        \n",
    "        fig, ax = get_accuracy_plot(df)\n",
    "\n",
    "        show_inline_matplotlib_plots()\n",
    "        \n",
    "def plot_generation_tree():\n",
    "    generation_tree_widget.clear_output()\n",
    "    with generation_tree_widget:\n",
    "        fig, ax = pyplot.subplots(1,1, figsize=(7,8))\n",
    "        graph, pos = get_tree(model, generation_count.value)\n",
    "        color = [model.player_color_dict[data[\"player\"]] for v, data in graph.nodes(data=True)]\n",
    "        _ = nx.draw(graph, pos, ax, node_color=color)       \n",
    "        show_inline_matplotlib_plots()\n",
    "\n",
    "init_button = widgets.Button(description=\"New Game!\")\n",
    "def init_button_clicked(b):\n",
    "    with log_widget:\n",
    "        model.load_population()\n",
    "        model.setup_ga()\n",
    "        \n",
    "init_button.on_click(init_button_clicked) \n",
    "        \n",
    "    \n",
    "        \n",
    "##################################################################\n",
    "#\n",
    "# GUI\n",
    "gui = widgets.VBox(children=[\n",
    "    init_button,\n",
    "    widgets.HBox([pull_button, generation_button]),\n",
    "    generation_count,\n",
    "    widgets.HBox([\n",
    "        accuracy_plot_widget,\n",
    "        generation_tree_widget,\n",
    "    ]),\n",
    "    evolve_button,\n",
    "    distribute_button,\n",
    "    log_widget,\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63beb160c92b442987748523345f968b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Button(description='New Game!', style=ButtonStyle()), HBox(children=(Button(description='Genera…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(gui)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "*** 2nd generation ***\n",
    "xeyvwudywaye xeyvwudywaye xeyvwudywaye\n",
    "xmghznggveec xmghznggveec xmghznggveec\n",
    "aigmzzgklmhs xmghznggveec xeyvwudywaye"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "delete_local()\n",
    "delete_remote()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph, pos = get_tree(model, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NodeDataView({'X-0': {'layer': 0, 'player': '0'}, 'hrmovsrxbpfu-1': {'layer': 1, 'player': 'Spieler3'}, 'vkjamktzpqpw-1': {'layer': 1, 'player': 'Google'}, 'efxwpuzolhge-1': {'layer': 1, 'player': 'Spieler1'}, 'joiutixtrpyd-1': {'layer': 1, 'player': 'Spieler2'}})"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graph.nodes(data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'player_color_dict' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_18782/1769961236.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mplayer_color_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"player\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mgraph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode_color\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/tmp/ipykernel_18782/1769961236.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcolor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mplayer_color_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"player\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mgraph\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mnx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnode_color\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'player_color_dict' is not defined"
     ]
    }
   ],
   "source": [
    "color = [player_color_dict[data[\"player\"]] for v, data in graph.nodes(data=True)]\n",
    "nx.draw(graph, pos, node_color=color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph.nodes(data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for g,generation in model.generations.items():\n",
    "    print(\"Generation {}\".format(g))\n",
    "    for name,chromosome in generation.items():\n",
    "        print(\"\\t\",name, chromosome.accuracy, chromosome.id, chromosome.parent_a, chromosome.parent_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "subset_sizes = [5, 5, 4, 3, 2, 4, 4, 3]\n",
    "subset_color = [\n",
    "    \"gold\",\n",
    "    \"violet\",\n",
    "    \"violet\",\n",
    "    \"violet\",\n",
    "    \"violet\",\n",
    "    \"limegreen\",\n",
    "    \"limegreen\",\n",
    "    \"darkorange\",\n",
    "]\n",
    "\n",
    "\n",
    "def multilayered_graph(*subset_sizes):\n",
    "    extents = nx.utils.pairwise(itertools.accumulate((0,) + subset_sizes))\n",
    "    layers = [range(start, end) for start, end in extents]\n",
    "    G = nx.Graph()\n",
    "    for (i, layer) in enumerate(layers):\n",
    "        G.add_nodes_from(layer, layer=i)\n",
    "    for layer1, layer2 in nx.utils.pairwise(layers):\n",
    "        edges = itertools.product(layer1, layer2)\n",
    "        edges = [edge for i,edge in enumerate(edges) if i%2==0]\n",
    "        G.add_edges_from(edges)\n",
    "    return G\n",
    "\n",
    "\n",
    "G = multilayered_graph(*subset_sizes)\n",
    "color = [subset_color[data[\"layer\"]] for v, data in G.nodes(data=True)]\n",
    "pos = nx.multipartite_layout(G, subset_key=\"layer\")\n",
    "plt.figure(figsize=(8, 8))\n",
    "nx.draw(G, pos, node_color=color, with_labels=False)\n",
    "plt.axis(\"equal\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.nodes(data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph.nodes(data=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos = nx.multipartite_layout(graph, subset_key='generation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph.nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_population()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for pl, ind in model.population.items():\n",
    "    print(pl, ind.parent_a, ind.parent_b, ind.id)\n",
    "    #ind.ml_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import newick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate tree\n",
    "initial_population = model.generations[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "last_generation = model.generations[next(reversed(model.generations.keys()))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "last_generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse-iterate through the generations and build up the tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chromosome=  last_generation['spieler4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del model.generations[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "root = newick.Node.create(name=\"X\")\n",
    "# for gen in model.generations.values:\n",
    "for indvdl_gen1 in model.generations[1].values():\n",
    "    node_gen1 = newick.Node.create(name=indvdl_gen1.id)\n",
    "    for indvdl_gen2 in model.generations[2].values():\n",
    "        if indvdl_gen2.parent_a == indvdl_gen1.id:\n",
    "            node_gen1.add_descendant(newick.Node.create(name=indvdl_gen2.id))\n",
    "        elif indvdl_gen2.parent_b == indvdl_gen1.id:\n",
    "            node_gen1.add_descendant(newick.Node.create(name=indvdl_gen2.id))\n",
    "        elif indvdl_gen2.id == indvdl_gen1.id:\n",
    "            node_gen1.add_descendant(newick.Node.create(name=indvdl_gen2.id))\n",
    "            \n",
    "#     parent_a = newick.Node.create(name=indvdl.parent_a)\n",
    "#     parent_b = newick.Node.create(name=indvdl.parent_b)\n",
    "\n",
    "#     node.add_descendant(parent_a)\n",
    "#     node.add_descendant(parent_b)\n",
    "    \n",
    "    root.add_descendant(node_gen1)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(root.ascii_art())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "winner = newick.Node.create(name=next(reversed(model.generations)), descendants=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for gen, pop in model.generations:\n",
    "    \n",
    "root.add_descendant(newick.Node(name='A'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.generations[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "generation_count.value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "winner = model.generations[4]['B']; winner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for gen in range(4,0,-1):\n",
    "    for parent in \n",
    "    winner_node.add_descendant(parent.id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "winner_node = newick.Node(name=winner.id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_parents(node, parent_gen):\n",
    "    gen_dict = model.generations[parent_gen]\n",
    "    chromosomes = list(gen_dict.values())\n",
    "    \n",
    "    parent_ids = \n",
    "    node.add_descendant()\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for gen, pop in model.generations.items():\n",
    "    print(gen)\n",
    "    if gen>0:\n",
    "        print(pop['D'].id)\n",
    "          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.generations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "EvolKI-Demo",
   "language": "python",
   "name": "evolki-demo"
  },
  "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.10.0"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}