benchmark-lap-solvers-py3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Benchmarking Python3 LAP Solvers\n",
    "\n",
    "The scripts benchmark the performance of Python3 linear assignment problem (LAP) solvers for random cost matrices of different sizes. **They have been rested to work with Python 3.6 and 3.7**  These solvers are:\n",
    "\n",
    "* **linear_sum_assignment** - a Python implementation of the Hungarian algorithm provided in SciPy\n",
    "  * https://github.com/scipy/scipy/\n",
    "* **munkres** - a Python implementation of the Hungarian algorithm provided by Brian Clapper\n",
    "  * https://github.com/bmc/munkres\n",
    "* **hungarian** - a wrapper to a C++ implementation Knuth's Hungarian algorithm provided by Harold Cooper. \n",
    "  * It does not work with Python 3.6+\n",
    "  * https://github.com/Hrldcpr/Hungarian\n",
    "* **lap.lapjv** - a wrapper to a C++ implementation of Jonker-Volgenant algorithm provided by Tomas Kazmar\n",
    "  * https://github.com/gatagat/lap\n",
    "  In addition, these two solvers are added for Python3\n",
    "* **lapjv.lapjv** - a wrapper to a C++ implementation of Jonker-Volgenant algorithm re-written for Python 3 and optimized to take advantage of AVX2 instruction sets by Vadim Markovtsev at src{d}.\n",
    "  * Please see the [blog post here](https://blog.sourced.tech/post/lapjv/)\n",
    "  * https://github.com/src-d/lapjv  \n",
    "* **lapsolver** - implementation for dense matrices based on shortest path augmentation by Christoph Heindl.\n",
    "  * Please note that Christioph has also done a [benchmark of LAP solvers](https://github.com/cheind/py-lapsolver/tree/master/lapsolver/benchmarks)\n",
    "  * https://github.com/cheind/py-lapsolver      \n",
    "\n",
    "They all formally have O(n<sup>3</sup>) complexity, but their performance differs substantially based on their implementation and the size of the matrix they are trying to solve. The solvers can be classified based on some unique characteristics.\n",
    "\n",
    "|  Module                             | Python or C/C++/Cython  | Algorithm     |\n",
    "|-------------------------------------|:-----------------------:|:--------------|\n",
    "|scipy.optimize.linear_sum_assignment |          Python(v<1.4)/C++(v=>1.4)         | Hungarian     |\n",
    "|munkres.Munkres                      |          Python         | Hungarian     |\n",
    "|hungarian.lap (<Py 3.5)              |          C++            | Hungarian     |\n",
    "|lap.lapjv                            |          C++            | Jonker-Volgenant     |\n",
    "|lapjv.lapjv                          |          C++            | Jonker-Volgenant     |\n",
    "|lapsolver.solve_dense                |          C++            | shortest augmenting path     |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import time\n",
    "import argparse\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "import inspect\n",
    "import sys\n",
    "import pip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check for missing packages; Install and load packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def install_modules(package):\n",
    "    try:\n",
    "        __import__(package)\n",
    "    except ImportError:\n",
    "        pip.main(['install', '--user', package])       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#LAP Solvers\n",
    "install_modules(\"munkres\")\n",
    "import munkres\n",
    "install_modules(\"scipy\")\n",
    "from scipy.optimize import linear_sum_assignment\n",
    "from scipy.optimize import curve_fit\n",
    "#install_modules(\"hungarian\")\n",
    "#import hungarian\n",
    "install_modules(\"lap\")\n",
    "import lap\n",
    "\n",
    "#If running Python3, benchmark all implementations\n",
    "if sys.version_info[0] >= 3:\n",
    "    install_modules(\"lapjv\")\n",
    "    import lapjv\n",
    "    install_modules(\"lapsolver\")\n",
    "    from lapsolver import solve_dense\n",
    "    install_modules(\"laptools\")\n",
    "    from laptools import clap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Invoke different LAP solvers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "\n",
    "### lapJV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_lap_lapjv(matrix, printlowestcost):\n",
    "    #print module name\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    #start timing\n",
    "    t_start = time.time()\n",
    "    lowest_cost, row_ind, column_ind = lap.lapjv(matrix)\n",
    "    t_end = time.time()\n",
    "    #end timing\n",
    "\n",
    "    #print minimum cost information with varying verbosity\n",
    "    if printlowestcost:\n",
    "        if verbose:\n",
    "            lowest_cost = 0.00\n",
    "            for i in range(len(row_ind)):\n",
    "                lowest_cost += matrix[i, row_ind[i]]\n",
    "                print(\"%18s %6d %5.3f\" % (\"      \", i ,lowest_cost))\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    del row_ind\n",
    "    del column_ind\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### lapJV.lapJV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_lapjv_lapjv(matrix, printlowestcost):\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    t_start = time.time()\n",
    "    row_ind, column_ind, _ = lapjv.lapjv(matrix)\n",
    "    t_end = time.time()\n",
    "\n",
    "    if printlowestcost:\n",
    "        lowest_cost = 0.00\n",
    "        for i in range(len(row_ind)):\n",
    "            lowest_cost += matrix[i, row_ind[i]]\n",
    "            if verbose:\n",
    "                print(\"%18s  %6d  %5.3f\" % (\"      \", i ,lowest_cost))\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    del row_ind\n",
    "    del column_ind\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### lapsolver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_lapsolver(matrix, printlowestcost):\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    t_start = time.time()\n",
    "    row_ind, column_ind = solve_dense(matrix)\n",
    "    t_end = time.time()\n",
    "\n",
    "    if printlowestcost:\n",
    "        lowest_cost = 0.00\n",
    "        lowest_cost = matrix[row_ind, column_ind].sum()\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    del row_ind\n",
    "    del column_ind\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### hungarian (doesn't work with Python 3.6+)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_hungarian(matrix, printlowestcost):\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    t_start = time.time()\n",
    "    hung_mat = np.copy(matrix)\n",
    "    row_ind, column_ind = hungarian.lap(hung_mat)\n",
    "    t_end = time.time()\n",
    "\n",
    "    if printlowestcost:\n",
    "        lowest_cost = 0.00\n",
    "        for i in range(len(row_ind)):\n",
    "            lowest_cost += matrix[i, row_ind[i]]\n",
    "            if verbose:\n",
    "                print(\"%18s  %6d  %5.3f\" % (\"      \", i ,lowest_cost))\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    del row_ind\n",
    "    del column_ind\n",
    "    del hung_mat\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### scipy.linear_sum_assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_scipy(matrix, printlowestcost):\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    t_start = time.time()\n",
    "    row_ind, column_ind = linear_sum_assignment(matrix)\n",
    "    t_end = time.time()\n",
    "\n",
    "    if printlowestcost:\n",
    "        lowest_cost = 0.00\n",
    "        lowest_cost = matrix[row_ind, column_ind].sum()\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    del row_ind\n",
    "    del column_ind\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### munkres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_munkres(matrix, printlowestcost):\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    t_start = time.time()\n",
    "    munk_mat = np.copy(matrix)\n",
    "    m = munkres.Munkres()\n",
    "    indices = m.compute(matrix)\n",
    "    t_end = time.time()\n",
    "\n",
    "    if printlowestcost:\n",
    "        columns = [x[1] for x in indices]\n",
    "        lowest_cost = 0.00\n",
    "        for i in range(len(columns)):\n",
    "            lowest_cost += munk_mat[i, columns[i]]\n",
    "            if verbose:\n",
    "                print(\"%18s  %6d  %5.3f\" % (\"      \", i ,lowest_cost))\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    del indices\n",
    "    del munk_mat\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### laptools_clap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_laptools_clap(matrix, printlowestcost):\n",
    "    temp = inspect.stack()[0][3]\n",
    "    method_name=temp[4:]\n",
    "    print(\" %s\" % ( method_name ), end=' ')\n",
    "\n",
    "    t_start = time.time()\n",
    "    lowest_cost = clap.cost(0,1,matrix)\n",
    "    t_end = time.time()\n",
    "\n",
    "    if printlowestcost:\n",
    "        print(\"  %12s %s %5.3f\" % (method_name, \"minimum cost\", lowest_cost))\n",
    "\n",
    "    return t_end-t_start"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "### New method\n",
    "\n",
    "One can add a function run_METHOD to get timing for that method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main function\n",
    "\n",
    "The script  will produce the following:\n",
    "- data of timing for LAP solving random cost matrices of dimensions 2<sup>min</sup> - 2<sup>max</sup>\n",
    "- plot of timing for LAP solving random cost matrices of dimensions 2<sup>min</sup> - 2<sup>max</sup>\n",
    "\n",
    "Instead of parsing arguments from the command line, it expects the following variables to be specified below\n",
    "\n",
    "* **min** - minimum dimension of cost matrix to solve\n",
    "    - The default is 8 (2<sup>3</sup>)\n",
    "* **max** - maximum dimension of cost matrix to solve\n",
    "    - The default is 4096 (2<sup>12</sup>)\n",
    "* **ncyc** - number of times to solve cost matrices and average their timing\n",
    "    - The default is 3 cycles')       \n",
    "* **printcost** - Print the minimum cost.\n",
    "    - The default is false, i.e. will not print the minimum cost\n",
    "* **verbose** - Determines verbosity.\n",
    "    - The default is minimal printing, i.e. not verbose\n",
    "* **noplot** - Do not plot data.\n",
    "    - The default is to save plot of the data in PNG format, but not open the plot GUI unless 'showplot=True'\n",
    "* **showplot** - generate plot of data using matplotlib\n",
    "    - The default is to save plot of the data in PNG format, but not open the plot GUI\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "\n",
    " smallest = 8              # smallest dimension of square cost matrix to be solved\n",
    " largest = 8193           # largest dimension of square cost matrix to be solved\n",
    " ncyc = 3             # number of times to repeat benchmarks \n",
    " printcost = False    # Print the minimum cost\n",
    " verbose = False      # Determines verbosity\n",
    " showplot = False     # Open matplotlib plot in a separate window         \n",
    " noplot = False       # Plot \n",
    "\n",
    "    \n",
    "# METHODS being benchmarked -- Add new METHOD[S] here\n",
    "# 'hungarian' removed because of incompatibilties with Python 3.6 and 3.7\n",
    "if sys.version_info[0] >= 3:\n",
    "    methods = [\"lapjv_lapjv\", \"lap_lapjv\", \"lapsolver\", \"laptools_clap\", \"scipy\", \"munkres\"]\n",
    "else:\n",
    "    methods = [\"lap_lapjv\", \"scipy\", \"munkres\"]\n",
    "\n",
    "minimum = int(np.floor(np.log2(smallest)))      # 2^min =  8x8 cost matrix\n",
    "maximum = int(np.ceil(np.log2(largest)))      # 2^max\n",
    "ncyc = int(ncyc)                      # number of cycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LIMITS - add limit for new METHOD[S] here\n",
    "The size of the matrix to be solved is limited to 2^{limit['method']} for each method to ensure quick termination of the benchmarking exercise. Munkres and Scipy are considerably slower, making it necessary to limit them to smaller matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solving matrices of sizes up to 2^{n} where n is {'munkres': 7, 'scipy': 14, 'lap_lapjv': 14, 'lapjv_lapjv': 14, 'lapsolver': 14, 'laptools_clap': 14}\n"
     ]
    }
   ],
   "source": [
    "limit = {}\n",
    "limit['munkres'] = min(7,maximum)\n",
    "#limit['hungarian'] = min(12,maximum)\n",
    "limit['scipy'] = maximum\n",
    "limit['lap_lapjv'] = maximum\n",
    "limit['lapjv_lapjv'] = maximum\n",
    "limit['lapsolver'] = maximum\n",
    "limit['laptools_clap'] =  maximum\n",
    "print(\"Solving matrices of sizes up to 2^{n} where n is \" + str(limit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# arrays to store data\n",
    "t_methods = [\"t_\" + i for i in methods]\n",
    "for i in range(len(methods)):\n",
    "    t_methods[i] = np.empty((0, 2), float)\n",
    "label_methods = [\"label_\" + i for i in methods]\n",
    "run_methods = [\"run_\" + i for i in methods]\n",
    "\n",
    "base = 2               # will build matrices of size base^n and solve them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "8 x 8 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "\n",
      "16 x 16 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "\n",
      "32 x 32 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "\n",
      "64 x 64 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "\n",
      "128 x 128 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy  munkres \n",
      "\n",
      "256 x 256 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "\n",
      "512 x 512 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "\n",
      "1024 x 1024 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "\n",
      "2048 x 2048 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "\n",
      "4096 x 4096 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "\n",
      "8192 x 8192 ... \n",
      "\n",
      "Cycle  0   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  1   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy \n",
      "Cycle  2   lapjv_lapjv  lap_lapjv  lapsolver  laptools_clap  scipy "
     ]
    }
   ],
   "source": [
    "for i in range(minimum, maximum):\n",
    "    matrix_size = pow(base, i)\n",
    "    print((\"\\n\\n\" + str(matrix_size) + \" x \" + str(matrix_size) + \" ... \"))\n",
    "    methods_data = np.zeros(len(methods), float)\n",
    "\n",
    "    # Generate n_cyc random matrices and solve them using different methods\n",
    "    for j in range(ncyc):\n",
    "        cost_matrix = matrix_size * \\\n",
    "            np.random.random((matrix_size, matrix_size))\n",
    "        print(\"\\nCycle \", (str(j) + \" \"), end=' ')\n",
    "        # print(\"\\n\")\n",
    "        # print(cost_matrix)\n",
    "        for method in range(len(methods)):\n",
    "            # print '%20s\\t' %(methods[method])\n",
    "            if methods[method] == 'munkres' and i <= limit[methods[method]]:\n",
    "                methods_data[method] += run_munkres(\n",
    "                    cost_matrix, printcost)\n",
    "            elif methods[method] == 'scipy' and i <= limit[methods[method]]:\n",
    "                real_time = run_scipy(cost_matrix, printcost)\n",
    "                methods_data[method] += real_time\n",
    "            #elif methods[method] == 'hungarian' and i <= limit[methods[method]]:\n",
    "            #    methods_data[method] += run_hungarian(\n",
    "            #        cost_matrix, printcost)\n",
    "            elif methods[method] == 'lap_lapjv' and i <= limit[methods[method]]:\n",
    "                methods_data[method] += run_lap_lapjv(\n",
    "                    cost_matrix, printcost)\n",
    "            elif methods[method] == 'lapjv_lapjv' and i <= limit[methods[method]]:\n",
    "                methods_data[method] += run_lapjv_lapjv(\n",
    "                    cost_matrix, printcost)\n",
    "            elif methods[method] == 'lapsolver' and i <= limit[methods[method]]:\n",
    "                methods_data[method] += run_lapsolver(\n",
    "                    cost_matrix, printcost)\n",
    "            elif methods[method] == 'laptools_clap' and i <= limit[methods[method]]:\n",
    "                methods_data[method] += run_laptools_clap(\n",
    "                    cost_matrix, printcost)\n",
    "                # If you want to benchmark a new METHOD, add another ELIF statement here\n",
    "            else:\n",
    "                pass\n",
    "            \n",
    "    # average the timing information from n_cyc cycles\n",
    "    for method in range(len(methods)):\n",
    "        if methods_data[method] != 0:   # to make sure there is timing information\n",
    "            t_methods[method] = np.append(t_methods[method],\n",
    "                                          np.array([[matrix_size, methods_data[method]/ncyc]]), axis=0) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print version and timing information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Package Versions for the current run\n",
      "Python -  3.7.6 | packaged by conda-forge | (default, Mar 23 2020, 23:03:20) \n",
      "[GCC 7.3.0]\n",
      "lap  -  0.4.0\n",
      "lapsolver  -  1.1.0\n",
      "laptools  -  0.1.7\n",
      "scipy  -  1.4.1\n",
      "munkres  -  1.1.2\n",
      "\n",
      "\n",
      "   Matrix_dims       8      16      32      64     128     256     512    1024    2048    4096    8192   \n",
      " lapjv_lapjv  [0.00003 0.00005 0.00003 0.00007 0.00016 0.00088 0.00375 0.01978 0.1088  0.67098 2.91433]\n",
      "   lap_lapjv  [0.00006 0.00004 0.00006 0.00007 0.00029 0.00117 0.0052  0.02481 0.16513 1.18349 8.33366]\n",
      "   lapsolver  [ 0.00003  0.00004  0.00005  0.00009  0.00045  0.0025   0.01211  0.07749  0.4336   2.33468 14.22419]\n",
      "laptools_clap  [0.00019 0.00017 0.00022 0.00033 0.00083 0.00373 0.01743 0.0723  0.39774 1.98782 9.8458 ]\n",
      "       scipy  [0.00007 0.00007 0.00014 0.00023 0.00065 0.00277 0.01192 0.05991 0.31778 1.62938 8.46878]\n",
      "     munkres  [0.00075 0.00673 0.05291 0.44745 3.99654]\n"
     ]
    }
   ],
   "source": [
    "#Print version information\n",
    "print(\"\\n\\nPackage Versions for the current run\")\n",
    "print(\"Python - \", sys.version)\n",
    "for method in methods:\n",
    "    tmp=method.split(\"_\")\n",
    "    # hungarian and lapjv don't print version numbers\n",
    "    if tmp[0] != 'hungarian':\n",
    "        if tmp[0] != 'lapjv':\n",
    "            ptmp=__import__(tmp[0])\n",
    "            method_version = ptmp.__version__\n",
    "            print(tmp[0], \" - \", ptmp.__version__)\n",
    "\n",
    "dimensions = t_methods[0][:, [0]]\n",
    "dimensions = dimensions.flatten()\n",
    "print(\"\\n\")\n",
    "print(\"  %12s \" % (\"Matrix_dims\"), end=\" \")\n",
    "np.set_printoptions(suppress=True, precision=5, linewidth=100)\n",
    "for i in range(len(dimensions)):\n",
    "    print('%6d ' % (dimensions[i]), end=\" \")\n",
    "print(\" \")\n",
    "\n",
    "np.set_printoptions(suppress=True, precision=5, linewidth=100)\n",
    "for method in range(len(methods)):\n",
    "    print('%12s ' % (methods[method]), end=\" \")\n",
    "    timings = t_methods[method][:, [1]]\n",
    "    timings = timings.flatten()\n",
    "    print(timings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate a plot\n",
    "Unless 'noplot=True'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure saved to file timing-LAPs-py3-8-16384.png\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x612 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if noplot:\n",
    "    pass\n",
    "else:\n",
    "    markers = []\n",
    "    markers = ['o', 'v', 's', 'D', 'P', '+', '*', '0', '1', '2']\n",
    "    marker_size = [50]\n",
    "    fig, ax = plt.subplots()\n",
    "    for method in range(len(methods)):\n",
    "        plt.scatter(t_methods[method][:, [0]], t_methods[method][:, [1]],\n",
    "                    s=marker_size, label=methods[method], marker=markers[method])\n",
    "        plt.loglog(t_methods[method][:, [0]], t_methods[method][:, [1]],\n",
    "                   basex=2, basey=10)\n",
    "\n",
    "    plt.grid(True, which=\"both\")\n",
    "    ax.xaxis.set_major_formatter(FormatStrFormatter('%d'))\n",
    "    plt.xlabel('Matrix column|row size', fontsize=18)\n",
    "    plt.ylabel('Real time to solution (seconds)', fontsize=18)\n",
    "    plt.title('Time to solve LAPs using different methods', fontsize=20)\n",
    "    plt.legend(fontsize=14)\n",
    "    fig_filename = \"timing-LAPs-py3-\" + \\\n",
    "        str(pow(2, minimum)) + \"-\" + str(pow(2, maximum)) + \".png\"\n",
    "    print(\"Figure saved to file %18s\" % (fig_filename))\n",
    "    fig.set_size_inches(11, 8.5)\n",
    "    plt.savefig(fig_filename, bbox_inches='tight', dpi=150)\n",
    "    if showplot:\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notes\n",
    "- compared to benchmarks in 2018 and 2019, the new LAP implementation in `scipy` has gotten much faster. In the past, it was moderately faster than `munkres` and it was too slow to solve anything larger than 512x512 problem, but now it is competitive with most fast implementations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "_Python3.7",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}