1_4_sparse_flight_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sparse flight data\n",
    "\n",
    "A key question for the generation of sparse state networks is _how_ sparse. If we lump all state nodes with each physical node, we lose all higher-order information and may underfit. On the other hand, keeping all second-order state nodes may overfit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In this tutorial, we will generate second-order state networks from path data, then from them generate multiple sparse networks with different number of (lumped) state nodes, and finally evaluate the result with Infomap."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Generate training and validation sets\n",
    "To get a bigger network, we can merge the flight path data from the four quarters (`\"data/air2015_{q}_paths.net\" for q in [1,2,3,4]`). To evaluate the goodness of fit, we can split each path randomly in either a _training_ or a _validation_ set and write a path data file for each of the data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parsing paths from 'data/air2015_1_paths.net'...\n",
      "Parsing paths from 'data/air2015_2_paths.net'...\n",
      "Parsing paths from 'data/air2015_3_paths.net'...\n",
      "Parsing paths from 'data/air2015_4_paths.net'...\n",
      "-> Writing 105095 paths to output/air2015_paths.net...\n"
     ]
    }
   ],
   "source": [
    "def combinePaths(inputFilenames, outputFilename):\n",
    "    \"\"\"Merge path data from inputFilenames and write to a single path data file\"\"\"\n",
    "    # Read path data\n",
    "    paths = []\n",
    "    for filename in inputFilenames:\n",
    "        print(\"Parsing paths from '{}'...\".format(filename))\n",
    "        with open(filename, mode='r') as infile:\n",
    "            isPath = False\n",
    "            for row in infile:\n",
    "                if not isPath and row[:6] == \"*paths\":\n",
    "                    isPath = True\n",
    "                    continue\n",
    "                if not isPath:\n",
    "                    continue\n",
    "                paths.append(row)\n",
    "    # Write path data\n",
    "    print(\"-> Writing {} paths to {}...\".format(len(paths), outputFilename))\n",
    "    with open(outputFilename, mode='w') as outfile:\n",
    "        outfile.write(\"*paths\\n\")\n",
    "        for p in paths:\n",
    "            outfile.write(p)\n",
    "\n",
    "inputFilenames = [\"data/air2015_{}_paths.net\".format(quarter) for quarter in [1,2,3,4]]\n",
    "combinePaths(inputFilenames, \"output/air2015_paths.net\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Generate state networks from paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read path data from file 'output/air2015_paths.net'...\n",
      "Done, parsed 55036/105095 paths\n",
      " -> 27092 return paths\n",
      "Generated training state network: StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)\n",
      "Writing state network to file 'output/states_training_order_2.net'...\n",
      "Generated validation state network: StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)\n",
      "Writing state network to file 'output/states_validation_order_2.net'...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "from state_lumping_network import StateNetwork\n",
    "\n",
    "pathNetwork = StateNetwork()\n",
    "pathNetwork.generateStateNetworkFromPaths(\"output/air2015_paths.net\",\n",
    "                                          \"output/states_training_order_2.net\",\n",
    "                                          outputValidationFilename=\"output/states_validation_order_2.net\",\n",
    "                                          markovOrder=2, splitWeight=True, validationProb=0.5,\n",
    "                                          minPathLength=3, maxPathLength=4, seed=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Generate _sparse_ state networks\n",
    "\n",
    "Here we will generate multiple lumped state networks with different amount of state nodes. A simple way is to parameterise this with a cluster rate $r$ going from 0.1 to 1, where `n_clusters = max(1, int(r * numStateNodes)`. For convenience, you can just send in the argument `clusterRate` to `clusterStateNodes` to achieve this, instead of the cluster function in the previous tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lumping training network with different cluster rates and lump validation network similarly\n",
      "Read state network from file 'output/states_training_order_2.net'...\n",
      " -> StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)\n",
      "Read state network from file 'output/states_validation_order_2.net'...\n",
      " -> StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)\n",
      "\n",
      "Original average entropy rate: 1.6897982538777094\n",
      "Original number of state nodes: 5219\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 718 state nodes and 6662 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_0.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 718 state nodes and 6662 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_0.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 1146 state nodes and 8213 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_1.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 1146 state nodes and 8213 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_1.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 1588 state nodes and 9808 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_2.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 1588 state nodes and 9808 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_2.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 2058 state nodes and 11534 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_3.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 2058 state nodes and 11534 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_3.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 2556 state nodes and 13315 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_4.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 2556 state nodes and 13315 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_4.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 2994 state nodes and 15112 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_5.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 2994 state nodes and 15112 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_5.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 3464 state nodes and 17027 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_6.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 3464 state nodes and 17027 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_6.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 3952 state nodes and 18938 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_7.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 3952 state nodes and 18938 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_7.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 4400 state nodes and 20873 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_8.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 4400 state nodes and 20873 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_8.net'...\n",
      "Cluster state nodes...\n",
      "Generate lumped state network from clustering...\n",
      " -> 5002 state nodes and 22618 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_training_lumped_9.net'...\n",
      "Cluster state nodes from clustering in network StateNetwork (298 physical nodes, 5219 state nodes and 22618 links)...\n",
      "Generate lumped state network from clustering...\n",
      " -> 5002 state nodes and 22618 links in lumped network.\n",
      "Writing lumped state network to file 'output/states_validation_lumped_9.net'...\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "print(\"Lumping training network with different cluster rates and lump validation network similarly\")\n",
    "trainingNet = StateNetwork()\n",
    "trainingNet.readFromFile(\"output/states_training_order_2.net\")\n",
    "validationNet = StateNetwork()\n",
    "validationNet.readFromFile(\"output/states_validation_order_2.net\")\n",
    "\n",
    "h0 = trainingNet.calcEntropyRate()\n",
    "print(\"\\nOriginal average entropy rate:\", h0)\n",
    "print(\"Original number of state nodes:\", trainingNet.numStateNodes())\n",
    "\n",
    "clusterRates = np.linspace(0.1, 1, 10)\n",
    "# clusterRates = [0.1, 0.3, 0.5, 0.7, 0.9, 0.95, 0.98, 0.99, 0.999, 1.0]\n",
    "trainNumStates = []\n",
    "trainEntropyRate = []\n",
    "valNumStates = []\n",
    "valEntropyRate = []\n",
    "\n",
    "for i, clusterRate in enumerate(clusterRates):\n",
    "    trainingNet.clusterStateNodes(clusterRate=clusterRate)\n",
    "    s = trainingNet.numLumpedStateNodes()\n",
    "    h = trainingNet.calcLumpedEntropyRate()\n",
    "    trainNumStates.append(s)\n",
    "    trainEntropyRate.append(h)\n",
    "    trainingNet.writeLumpedStateNetwork(\"output/states_training_lumped_{}.net\".format(i))\n",
    "    validationNet.clusterStateNodesFromNetwork(trainingNet)\n",
    "    validationNet.writeLumpedStateNetwork(\"output/states_validation_lumped_{}.net\".format(i))\n",
    "    s = trainingNet.numLumpedStateNodes()\n",
    "    h = trainingNet.calcLumpedEntropyRate()\n",
    "    valNumStates.append(s)\n",
    "    valEntropyRate.append(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### How much information do we lose as we reduce the number of state nodes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(trainNumStates, trainEntropyRate, marker='o')\n",
    "plt.plot(valNumStates, valEntropyRate, marker='x')\n",
    "plt.xlabel(\"number of lumped states\")\n",
    "plt.ylabel(\"entropy rate\")\n",
    "plt.axhline(y=h0, color='r', linestyle='-')\n",
    "# plt.axvline(x=sparseNet.numStateNodes(), color='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note that the original number of state nodes can be much larger than the maximum in the lumped state networks due to dangling nodes, which are lumped implicitly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Validate with Infomap\n",
    "The goal here is to calculate the codelength for the validation network, given the different partitions found on the lumped training networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import infomap\n",
    "trainingCodelengths = []\n",
    "validationCodelengths = []\n",
    "\n",
    "def calcCodelength(inputFilename, cluInputFile, flags=\"--directed --two-level\"):\n",
    "    im = infomap.Infomap(\"{} --no-infomap --input {} --cluster-data {}\".format(flags, inputFilename, cluInputFile))\n",
    "    im.run()\n",
    "    return im.codelength()\n",
    "\n",
    "def partition(inputFilename, cluOutputFile=None, flags=\"--directed --two-level\"):\n",
    "    im = infomap.Infomap(flags)\n",
    "    im.network().readInputData(inputFilename)\n",
    "    im.run()\n",
    "    if cluOutputFile:\n",
    "        # Use second argument True to write the state-level clustering\n",
    "        im.writeClu(cluOutputFile, True) # Second parameter shows States\n",
    "    return im.codelength()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: training codelength: 6.804890228842719 (718 nodes), validation codelength: 6.80692441636459 (718 nodes)\n",
      "1: training codelength: 7.0643228315164475 (1146 nodes), validation codelength: 7.067727496978909 (1146 nodes)\n",
      "2: training codelength: 6.893396366841944 (1588 nodes), validation codelength: 6.900823483872858 (1588 nodes)\n",
      "3: training codelength: 6.334775798013425 (2058 nodes), validation codelength: 6.344158159237375 (2058 nodes)\n",
      "4: training codelength: 5.641065576236672 (2556 nodes), validation codelength: 5.65001113373823 (2556 nodes)\n",
      "5: training codelength: 5.002942833318026 (2994 nodes), validation codelength: 5.014616638108008 (2994 nodes)\n",
      "6: training codelength: 4.548152864473756 (3464 nodes), validation codelength: 4.560046440410952 (3464 nodes)\n",
      "7: training codelength: 4.301472424909189 (3952 nodes), validation codelength: 4.312111534653179 (3952 nodes)\n",
      "8: training codelength: 4.29738335005707 (4400 nodes), validation codelength: 4.3070143117316615 (4400 nodes)\n",
      "9: training codelength: 4.388709473003445 (5002 nodes), validation codelength: 4.399936102604309 (5002 nodes)\n"
     ]
    }
   ],
   "source": [
    "for i, clusterRate in enumerate(clusterRates):\n",
    "    trainingCodelength = partition(\"output/states_training_lumped_{}.net\".format(i),\n",
    "             \"output/states_training_lumped_{}.clu\".format(i))\n",
    "    validationCodelength = calcCodelength(\"output/states_validation_lumped_{}.net\".format(i),\n",
    "             \"output/states_training_lumped_{}.clu\".format(i))\n",
    "    trainingCodelengths.append(trainingCodelength)\n",
    "    validationCodelengths.append(validationCodelength)\n",
    "    print(\"{}: training codelength: {} ({} nodes), validation codelength: {} ({} nodes)\".format(i, trainingCodelength, trainNumStates[i], validationCodelength, valNumStates[i]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(trainNumStates, trainingCodelengths, marker='o')\n",
    "plt.plot(valNumStates, validationCodelengths, marker='x')\n",
    "plt.legend([\"training\", \"validation\"])\n",
    "plt.xlabel(\"number of state nodes\")\n",
    "plt.ylabel(\"codelength\")\n",
    "# plt.ylim(ymin=7, ymax=8)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}