Code/02_MIP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load data\n",
    "\n",
    "Choose that dataset to load. We have prepared 2 different datasets, downloaded and converted from the competition:\n",
    "* wbg-fal10: dataset_01 ([ITC2019 description](https://www.itc2019.org/instances/status/5b59b12884ed6a262b1ce9d3))\n",
    "* pu-cs-fal07: dataset_04 ([ITC2019 description](https://www.itc2019.org/instances/status/5b59ebf984ed6a262b1ce9dc))\n",
    "\n",
    "Choose between datasets by adjusting the command `import dataset_0x as dataset`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from docplex.mp.model import Model\n",
    "import time\n",
    "import dataset_01 as dataset\n",
    "\n",
    "solution_filename = 'Solutions/sol_01_mp.py'\n",
    "progress_filename = 'Progress/log_01_mp.txt'\n",
    "\n",
    "rooms = dataset.rooms\n",
    "courses = dataset.courses\n",
    "students = dataset.students\n",
    "constraints = dataset.constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List of supporting tables:\n",
    "* `classes`: 150 classes with details\n",
    "* `classes_id`: ids from 1 to 150\n",
    "* `rooms_id`: ids from 1 to 7\n",
    "* `students_id`: ids from 1 to 19\n",
    "* `student_subparts`: pairs of 1 student & 1 subpart that he/she must attend (the subpart is a list of classes_id)\n",
    "* `student_classes`: pairs of 1 student & the list of all classes that he/she might attend (flattened from above subpart) -> 19 pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "rooms_id = [r['id'] for r in rooms]\n",
    "students_id = [s['id'] for s in students]\n",
    "\n",
    "# class-time pairs\n",
    "classes = []\n",
    "for course in courses:\n",
    "    for subpart in course['subpart']:\n",
    "        for c in subpart['class']:\n",
    "            classes.append(c)\n",
    "classes_id = [c['id'] for c in classes]\n",
    "\n",
    "# student-subpart pairs\n",
    "student_subparts = []\n",
    "for s in students_id:\n",
    "    for i in students[s-1]['course']:\n",
    "        for subpart in courses[i-1]['subpart']:\n",
    "            student_subparts.append([s,[c['id'] for c in subpart['class']]]) \n",
    "\n",
    "# student-classes pairs\n",
    "student_classes = []\n",
    "for s in students_id:\n",
    "    student_classes.append([s, []])\n",
    "    class_list = student_classes[-1][1]\n",
    "    for i in students[s-1]['course']:\n",
    "        for subpart in courses[i-1]['subpart']:\n",
    "            for c in subpart['class']:\n",
    "                class_list.append(c['id'])\n",
    "\n",
    "# pairs of classes with SameAttendee constraint\n",
    "SA_pairs=[]\n",
    "for ct in constraints:\n",
    "    if ct['type']=='SameAttendees':\n",
    "        for i1 in range(len(ct['class'])):\n",
    "            for i2 in range(i1+1, len(ct['class'])):\n",
    "                c1, c2 = ct['class'][i1], ct['class'][i2]\n",
    "                SA_pairs.append((c1,c2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### support functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clash(time1, time2):\n",
    "    clash_days = bool(sum([int(a) & int(b) for a,b in zip(time1['days'], time2['days'])]))\n",
    "    clash_weeks = bool(sum([int(a) & int(b) for a,b in zip(time1['weeks'], time2['weeks'])]))\n",
    "    clash_time1 = time1['start'] < time2['start'] + time2['length']\n",
    "    clash_time2 = time1['start'] + time1['length'] > time2['start']\n",
    "    return clash_days and clash_weeks and clash_time1 and clash_time2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decision Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Model('model1')\n",
    "\n",
    "# x = 1 if the class c takes place at time t, 0 otherwise\n",
    "x = m.binary_var_dict([(c,t) \n",
    "                       for c in classes_id \n",
    "                       for t in range(len(classes[c-1]['time']))], name= 'x')\n",
    "\n",
    "# y = 1 if the class c takes place at room r, 0 otherwise\n",
    "y = m.binary_var_dict([(c,r) \n",
    "                       for c in classes_id \n",
    "                       for r in range(len(classes[c-1]['room']))], name= 'y')\n",
    "\n",
    "# z = 1 if the student s takes class c, 0 otherwise\n",
    "z = m.binary_var_dict([(s,c) \n",
    "                       for s in students_id \n",
    "                       for c in student_classes[s-1][1]], name= 'z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objective functions\n",
    "(skip if only search for feasible solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Every class must be assigned a time\n",
    "m.add_constraints(m.sum(x[c,t] for t in range(len(classes[c-1]['time']))) == 1 \n",
    "                  for c in classes_id)\n",
    "\n",
    "# Every class must be assigned a room, where applicable\n",
    "m.add_constraints(m.sum(y[c,r] for r in range(len(classes[c-1]['room']))) == 1 \n",
    "                  for c in classes_id)\n",
    "\n",
    "# Every student must attend exactly one class for each subpart that he/she must attend\n",
    "m.add_constraints(m.sum(z[s,c] for c in subpart) == 1 \n",
    "                  for s, subpart in student_subparts)\n",
    "\n",
    "# For two classes with a parent-child relationship, if a class is assigned to a student\n",
    "# then the parent class must also be assigned\n",
    "m.add_constraints(z[s,c] <= z[s,classes[c-1]['parent']] \n",
    "                  for s in students_id \n",
    "                  for c in student_classes[s-1][1] if classes[c-1].get('parent', 0));\n",
    "\n",
    "# The capacity of each class in terms of the number of students must be satisfed\n",
    "m.add_constraints(m.sum(z[s,c] for s in students_id if c in student_classes[s-1][1]) <= classes[c-1]['limit'] \n",
    "                  for c in classes_id);\n",
    "\n",
    "# A room cannot be used when it is unavailable\n",
    "# there are no clashes in this test set\n",
    "for c in classes_id:\n",
    "    for t in range(len(classes[c-1]['time'])):\n",
    "        for r in range(len(classes[c-1]['room'])):\n",
    "            ctime = classes[c-1]['time'][t]\n",
    "            croom = rooms[classes[c-1]['room'][r]['id'] - 1]\n",
    "            penalty = classes[c-1]['room'][r]['penalty']\n",
    "            for room_uat in croom['unavailable']:\n",
    "                if clash(ctime, room_uat):\n",
    "                    m.add_constraint(x[c,t] + y[c,r] <= 1)\n",
    "\n",
    "# Any hard distribution constraints must be satisfied\n",
    "# in this instance refers to the same attendee requirement \n",
    "for c1, c2 in SA_pairs:\n",
    "    for t1 in range(len(classes[c1-1]['time'])):\n",
    "        for t2 in range(len(classes[c2-1]['time'])):\n",
    "            time1=classes[c1-1]['time'][t1]\n",
    "            time2=classes[c2-1]['time'][t2]\n",
    "            if clash(time1, time2):\n",
    "                m.add_constraint(x[c1,t1] + x[c2,t2] <= 1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Two class cannot be at the same time and in the same room (H8) (~3 minutes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two class cannot be at the same time and in the same room\n",
    "# Long time to run\n",
    "for i1 in range(len(classes_id)):\n",
    "    for i2 in range(i1+1, len(classes_id)):\n",
    "        c1, c2 = classes_id[i1], classes_id[i2]\n",
    "            \n",
    "        for t1 in range(len(classes[c1-1]['time'])):\n",
    "            for t2 in range(len(classes[c2-1]['time'])):\n",
    "                time1=classes[c1-1]['time'][t1]\n",
    "                time2=classes[c2-1]['time'][t2]\n",
    "                if clash(time1, time2):\n",
    "\n",
    "                    for r1 in range(len(classes[c1-1]['room'])):\n",
    "                        for r2 in range(len(classes[c2-1]['room'])):\n",
    "                            r1_id=classes[c1-1]['room'][r1]['id']\n",
    "                            r2_id=classes[c2-1]['room'][r2]['id']\n",
    "                            if r1_id==r2_id:\n",
    "                                m.add_constraint(x[c1,t1] + x[c2,t2] + y[c1,r1] + y[c2,r2] <= 3)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " - number of variables: 6272\n",
      "   - binary=6272, integer=0, continuous=0\n",
      " - number of constraints: 601751\n",
      "   - linear=601751\n"
     ]
    }
   ],
   "source": [
    "print(m.get_statistics())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### support functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_time(class_id, x_sol):\n",
    "    # output: time dict\n",
    "    for t in range(len(x_sol[class_id-1]['time'])):\n",
    "        if x_sol[class_id-1]['time'][t]==1:\n",
    "            return classes[class_id-1]['time'][t]\n",
    "\n",
    "def extract_room(class_id, y_sol):\n",
    "    # output: room dict{'id', 'penalty'}\n",
    "    for r in range(len(y_sol[class_id-1]['room'])):\n",
    "        if y_sol[class_id-1]['room'][r]==1:\n",
    "            return classes[class_id-1]['room'][r]\n",
    "\n",
    "def extract_xyz(sol):\n",
    "    '''\n",
    "    Input: Solution object (docplex.mp.solution.SolveSolution)\n",
    "    Output: x, y, z in python list format\n",
    "    '''\n",
    "    \n",
    "    # initialize x,y,z\n",
    "    x_sol = []\n",
    "    for c in classes_id:\n",
    "        x_sol.append({'id':c})\n",
    "        x_sol[-1]['time'] = [0]*len(classes[c-1]['time'])    \n",
    "\n",
    "    y_sol = []\n",
    "    for c in classes_id:\n",
    "        y_sol.append({'id':c})\n",
    "        y_sol[-1]['room'] = [0]*len(classes[c-1]['room'])      \n",
    "\n",
    "    z_sol = [[0]*len(classes_id) for _ in range(len(students_id))]\n",
    "    \n",
    "    # extract data\n",
    "    content = str(sol).split('\\n')\n",
    "    for line in content:\n",
    "        if len(line)==0 or line[0] not in ('x', 'y', 'z'):\n",
    "            continue\n",
    "        var, idx1, idx2 = line[:-2].split('_')\n",
    "        if var=='x':\n",
    "            x_sol[int(idx1)-1]['time'][int(idx2)] = 1\n",
    "        elif var=='y':\n",
    "            y_sol[int(idx1)-1]['room'][int(idx2)] = 1\n",
    "        elif var=='z':\n",
    "            z_sol[int(idx1)-1][int(idx2)-1] = 1\n",
    "    \n",
    "    return x_sol, y_sol, z_sol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_solution(sol):\n",
    "    '''\n",
    "    Input: Solution object (docplex.mp.solution.SolveSolution)\n",
    "    Function: Announce constraints violated by the solution\n",
    "    '''\n",
    "    print('---no output if all constraints passed---')\n",
    "    x_sol, y_sol, z_sol = extract_xyz(sol)\n",
    "    \n",
    "    # (1) check x\n",
    "    for i in x_sol:\n",
    "        if sum(i['time']) != 1:\n",
    "            print('Constraint (1) violated!')\n",
    "            break\n",
    "\n",
    "    # (2) check y\n",
    "    for i in y_sol:\n",
    "        if sum(i['room']) != 1:\n",
    "            print('Constraint (2) violated!')\n",
    "            break\n",
    "\n",
    "    # (3) check z\n",
    "    for s, class_list in student_subparts:\n",
    "        if sum([z_sol[s-1][c-1] for c in class_list]) != 1:\n",
    "            print('Constraint (3) violated!')\n",
    "            break\n",
    "\n",
    "    # (4) check parent-child relationship\n",
    "    for c in classes:\n",
    "        c_parent = c.get('parent', 0)\n",
    "        if c_parent:\n",
    "            for s in students_id:\n",
    "                # print out details if there is a constraint violation:\n",
    "                if z_sol[s-1][c['id']-1] > z_sol[s-1][c_parent-1]:\n",
    "                    print('Constraint (4) violated!')\n",
    "                    break\n",
    "\n",
    "    # (5) check class limit\n",
    "    for c in classes:\n",
    "        # print out details if there is a constraint violation:\n",
    "        if sum([z_sol[i][c['id']-1] for i in range(len(z_sol))]) > c['limit']:\n",
    "            print('Constraint (5) violated!')\n",
    "            break\n",
    "            \n",
    "    # (6) check room unavailable time\n",
    "    for c in classes_id:\n",
    "        ctime = extract_time(c, x_sol)\n",
    "        room_id = extract_room(c, y_sol)['id']\n",
    "        for room_uat in rooms[room_id-1]['unavailable']:\n",
    "            if clash(ctime, room_uat):\n",
    "                print('Constraint (6) violated!')\n",
    "                break\n",
    "\n",
    "    # (7) check SameAttendees\n",
    "    for c1, c2 in SA_pairs:\n",
    "        time1 = extract_time(c1, x_sol)\n",
    "        time2 = extract_time(c2, x_sol)\n",
    "        if clash(time1, time2):\n",
    "            print('Constraint (7) violated!')\n",
    "            break\n",
    "\n",
    "    # (8) check if 2 classes clash room-time constraint\n",
    "    for i1 in range(len(classes_id)):\n",
    "        for i2 in range(i1+1, len(classes_id)):\n",
    "            c1, c2 = classes_id[i1], classes_id[i2]\n",
    "            time1 = extract_time(c1, x_sol)\n",
    "            time2 = extract_time(c2, x_sol)\n",
    "            room1 = extract_room(c1, y_sol)\n",
    "            room2 = extract_room(c2, y_sol)\n",
    "            # print out details if there is a constraint violation:\n",
    "            if clash(time1, time2) and room1==room2:\n",
    "                print('Constraint (8) violated!')\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def objective(sol):\n",
    "    x_sol, y_sol, z_sol = extract_xyz(sol)\n",
    "    \n",
    "    # calculate objective value\n",
    "    time_penalty = 0\n",
    "    for c in classes_id:\n",
    "        for t in range(len(classes[c-1]['time'])):\n",
    "            if x_sol[c-1]['time'][t] == 1:\n",
    "                time_penalty += classes[c-1]['time'][t]['penalty']\n",
    "    \n",
    "    room_penalty = 0\n",
    "    for c in classes_id:\n",
    "        for r in range(len(classes[c-1]['room'])):\n",
    "            if y_sol[c-1]['room'][r] == 1:\n",
    "                room_penalty += classes[c-1]['room'][r]['penalty']\n",
    "\n",
    "    return time_penalty, room_penalty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solver\n",
    "* without objective: runtime = 5.29 s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration:  0 , Execution time:  17.570014715194702\n",
      "Time penalty:  144\n",
      "Room penalty:  38\n",
      "Total penalty:  182\n",
      "Iteration:  1 , Execution time:  17.280726671218872\n",
      "Time penalty:  128\n",
      "Room penalty:  36\n",
      "Total penalty:  164\n",
      "Iteration:  2 , Execution time:  16.171014070510864\n",
      "Time penalty:  120\n",
      "Room penalty:  33\n",
      "Total penalty:  153\n",
      "Iteration:  3 , Execution time:  16.765631198883057\n",
      "Time penalty:  112\n",
      "Room penalty:  33\n",
      "Total penalty:  145\n",
      "Iteration:  4 , Execution time:  16.919880867004395\n",
      "Time penalty:  96\n",
      "Room penalty:  37\n",
      "Total penalty:  133\n",
      "Iteration:  5 , Execution time:  20.267347812652588\n",
      "Time penalty:  96\n",
      "Room penalty:  28\n",
      "Total penalty:  124\n",
      "Iteration:  6 , Execution time:  19.42621684074402\n",
      "Time penalty:  88\n",
      "Room penalty:  28\n",
      "Total penalty:  116\n",
      "Iteration:  7 , Execution time:  17.807680368423462\n",
      "Time penalty:  16\n",
      "Room penalty:  30\n",
      "Total penalty:  46\n",
      "Iteration:  8 , Execution time:  18.407712697982788\n",
      "Time penalty:  0\n",
      "Room penalty:  30\n",
      "Total penalty:  30\n",
      "Iteration:  9 , Execution time:  16.324589014053345\n",
      "Time penalty:  0\n",
      "Room penalty:  28\n",
      "Total penalty:  28\n",
      "Iteration:  10 , Execution time:  16.073149919509888\n",
      "Time penalty:  0\n",
      "Room penalty:  27\n",
      "Total penalty:  27\n",
      "Iteration:  11 , Execution time:  17.983423233032227\n",
      "Time penalty:  0\n",
      "Room penalty:  25\n",
      "Total penalty:  25\n",
      "Iteration:  12 , Execution time:  17.726499795913696\n",
      "Time penalty:  0\n",
      "Room penalty:  24\n",
      "Total penalty:  24\n",
      "Iteration:  13 , Execution time:  15.550103425979614\n",
      "Time penalty:  0\n",
      "Room penalty:  22\n",
      "Total penalty:  22\n",
      "Iteration:  14 , Execution time:  15.487870454788208\n",
      "Time penalty:  0\n",
      "Room penalty:  21\n",
      "Total penalty:  21\n",
      "Iteration:  15 , Execution time:  16.38615083694458\n",
      "Time penalty:  0\n",
      "Room penalty:  19\n",
      "Total penalty:  19\n",
      "Iteration:  16 , Execution time:  16.147879362106323\n",
      "Time penalty:  0\n",
      "Room penalty:  18\n",
      "Total penalty:  18\n",
      "Iteration:  17 , Execution time:  14.8906831741333\n",
      "Time penalty:  0\n",
      "Room penalty:  17\n",
      "Total penalty:  17\n",
      "Iteration:  18 , Execution time:  31.22014045715332\n",
      "Time penalty:  0\n",
      "Room penalty:  17\n",
      "Total penalty:  17\n",
      "Stopping criteria met\n"
     ]
    }
   ],
   "source": [
    "it = 0\n",
    "executionTime = 0\n",
    "obj = []\n",
    "exec_time = []\n",
    "sol_prev = None\n",
    "\n",
    "while True:\n",
    "    startTime = time.time()\n",
    "    \n",
    "    m.set_time_limit(30)\n",
    "    sol = m.solve(log_output=False)\n",
    "\n",
    "    executionTime = (time.time() - startTime)\n",
    "    print('Iteration: ', it, ', Execution time: ', str(executionTime))\n",
    "    \n",
    "    # save the progress\n",
    "    if sol:\n",
    "        sol_prev = sol\n",
    "    sol_time, sol_room = objective(sol_prev)\n",
    "    sol_penalty = sol_time + sol_room\n",
    "    print('Time penalty: ', sol_time)\n",
    "    print('Room penalty: ', sol_room)\n",
    "    print('Total penalty: ', sol_penalty)\n",
    "    obj.append([sol_time, sol_room, sol_penalty])\n",
    "    exec_time.append(executionTime)\n",
    "    \n",
    "    filename = progress_filename\n",
    "    file = open(filename, 'w')\n",
    "    file.write(str(obj) + '\\n' + str(exec_time))\n",
    "    file.close()\n",
    "    \n",
    "    # stopping criteria\n",
    "    #if executionTime > 30 or it > 50 or sol_penalty < 0.15 * obj[0][2]:\n",
    "    if executionTime > 30 or it > 50:\n",
    "        print('Stopping criteria met')\n",
    "        break\n",
    "    \n",
    "    # update model constraints\n",
    "    time_penalty = m.sum(x[c,t]*classes[c-1]['time'][t]['penalty'] \n",
    "                         for c in classes_id for t in range(len(classes[c-1]['time'])))\n",
    "    room_penalty = m.sum(y[c,r]*classes[c-1]['room'][r]['penalty'] \n",
    "                         for c in classes_id for r in range(len(classes[c-1]['room'])))\n",
    "    m.add_constraint(time_penalty + room_penalty <= sol_penalty-1)\n",
    "    \n",
    "    it += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* save solution to text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = solution_filename\n",
    "\n",
    "file = open(filename, 'w')\n",
    "file.write(str(sol_prev))\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---no output if all constraints passed---\n"
     ]
    }
   ],
   "source": [
    "check_solution(sol_prev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* plot objective through time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total runtime: 338.4067 seconds\n",
      "Objective value: 17\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import json\n",
    "\n",
    "fileObj=open(progress_filename,\"r\")\n",
    "content=fileObj.readlines()\n",
    "obj = json.loads(content[0][:-1])\n",
    "exec_time = json.loads(content[1])\n",
    "\n",
    "print('Total runtime: {0:.4f} seconds'.format(sum(exec_time)))\n",
    "print('Objective value: {0}'.format(obj[-1][-1]))\n",
    "\n",
    "plt.figure(figsize=(20,10))\n",
    "ax = plt.gca()\n",
    "ax2 = ax.twinx()\n",
    "\n",
    "ax.plot([i for i in range(len(obj))], [val[2] for val in obj], marker='o', label='Objective')\n",
    "ax.plot([i for i in range(len(obj))], [val[0] for val in obj], marker='o', label='Time_penalty')\n",
    "ax.plot([i for i in range(len(obj))], [val[1] for val in obj], marker='o', label='Room_penalty')\n",
    "ax.set_ylabel('Objective', fontsize=14)\n",
    "ax.set_xlabel('Iterations', fontsize=14)\n",
    "\n",
    "ax2.plot([i for i in range(len(obj))], [val for val in exec_time], linestyle='dashed', color='orange', label='exec_time')\n",
    "ax2.set_ylabel('Execution time')\n",
    "ax2.set_ylim(0, max(exec_time))\n",
    "\n",
    "ax.legend()\n",
    "ax2.legend(loc='lower right')\n",
    "plt.show();"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}