KnapsackProblem.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import importlib as imp\n",
    "\n",
    "from tqdm import tqdm, tqdm_notebook\n",
    "import warnings\n",
    "warnings.simplefilter('ignore')\n",
    "pd.options.display.max_columns = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **p01_c.txt**, the knapsack capacity. <br>\n",
    "- **p01_w.txt**, the weights of the objects. <br>\n",
    "- **p01_p.txt**, the profits of each object. <br>\n",
    "- **p01_s.txt**, the optimal selection of weights. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import tools\n",
    "tools = imp.reload(tools)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01 is loaded!\n",
      "02 is loaded!\n",
      "03 is loaded!\n",
      "04 is loaded!\n",
      "05 is loaded!\n",
      "06 is loaded!\n",
      "07 is loaded!\n",
      "Wall time: 29.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n = np.arange(1,8)\n",
    "benchmarks = {k: tools.get_knapsack(n='0'+str(k)) for k in n}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'capacity': [165],\n",
       " 'weights': [23, 31, 29, 44, 53, 38, 63, 85, 89, 82],\n",
       " 'profits': [92, 57, 49, 68, 60, 43, 67, 84, 87, 72],\n",
       " 'optimal': [1, 1, 1, 1, 0, 1, 0, 0, 0, 0]}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "benchmarks[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import tools\n",
    "tools = imp.reload(tools)\n",
    "from algorithm import brute_force, greedy, genetic, bound_and_branches, dynamic\n",
    "brute_force = imp.reload(brute_force)\n",
    "greedy      = imp.reload(greedy)\n",
    "genetic     = imp.reload(genetic)\n",
    "bound_and_branches = imp.reload(bound_and_branches)\n",
    "dynamic = imp.reload(dynamic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 563,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Genetic optimal profit 1735 and weight 169\n",
      "Real optimal profit 1735 and maximum weight 169\n"
     ]
    }
   ],
   "source": [
    "i = 6\n",
    "knap = benchmarks[i]\n",
    "\n",
    "param = {'n_epoch': 5000,\n",
    "         'eps': 0.5,\n",
    "         'chaos': 20,\n",
    "         'n_chrom': 15}\n",
    "knap = dict(knap, **param)\n",
    "alg = genetic.Genetic(knap)\n",
    "opt = alg.solve()\n",
    "print('{} optimal solution {}'.format(alg.name, opt))\n",
    "alg_knap = tools.compute_knapsack(knap, opt)\n",
    "real_knap = tools.compute_knapsack(knap, knap['optimal'])\n",
    "print('{} optimal profit {} and weight {}'.format(alg.name, alg_knap[1], alg_knap[0]))\n",
    "print('Real optimal profit {} and maximum weight {}'.format(real_knap[1],real_knap[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "data/large_scale\\knapPI_2_10000_1000_1\n",
      "90204\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(49877, 90204)"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import glob\n",
    "tools = imp.reload(tools)\n",
    "complexity = ['low-dimensional', 'large_scale']\n",
    "h = 1\n",
    "data_lst = glob.glob('data/'+complexity[h]+'/*')\n",
    "print(len(data_lst))\n",
    "i = 7\n",
    "print(data_lst[i])\n",
    "kdct = tools.get_kdct(data_lst[i], with_optimum=True)\n",
    "with open('data/'+complexity[h]+'-optimum/'+data_lst[i].split('\\\\')[-1] ,'r') as f:\n",
    "    print(f.read())\n",
    "tools.compute_knapsack(kdct, kdct['optimal'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Low-dimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f10_l-d_kp_20_879\n",
      " - capacity: *879*<br>\n",
      " - optimal profit: *1025*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 837, and profit **1019**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.02s```<br>\n",
      "     optimal weight: 871.0, and profit **1025.0**<br>\n",
      "  **Dynamic**  ```exec time 0.09s```<br>\n",
      "     optimal weight: 871, and profit **1025**<br>\n",
      "  **Genetic**  ```exec time 0.31s```<br>\n",
      "     optimal weight: 871, and profit **1025**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f1_l-d_kp_10_269\n",
      " - capacity: *269*<br>\n",
      " - optimal profit: *295*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 260, and profit **294**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.03s```<br>\n",
      "     optimal weight: 269.0, and profit **295.0**<br>\n",
      "  **Dynamic**  ```exec time 0.02s```<br>\n",
      "     optimal weight: 269, and profit **295**<br>\n",
      "  **Genetic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 269, and profit **295**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f2_l-d_kp_20_878\n",
      " - capacity: *878*<br>\n",
      " - optimal profit: *1024*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 837, and profit **1018**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.03s```<br>\n",
      "     optimal weight: 871.0, and profit **1024.0**<br>\n",
      "  **Dynamic**  ```exec time 0.14s```<br>\n",
      "     optimal weight: 871, and profit **1024**<br>\n",
      "  **Genetic**  ```exec time 0.41s```<br>\n",
      "     optimal weight: 871, and profit **1024**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f3_l-d_kp_4_20\n",
      " - capacity: *20*<br>\n",
      " - optimal profit: *35*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 18, and profit **35**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.01s```<br>\n",
      "     optimal weight: 18.0, and profit **35.0**<br>\n",
      "  **Dynamic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 18, and profit **35**<br>\n",
      "  **Genetic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 18, and profit **35**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f4_l-d_kp_4_11\n",
      " - capacity: *11*<br>\n",
      " - optimal profit: *23*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 6, and profit **16**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.02s```<br>\n",
      "     optimal weight: 11.0, and profit **23.0**<br>\n",
      "  **Dynamic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 11, and profit **23**<br>\n",
      "  **Genetic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 11, and profit **23**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f6_l-d_kp_10_60\n",
      " - capacity: *60*<br>\n",
      " - optimal profit: *52*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 57, and profit **52**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.04s```<br>\n",
      "     optimal weight: 57.0, and profit **52.0**<br>\n",
      "  **Dynamic**  ```exec time 0.01s```<br>\n",
      "     optimal weight: 60, and profit **52**<br>\n",
      "  **Genetic**  ```exec time 0.01s```<br>\n",
      "     optimal weight: 58, and profit **48**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f7_l-d_kp_7_50\n",
      " - capacity: *50*<br>\n",
      " - optimal profit: *107*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 48, and profit **102**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.02s```<br>\n",
      "     optimal weight: 50.0, and profit **107.0**<br>\n",
      "  **Dynamic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 50, and profit **107**<br>\n",
      "  **Genetic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 50, and profit **107**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f8_l-d_kp_23_10000\n",
      " - capacity: *10000*<br>\n",
      " - optimal profit: *9767*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 9750, and profit **9751**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.05s```<br>\n",
      "     optimal weight: 9768.0, and profit **9767.0**<br>\n",
      "  **Dynamic**  ```exec time 1.11s```<br>\n",
      "     optimal weight: 9768, and profit **9767**<br>\n",
      "  **Genetic**  ```exec time 0.42s```<br>\n",
      "     optimal weight: 9765, and profit **9764**<br>\n",
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack f9_l-d_kp_5_80\n",
      " - capacity: *80*<br>\n",
      " - optimal profit: *130*<br>\n",
      "  **Greedy**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 60, and profit **130**<br>\n",
      "  **Branch-And-Bound**  ```exec time 0.01s```<br>\n",
      "     optimal weight: 60.0, and profit **130.0**<br>\n",
      "  **Dynamic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 60, and profit **130**<br>\n",
      "  **Genetic**  ```exec time 0.00s```<br>\n",
      "     optimal weight: 60, and profit **130**<br>\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "from datetime import datetime\n",
    "tools = imp.reload(tools)\n",
    "complexity = 'low-dimensional'\n",
    "data_lst = sorted(glob.glob('data/'+complexity+'/*'))\n",
    "\n",
    "for data in data_lst:\n",
    "#     print(data)\n",
    "    if 'kp_15_375' in data:\n",
    "#         print(data)\n",
    "        continue\n",
    "    knapsack = tools.get_kdct(data, with_optimum=False)\n",
    "    bm_name  = data.split('\\\\')[-1] \n",
    "    with open('data/'+complexity+'-optimum/'+bm_name, 'r') as f:\n",
    "        opt_profit = f.read()\n",
    "    z = 30\n",
    "    opt_w, opt_p = tools.compute_knapsack(knapsack, knapsack['optimal'])\n",
    "    print('\\n--- \\n')\n",
    "    print('\\n' + '## Knapsack {}'.format(bm_name))\n",
    "    print(' - capacity: *{}*<br>'.format(knapsack['capacity'][0]))\n",
    "    print(' - optimal profit: *{}*<br>'.format(opt_profit))\n",
    "\n",
    "    param = {'n_epoch': 450,\n",
    "             'eps': 0.3,\n",
    "             'chaos': 15,\n",
    "             'n_chrom': 20}\n",
    "    algorithms = [greedy.Greedy,\n",
    "                  bound_and_branches.BranchAndBound,\n",
    "                  dynamic.Dynamic,\n",
    "                  genetic.Genetic]\n",
    "    for alg in algorithms:\n",
    "        knapsack = dict(knapsack, **param)\n",
    "        start_time = datetime.now()\n",
    "        alg     = alg(knapsack)\n",
    "        alg_opt = alg.solve()\n",
    "        end_time = datetime.now() - start_time\n",
    "        alg_opt_w, alg_opt_p = tools.compute_knapsack(knapsack, alg_opt)\n",
    "#         print('   **{}** optimal solution: ```{}```<br>'.format(alg.name, alg_opt))\n",
    "        print('  **{}**  ```exec time {:.2f}s```<br>'.format(alg.name, end_time.total_seconds()))\n",
    "        print('     optimal weight: {}, and profit **{}**<br>'.format(alg_opt_w, alg_opt_p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Large-scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- \n",
      "\n",
      "\n",
      "## Knapsack knapPI_1_10000_1000_1\n",
      " - capacity: *49877*<br>\n",
      " - optimal weight: *49877*, optimal profit: *563647*<br>\n",
      "  **Greedy**  ```exec time 0.02s```<br>\n",
      "     optimal weight: 49876, and profit **563605**<br>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "CPLEX Error  1016: Community Edition. Problem size limits exceeded. Purchase at http://ibm.biz/error1016.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPLEX Error  1016: Community Edition. Problem size limits exceeded. Purchase at http://ibm.biz/error1016.\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "from datetime import datetime\n",
    "tools = imp.reload(tools)\n",
    "complexity = 'large_scale'\n",
    "data_lst = sorted(glob.glob('data/'+complexity+'/*'))\n",
    "\n",
    "for data in data_lst:\n",
    "\n",
    "    knapsack = tools.get_kdct(data, with_optimum=True)\n",
    "    bm_name  = data.split('\\\\')[-1] \n",
    "    z = 30\n",
    "    opt_w, opt_p = tools.compute_knapsack(knapsack, knapsack['optimal'])\n",
    "    print('\\n--- \\n')\n",
    "    print('\\n' + '## Knapsack {}'.format(bm_name))\n",
    "    print(' - capacity: *{}*<br>'.format(knapsack['capacity'][0]))\n",
    "    print(' - optimal weight: *{}*, optimal profit: *{}*<br>'.format(opt_w, opt_p))\n",
    "\n",
    "    param = {'n_epoch': 450,\n",
    "             'eps': 0.3,\n",
    "             'chaos': 15,\n",
    "             'n_chrom': 20}\n",
    "    algorithms = [greedy.Greedy,\n",
    "                  bound_and_branches.BranchAndBound,\n",
    "                  dynamic.Dynamic,\n",
    "                  genetic.Genetic]\n",
    "    for alg in algorithms:\n",
    "        knapsack = dict(knapsack, **param)\n",
    "        start_time = datetime.now()\n",
    "        alg     = alg(knapsack)\n",
    "        alg_opt = alg.solve()\n",
    "        end_time = datetime.now() - start_time\n",
    "        if alg_opt != -1:\n",
    "            alg_opt_w, alg_opt_p = tools.compute_knapsack(knapsack, alg_opt)\n",
    "            print('  **{}**  ```exec time {:.2f}s```<br>'.format(alg.name, end_time.total_seconds()))\n",
    "            print('     optimal weight: {}, and profit **{}**<br>'.format(alg_opt_w, alg_opt_p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pprint\n",
    "for key in benchmarks:\n",
    "    \n",
    "    knapsack = benchmarks[key]\n",
    "    z = 30\n",
    "    opt_w, opt_p = tools.compute_knapsack(knapsack, knapsack['optimal'])\n",
    "    print('--- \\n')\n",
    "    print('\\n' + '## Knapsack 0{}'.format(key))\n",
    "    print(' - capacity: *{}*<br>'.format(knapsack['capacity'][0]))\n",
    "    print(' - optimal solution: ```{}```<br>'.format(knapsack['optimal']))\n",
    "    print(' - optimal weight: *{}*, and profit: *{}*<br>'.format(opt_w, opt_p))\n",
    "\n",
    "    param = {'n_epoch': 5000,\n",
    "             'eps': 0.5,\n",
    "             'chaos': 20,\n",
    "             'n_chrom': 15}\n",
    "    algorithms = [brute_force.BruteForce,\n",
    "                  greedy.Greedy,\n",
    "                  bound_and_branches.BranchAndBound,\n",
    "                  dynamic.Dynamic,\n",
    "                  genetic.Genetic]\n",
    "    for alg in algorithms:\n",
    "        knapsack = dict(knapsack, **param)\n",
    "        alg     = alg(knapsack)\n",
    "        alg_opt = alg.solve()\n",
    "        alg_opt_w, alg_opt_p = tools.compute_knapsack(knapsack, alg_opt)\n",
    "        print('   **{}** optimal solution: ```{}```<br>'.format(alg.name, alg_opt))\n",
    "        print('          optimal weight: {}, and profit **{}**'.format(alg_opt_w, alg_opt_p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# kdct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(49877, 563647)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 564,
   "metadata": {},
   "outputs": [],
   "source": [
    "genetic_param = {'n_epoch': 500,\n",
    "                 'eps': 0.3,\n",
    "                 'chaos': 20,\n",
    "                 'n_chrom': 15}\n",
    "\n",
    "algorithms = [brute_force.BruteForce,\n",
    "              greedy.Greedy,\n",
    "              bound_and_branches.BranchAndBound,\n",
    "              dynamic.Dynamic,\n",
    "              genetic.Genetic]\n",
    "\n",
    "alg_params = [{},\n",
    "              {},\n",
    "              {},\n",
    "              {},\n",
    "              genetic_param]\n",
    "\n",
    "\n",
    "stat_df = tools.generate_stat(algorithms, \n",
    "                        benchmarks, \n",
    "                        alg_params, \n",
    "                        n_observations=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 595,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|   benchmark | algorithm        |   execution mean |   execution std |   capacity |   optim_weight |   optim_profit |\n",
      "|------------:|:-----------------|-----------------:|----------------:|-----------:|---------------:|---------------:|\n",
      "|           1 | Branch-And-Bound |           0      |          0      |        165 |            165 |            309 |\n",
      "|           1 | BruteForce       |           0.0016 |          0.0005 |        165 |            165 |            309 |\n",
      "|           1 | Dynamic          |           0.006  |          0.0007 |        165 |            165 |            309 |\n",
      "|           1 | Genetic          |           0.0145 |          0.0089 |        165 |            165 |            309 |\n",
      "|           1 | Greedy           |           0      |          0      |        165 |            165 |            309 |\n",
      "|           2 | Branch-And-Bound |           0      |          0      |         26 |             26 |             51 |\n",
      "|           2 | BruteForce       |           0      |          0      |         26 |             26 |             51 |\n",
      "|           2 | Dynamic          |           0.0006 |          0.0005 |         26 |             26 |             51 |\n",
      "|           2 | Genetic          |           0.0004 |          0.0005 |         26 |             24 |             47 |\n",
      "|           2 | Greedy           |           0      |          0      |         26 |             23 |             47 |\n",
      "|           3 | Branch-And-Bound |           0.0002 |          0.0005 |        190 |            190 |            150 |\n",
      "|           3 | BruteForce       |           0      |          0      |        190 |            190 |            150 |\n",
      "|           3 | Dynamic          |           0.0044 |          0.0006 |        190 |            190 |            150 |\n",
      "|           3 | Genetic          |           0.0004 |          0.0005 |        190 |            172 |            119 |\n",
      "|           3 | Greedy           |           0      |          0      |        190 |            179 |            146 |\n",
      "|           4 | Branch-And-Bound |           0      |          0      |         50 |             50 |            107 |\n",
      "|           4 | BruteForce       |           0.0006 |          0.0005 |         50 |             50 |            107 |\n",
      "|           4 | Dynamic          |           0.0012 |          0.0004 |         50 |             50 |            107 |\n",
      "|           4 | Genetic          |           0.0014 |          0.0009 |         50 |             50 |            107 |\n",
      "|           4 | Greedy           |           0      |          0      |         50 |             48 |            102 |\n",
      "|           5 | Branch-And-Bound |           0      |          0      |        104 |            104 |            900 |\n",
      "|           5 | BruteForce       |           0.0004 |          0.0005 |        104 |            104 |            900 |\n",
      "|           5 | Dynamic          |           0.0038 |          0.0008 |        104 |            104 |            900 |\n",
      "|           5 | Genetic          |           0.0032 |          0.0008 |        104 |            103 |            898 |\n",
      "|           5 | Greedy           |           0      |          0      |        104 |             97 |            858 |\n",
      "|           6 | Branch-And-Bound |           0.0002 |          0.0004 |        170 |            169 |           1735 |\n",
      "|           6 | BruteForce       |           0.0002 |          0.0005 |        170 |            169 |           1735 |\n",
      "|           6 | Dynamic          |           0.0052 |          0.0008 |        170 |            169 |           1735 |\n",
      "|           6 | Genetic          |           0.001  |          0.0007 |        170 |            169 |           1735 |\n",
      "|           6 | Greedy           |           0      |          0      |        170 |            140 |           1478 |\n",
      "|           7 | Branch-And-Bound |           0.0042 |          0.0008 |        750 |            749 |           1458 |\n",
      "|           7 | BruteForce       |           0.0541 |          0.0147 |        750 |            749 |           1458 |\n",
      "|           7 | Dynamic          |           0.058  |          0.0047 |        750 |            749 |           1458 |\n",
      "|           7 | Genetic          |           0.306  |          0.0365 |        750 |            749 |           1458 |\n",
      "|           7 | Greedy           |           0.0002 |          0.0004 |        750 |            740 |           1441 |\n"
     ]
    }
   ],
   "source": [
    "stat = stat_df.groupby(['benchmark', 'algorithm']).agg({'execution':['mean','std'],\n",
    "                                                        'capacity': 'median',\n",
    "                                                        'optim_weight': 'median',\n",
    "                                                        'optim_profit': 'median'})\n",
    "stat.columns = [ 'execution mean', 'execution std', 'capacity','optim_weight', 'optim_profit']\n",
    "stat = np.around(stat, 4).reset_index()\n",
    "stat = stat.set_index(['benchmark'])\n",
    "print(stat.to_markdown())"
   ]
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}