{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ca8bc9c",
   "metadata": {
    "id": "5ca8bc9c"
   },
   "source": [
    "# Job Shop Scheduling: Heuristics\n",
    "\n",
    "In the previous [tutorial on Job Shop Scheduling: Basics and State Space Search](https://homepages.ecs.vuw.ac.nz/~yimei/tutorials/job-shop-scheduling-state-space-search.html), we have introduced the basics of **job shop scheduling** and an AI planning **state space search** algorithm to find the best schedule with the minimal makespan.\n",
    "\n",
    "The state space search algorithm searches all the possible goal states (schedules) exhaustively. Although the exhaustive search can guarantee optimality, its **computation complexity grows exponentially with the increase of the problem size**. \n",
    "\n",
    "> The computational complexity of the state space exhaustive search is $O(N^{NM})$, where $N$ is the number of jobs and $M$ is the number of machines.\n",
    "\n",
    "Therefore, it is usually not possible to enumerate all the possible solutions / goal states to find the optimal solution.\n",
    "\n",
    "> The job shop scheduling problem is known as $\\mathbb{NP}$-hard, which means there is no exact method that can find the optimal schedule in polynomial time.\n",
    "\n",
    "As the problem size increases, it is impossible to enumerate all the possible solutions. In this case, we can develop **heuristic search** approaches to search **ONLY a part** of the solution space, to find **good enough** solutions within **a reasonable time**. \n",
    "\n",
    "In this tutorial, we introduce the heuristic search approaches for job shop scheduling, including the **dispatching rule** and **local search**.\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "1. [General Heuristic Search Framework](#framework)\n",
    "2. [Dispatching Rule](#rule)\n",
    "3. [Local Search](#ls)\n",
    "\n",
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325c0177",
   "metadata": {},
   "source": [
    "## 1. General Heuristic Search Framework <a name='framework'></a>\n",
    "\n",
    "\n",
    "As described in the previous [tutorial](https://homepages.ecs.vuw.ac.nz/~yimei/tutorials/job-shop-scheduling-state-space-search.html), the pseudo code of the **exhaustive state space search** for job shop scheduling is given as follows.\n",
    "\n",
    "---------\n",
    "\n",
    "```python\n",
    "Generate an initial state, best_state = None, best_makespan = infinity\n",
    "# Initialise the fringe with the initial state\n",
    "fringe = [initial_state]\n",
    "\n",
    "# Search by expanding a branch at each step\n",
    "while fringe is not empty:\n",
    "    Pick a state from fringe\n",
    "    \n",
    "    if state is a goal state:\n",
    "        if state.schedule has a smaller makespan than best_makespan:\n",
    "            best_state = state, best_makespan = makespan\n",
    "    \n",
    "    Find the applicable actions at state\n",
    "    \n",
    "    for action in applicable_actions:\n",
    "        Apply action to state to generate next_state\n",
    "        Add next_state into fringe\n",
    "\n",
    "    remove state from fringe\n",
    "return best_state.schedule\n",
    "```\n",
    "\n",
    "-------------\n",
    "\n",
    "It **enumerates** all the possible solutions by \n",
    "\n",
    "1. Expand the branches of **ALL** the applicable actions at each state during the search;\n",
    "2. Stop the search after **ALL** the goal states have been visited.\n",
    "\n",
    "As the problem size increases, it is impossible to enumerate all the possible solutions. In this case, we develop heuristic search approaches to search **a part** of the solution space, to find **good enough** solutions within **a reasonable time**. \n",
    "\n",
    "Generally speaking, the heuristic search approaches are based on pruning the search space by ignoring the branches that are unlikely to reach promising/optimal solutions. This is also known as the **beam search**. The pruning can be done by modifying the above pseudo code as follows.\n",
    "\n",
    "1. Expand the branches of **only a subset** of the applicable actions at each state;\n",
    "2. **Early stop** the search.\n",
    "3. Note that the state space search picks states from the fringe arbitrarily. To further improve the search efficiency, we can design heuristics to pick the **best state** first, so we can expand the better branches first and stop the search earlier.\n",
    "\n",
    "Taking the above factors into account, the **heuristic search** in the state space can be written as follows.\n",
    "\n",
    "---------\n",
    "\n",
    "```python\n",
    "Generate an initial state, best_state = None, best_makespan = infinity\n",
    "# Initialise the fringe with the initial state\n",
    "fringe = [initial_state]\n",
    "\n",
    "# Search by expanding a branch at each step\n",
    "while fringe is not empty:\n",
    "    Heuristic select a state from fringe\n",
    "    \n",
    "    if state is a goal state:\n",
    "        if state.schedule has a smaller makespan than best_makespan:\n",
    "            best_state = state, best_makespan = makespan\n",
    "        if early stop:\n",
    "            return best_state.schedule\n",
    "    \n",
    "    Find the applicable actions at state\n",
    "    \n",
    "    for action in subset(applicable_actions):\n",
    "        Apply action to state to generate next_state\n",
    "        Add next_state into fringe\n",
    "\n",
    "    remove state from fringe\n",
    "return best_state.schedule\n",
    "```\n",
    "\n",
    "-------------\n",
    "\n",
    "In this heuristic search, there are three design issues:\n",
    "\n",
    "1. The heuristic to select the next state from the fringe to expand.\n",
    "2. The subset `subset(applicable_actions)` that selects the subset of the applicable actions to expand.\n",
    "3. The early stopping criterion.\n",
    "\n",
    "Below we introduce some common design of the heuristics.\n",
    "\n",
    "-------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4716777c",
   "metadata": {},
   "source": [
    "## 2. Dispatching Rule <a name='rule'></a>\n",
    "\n",
    "Dispatching rule is a very simple heuristic that expands **only one** action at each state. Therefore, starting with a single initial state, the fringe always contains a single state. Thus, at each step we trivially select the only state in the fringe. As a result, only a single goal state will be reached. Thus, The stopping criterion is also trivial: the search will stop after the first and only goal state is reached.\n",
    "\n",
    "For example, if we are given the following state space to be searched in:\n",
    "\n",
    "<img src=\"img/jss-state-search.png\" width=600 /> \n",
    "\n",
    "The search based on dispatching rule will select one branch (highlighted in blue boxes) at each state and finally reach a single goal state (a leaf node in the search tree).\n",
    "\n",
    "<img src=\"img/jss-rule-search.png\" width=600 />\n",
    "\n",
    "A dispatching rule selects the single action from the applicable actions based on the following two steps.\n",
    "\n",
    "1. Select the **earliest** applicable action (with the smallest start time).\n",
    "2. If there are multiple earliest applicable actions, then select an action based on the predefined **priority function**. Specifically, for each earliest applicable actions, a priority value in the current state is calculated by the priority function. Then, the action with the **highest priority** is selected.\n",
    "\n",
    "The heuristic search based on dispatching rule can be written as follows.\n",
    "\n",
    "---------\n",
    "\n",
    "```python\n",
    "Generate an initial state\n",
    "# Initialise the fringe with the initial state\n",
    "fringe = [initial_state]\n",
    "\n",
    "# Search process, the fringe will become empty after the first and only goal state is reached\n",
    "while fringe is not empty:\n",
    "    # Select the first and only state in the fringe\n",
    "    state = fringe[0]\n",
    "    \n",
    "    if state is a goal state:\n",
    "        return state.schedule\n",
    "    \n",
    "    Find the applicable actions at state\n",
    "    \n",
    "    # Select the earliest action with the highest priority\n",
    "    best_action = None, earliest_time = float('inf'), best_priority = -float('inf')\n",
    "    for action in applicable_actions:\n",
    "        if action.time < earliest_time:\n",
    "            best_action = action, earliest_time = action.time, best_priority = priority(action, state)\n",
    "        elif action.time == earliest_time:  \n",
    "            p = priority(action, state)\n",
    "            if p > best_priority:\n",
    "                best_action = action, best_priority = p\n",
    "    \n",
    "    Apply best_action to state to generate next_state\n",
    "    Add next_state into fringe\n",
    "\n",
    "    remove state from fringe\n",
    "```\n",
    "\n",
    "-------------\n",
    "\n",
    "> Dispatching rule has a promising characteristic that it always expends an earliest action. Taking advantage of this characteristic, we can convert the above procedure into a much more efficient **discrete event simulation** procedure with priority queue.\n",
    "\n",
    "Below are some examples of commonly used dispatching rules.\n",
    "\n",
    "- **First-Come-First-Serve (FCFS)**: it processes the operation that comes to the machine (becomes ready) first. The priority function can be defined as the negative ready time of the processed operation, i.e., `priority(action, state) = - state.operation_ready_time[action.operation]`.\n",
    "- **Shortest-Processing-Time (SPT)**: it processes the shortest operation with the smallest processing time first. The priority function can be defined as the negative processing time, i.e., `priority(action, state) = - action.operation.duration`.\n",
    "\n",
    "### Computational Complexity\n",
    "\n",
    "Assume that there are $N$ jobs and $M$ machines. Each job has $M$ operations, each to be processed by a different machine. There are $NM$ operations in total.\n",
    "\n",
    "At each state, there can be at most $N$ applicable actions, as each job can have an operation ready. Therefore, it takes $O(N)$ time to find the best action from the $N$ applicable actions. However, only one branch is expanded.\n",
    "\n",
    "Each action completes an operation. Thus, it takes $NM$ actions from the initial state to a goal state. In other words, the depth of the tree is $NM$.\n",
    "\n",
    "In summary, a dispatching rule generates a chain-like search tree where each node has only one branch expanded. The entire search process visits $NM$ states, where each state takes $O(N)$ time to find the expanded branch. Therefore, the overall complexity of the dispatching rule-based heuristic search is $O(N^2M)$.\n",
    "\n",
    "> If the procedure is implemented by a **discrete event simulation**, for each state, we can obtain the earliest applicable actions in $O(1)$ time. In this case, we can find the best branch in $O(E)$ time, where $E$ is the number of earliest applicable action, which is usually much smaller than $N$. We can see that the **discrete event simulation** can greatly reduce the computational complexity to $O(NME) \\ll O(N^2M)$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3601adf",
   "metadata": {},
   "source": [
    "### Case Study on Car Manufacturing\n",
    "\n",
    "Below is a case study of the heuristic search based on dispatching rule on the car manufacturing example. To this end we need to prepare the supporting Python classes and utility methods. These include\n",
    "\n",
    "- The classes for the job shop environment: `Operation`, `Job` and `JobShop`.\n",
    "- The classes for the state space search: `State` and `Process` action.\n",
    "- The utility methods: finding applicable actions of a state, makespan calculation, and schedule display.\n",
    "\n",
    "\n",
    "First, we define the Python classes for `Operation`, `Job` and `JobShop` as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0e7a65ec",
   "metadata": {
    "id": "0e7a65ec"
   },
   "outputs": [],
   "source": [
    "class Operation:\n",
    "    '''\n",
    "    Construct an operation, including the following properties.\n",
    "    - name of the operation\n",
    "    - machine\n",
    "    - duration (processing time)\n",
    "    - prec (preceding operation)\n",
    "    - succ (succeeding operation)\n",
    "    '''\n",
    "    def __init__(self, name, machine, duration, prec, succ):\n",
    "        self.name = name\n",
    "        self.machine = machine\n",
    "        self.duration = duration\n",
    "        self.prec = prec\n",
    "        self.succ = succ\n",
    "        \n",
    "class Job:\n",
    "    '''\n",
    "    Construct a job, including the following properties.\n",
    "    - job name\n",
    "    - list of operations\n",
    "    - arrival time, default to be 0\n",
    "    - due date, default to be infinity\n",
    "    - weight, default to be 1\n",
    "    '''\n",
    "    def __init__(self, name, operations):\n",
    "        self.name = name\n",
    "        self.operations = operations\n",
    "        self.arrival_time = 0\n",
    "        self.due_date = float('inf')\n",
    "        self.weight = 1\n",
    "        \n",
    "class JobShop:\n",
    "    '''\n",
    "    Construct a job shop environment, including a list of machines and a list of jobs.\n",
    "    '''\n",
    "    def __init__(self, machines, jobs):        \n",
    "        self.machines = machines\n",
    "        self.jobs = jobs\n",
    "        \n",
    "        # We also create a hash map to quickly access operations if needed\n",
    "        self.operations = {}\n",
    "        for job in jobs:\n",
    "            for op in job.operations:\n",
    "                self.operations[op.name] = op"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "631786df",
   "metadata": {},
   "source": [
    "Then, we define the Python classes for the `State` and `Process` action for state space search as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "49dd6017",
   "metadata": {},
   "outputs": [],
   "source": [
    "class State:\n",
    "    '''\n",
    "    Initialise the state with the job shop, i.e., a list of machines and a list of operations.\n",
    "    '''\n",
    "    def __init__(self, job_shop):\n",
    "        # 1. Initially, the idle time of all the machines are 0.\n",
    "        self.machine_idle_time = {}\n",
    "        for machine in job_shop.machines:\n",
    "            self.machine_idle_time[machine] = 0 \n",
    "        \n",
    "        # 2. Initially, all the operations except the first operations of the jobs are not ready.\n",
    "        # Their ready time are undefined, so not added into the operation_ready_time.\n",
    "        self.operation_ready_time = {}\n",
    "        for job in job_shop.jobs:\n",
    "            self.operation_ready_time[job.operations[0].name] = job.arrival_time\n",
    "        \n",
    "        # 3. Initial schedule is empty\n",
    "        self.schedule = []\n",
    "        \n",
    "        # 4. Initially, no operation is completed, and the list is empty.\n",
    "        self.completed = []\n",
    "\n",
    "import copy\n",
    "\n",
    "class Process:\n",
    "    '''\n",
    "    Construct a process with an operation, a machine and a time\n",
    "    '''\n",
    "    def __init__(self, operation, machine, time):\n",
    "        self.operation = operation\n",
    "        self.machine = machine\n",
    "        self.time = time\n",
    "    \n",
    "    '''\n",
    "    Check its precondition to see if it is applicable in a state.\n",
    "    '''\n",
    "    def is_applicable(self, state):\n",
    "        # Check if the operation is completed or not.\n",
    "        if self.operation.name in state.completed:\n",
    "            return False\n",
    "        \n",
    "        # Check if the operation is ready now or not.\n",
    "        if state.operation_ready_time[self.operation.name] > self.time:\n",
    "            return False\n",
    "        \n",
    "        # Check if the machine is idle now or not.\n",
    "        if state.machine_idle_time[self.machine] > self.time:\n",
    "            return False\n",
    "\n",
    "        return True\n",
    "    \n",
    "    '''\n",
    "    Apply the processing action to a state, and return the resultant state.\n",
    "    '''\n",
    "    def apply(self, state):\n",
    "        new_state = copy.deepcopy(state)\n",
    "        \n",
    "        # Add this process action to the schedule\n",
    "        new_state.schedule.append(self)\n",
    "        \n",
    "        # The operation becomes completed\n",
    "        new_state.completed.append(self.operation.name)\n",
    "        \n",
    "        # Delete the operation from operation_ready_time, since it is completed\n",
    "        new_state.operation_ready_time.pop(self.operation.name)\n",
    "        \n",
    "        completion_time = self.time + self.operation.duration\n",
    "        \n",
    "        # The machine becomes busy, and will be idle again after the operation is completed\n",
    "        new_state.machine_idle_time[self.machine] = completion_time\n",
    "        \n",
    "        # If the operation is not the last operation of the job, then its next operation becomes ready\n",
    "        if self.operation.succ != None:\n",
    "            new_state.operation_ready_time[self.operation.succ.name] = completion_time\n",
    "        \n",
    "        return new_state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77e437c3",
   "metadata": {},
   "source": [
    "Below we define the following utility methods.\n",
    "\n",
    "- `applicable_actions()`: find the applicable actions for a `state` in a `job_shop` environment.\n",
    "- `makespan()`: calculate the makespan of a `schedule`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a2b29373",
   "metadata": {},
   "outputs": [],
   "source": [
    "def applicable_actions(state, job_shop):\n",
    "    actions = []\n",
    "    \n",
    "    # Enumerate all the operations in the operation_ready_time map.\n",
    "    # For efficiency, this map ignores the operations whose ready time are still infinity \n",
    "    # (they are not applicable anyway).\n",
    "    for opname in state.operation_ready_time.keys():\n",
    "        op = job_shop.operations[opname]\n",
    "        \n",
    "        time = state.operation_ready_time[opname]\n",
    "        \n",
    "        if time < state.machine_idle_time[op.machine]:\n",
    "            time = state.machine_idle_time[op.machine]\n",
    "            \n",
    "        action = Process(op, op.machine, time)\n",
    "        \n",
    "        if action.is_applicable(state):\n",
    "            actions.append(action)\n",
    "    \n",
    "    return actions\n",
    "\n",
    "def makespan(schedule):\n",
    "    makespan = 0\n",
    "    \n",
    "    for action in schedule:\n",
    "        completion_time = action.time + action.operation.duration\n",
    "        \n",
    "        if completion_time > makespan:\n",
    "            makespan = completion_time\n",
    "    \n",
    "    return makespan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85922f1c",
   "metadata": {},
   "source": [
    "Then, we install the `matplotlib` library and define methods for visualising a schedule by gantt chart as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "81ab34df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib in /Users/yimei/miniforge3/lib/python3.9/site-packages (3.5.1)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n",
      "Requirement already satisfied: pillow>=6.2.0 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (9.0.1)\n",
      "Requirement already satisfied: fonttools>=4.22.0 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (4.29.1)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (1.3.2)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (3.0.6)\n",
      "Requirement already satisfied: packaging>=20.0 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (21.3)\n",
      "Requirement already satisfied: cycler>=0.10 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n",
      "Requirement already satisfied: numpy>=1.17 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from matplotlib) (1.21.2)\n",
      "Requirement already satisfied: six>=1.5 in /Users/yimei/miniforge3/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ef47f48f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "\n",
    "# Convert a schedule to a Pandas data frame\n",
    "def schedule_data_frame(schedule):\n",
    "    # Convert each action to dictionary\n",
    "    schedule_dict = []\n",
    "    for action in schedule:\n",
    "        a_dict = {\n",
    "            'Operation': action.operation.name,\n",
    "            'Machine': action.machine,\n",
    "            'Start': action.time,\n",
    "            'Duration': action.operation.duration,\n",
    "            'Finish': action.time + action.operation.duration\n",
    "        }\n",
    "        schedule_dict.append(a_dict)\n",
    "    \n",
    "    return pd.DataFrame(schedule_dict)\n",
    "\n",
    "# Visualise a schedule by gantt chart\n",
    "def visualise(schedule):\n",
    "    schedule = schedule_data_frame(schedule)\n",
    "    \n",
    "    JOBS = sorted(list(schedule['Operation'].unique()))\n",
    "    MACHINES = sorted(list(schedule['Machine'].unique()))\n",
    "    makespan = schedule['Finish'].max()\n",
    "    \n",
    "    bar_style = {'alpha':1.0, 'lw':25, 'solid_capstyle':'butt'}\n",
    "    text_style = {'color':'white', 'weight':'bold', 'ha':'center', 'va':'center'}\n",
    "    colors = mpl.cm.Dark2.colors\n",
    "\n",
    "    schedule.sort_values(by=['Operation', 'Start'])\n",
    "    schedule.set_index(['Operation', 'Machine'], inplace=True)\n",
    "\n",
    "    fig, ax = plt.subplots(2,1, figsize=(12, 5+(len(JOBS)+len(MACHINES))/4))\n",
    "\n",
    "    for jdx, j in enumerate(JOBS, 1):\n",
    "        for mdx, m in enumerate(MACHINES, 1):\n",
    "            if (j,m) in schedule.index:\n",
    "                xs = schedule.loc[(j,m), 'Start']\n",
    "                xf = schedule.loc[(j,m), 'Finish']\n",
    "                ax[0].plot([xs, xf], [jdx]*2, c=colors[mdx%7], **bar_style)\n",
    "                ax[0].text((xs + xf)/2, jdx, m, **text_style)\n",
    "                ax[1].plot([xs, xf], [mdx]*2, c=colors[jdx%7], **bar_style)\n",
    "                ax[1].text((xs + xf)/2, mdx, j, **text_style)\n",
    "                \n",
    "    ax[0].set_title('Job Schedule')\n",
    "    ax[0].set_ylabel('Operation')\n",
    "    ax[1].set_title('Machine Schedule')\n",
    "    ax[1].set_ylabel('Machine')\n",
    "    \n",
    "    for idx, s in enumerate([JOBS, MACHINES]):\n",
    "        ax[idx].set_ylim(0.5, len(s) + 0.5)\n",
    "        ax[idx].set_yticks(range(1, 1 + len(s)))\n",
    "        ax[idx].set_yticklabels(s)\n",
    "        ax[idx].text(makespan, ax[idx].get_ylim()[0]-0.2, \"{0:0.1f}\".format(makespan), ha='center', va='top')\n",
    "        ax[idx].plot([makespan]*2, ax[idx].get_ylim(), 'r--')\n",
    "        ax[idx].set_xlabel('Time')\n",
    "        ax[idx].grid(True)\n",
    "        \n",
    "    fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "184a34ca",
   "metadata": {},
   "source": [
    "After defining all the above supporting classes and utility methods, we define the core `heuristic_search_dispatching_rule()` method as follows. It takes the `priority` function as an argument, which varies depending on the dispatching rule used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5f547c5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def heuristic_search_dispatching_rule(job_shop, priority):\n",
    "    # Initialise the state and fringe\n",
    "    init_state = State(job_shop)\n",
    "    fringe = [init_state]\n",
    "    \n",
    "    while len(fringe) > 0:\n",
    "        state = fringe[0] # select the first and only state in the fringe\n",
    "        \n",
    "        if len(state.completed) == len(job_shop.operations):\n",
    "            return state.schedule\n",
    "        \n",
    "        actions = applicable_actions(state, job_shop)\n",
    "        \n",
    "        best_action = None\n",
    "        earliest_time = float('inf')\n",
    "        best_priority = -float('inf')\n",
    "        for a in actions:\n",
    "            if a.time < earliest_time:\n",
    "                best_action = a\n",
    "                earliest_time = a.time\n",
    "                best_priority = priority(a, state)\n",
    "            elif a.time == earliest_time:\n",
    "                p = priority(a, state)\n",
    "                if p > best_priority:\n",
    "                    best_action = a\n",
    "                    best_priority = p\n",
    "        \n",
    "        next_state = best_action.apply(state)\n",
    "        fringe.append(next_state)\n",
    "        \n",
    "        fringe.remove(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4991bb88",
   "metadata": {},
   "source": [
    "Now, we create a car manufacturing example as follows. It contains three jobs, each with three operations [`add_engine`, `add_wheels`, `inspect`]. The first two jobs is arrived at the beginning (time 0), while the third job arrives at time 10.\n",
    "\n",
    "| Job | Arrival | Operation | Machine | Duration |\n",
    "| --- | --------- | ------- | --------- | --------- |\n",
    "| 1   | 0 | `add_engine_1` | `engine_hoist` | 30 |\n",
    "|     |   | `add_wheels_1` | `wheel_station` | 30 |\n",
    "|     |   | `inspect_1` |    `inspector` | 10 |\n",
    "| 2   | 0 | `add_engine_2` | `engine_hoist` | 60 |\n",
    "|     |   | `add_wheels_2` | `wheel_station` | 15 |\n",
    "|     |   | `inspect_2` |    `inspector` | 10 |\n",
    "| 3   | 10| `add_engine_3` | `engine_hoist` | 20 |\n",
    "|     |   | `add_wheels_3` | `wheel_station` | 30 |\n",
    "|     |   | `inspect_3` |    `inspector` | 10 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f586bcba",
   "metadata": {},
   "outputs": [],
   "source": [
    "machines = ['engine_hoist', 'wheel_station', 'inspector']\n",
    "\n",
    "add_engine_1 = Operation('add_engine_1', 'engine_hoist', 30, None, None)\n",
    "add_wheels_1 = Operation('add_wheels_1', 'wheel_station', 30, add_engine_1, None)\n",
    "inspect_1 = Operation('inspect_1', 'inspector', 10, add_wheels_1, None)\n",
    "add_engine_2 = Operation('add_engine_2', 'engine_hoist', 60, None, None)\n",
    "add_wheels_2 = Operation('add_wheels_2', 'wheel_station', 15, add_engine_2, None)\n",
    "inspect_2 = Operation('inspect_2', 'inspector', 10, add_wheels_2, None)\n",
    "add_engine_3 = Operation('add_engine_3', 'engine_hoist', 20, None, None)\n",
    "add_wheels_3 = Operation('add_wheels_3', 'wheel_station', 30, add_engine_3, None)\n",
    "inspect_3 = Operation('inspect_3', 'inspector', 10, add_wheels_3, None)\n",
    "\n",
    "add_engine_1.succ = add_wheels_1\n",
    "add_wheels_1.succ = inspect_1\n",
    "add_engine_2.succ = add_wheels_2\n",
    "add_wheels_2.succ = inspect_2\n",
    "add_engine_3.succ = add_wheels_3\n",
    "add_wheels_3.succ = inspect_3\n",
    "\n",
    "job_1 = Job('job_1', [add_engine_1, add_wheels_1, inspect_1])\n",
    "job_2 = Job('job_2', [add_engine_2, add_wheels_2, inspect_2])\n",
    "job_3 = Job('job_3', [add_engine_3, add_wheels_3, inspect_3])\n",
    "job_3.arrival_time = 10\n",
    "\n",
    "job_shop = JobShop(machines, [job_1, job_2, job_3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5031cc97",
   "metadata": {},
   "source": [
    "Below we show the gantt chart of the schedule obtained by the heuristic search with the **Shortest Processing Time** rule, whose priority function is `- action.operation.duration`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6f6ce4ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "spt_rule = lambda action, state: -action.operation.duration\n",
    "\n",
    "spt_schedule = heuristic_search_dispatching_rule(job_shop, spt_rule)\n",
    "visualise(spt_schedule)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07990805",
   "metadata": {},
   "source": [
    "Below we show the gantt chart of the schedule obtained by the heuristic search with the **First Come First Serve** rule, whose priority function is `- operation ready time`. We can see the schedule is different from (worse than) the schedule obtained by the Shortest Processing Time rule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "45c1a27e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fcfs_rule = lambda action, state: -state.operation_ready_time[action.operation.name]\n",
    "\n",
    "fcfs_schedule = heuristic_search_dispatching_rule(job_shop, fcfs_rule)\n",
    "visualise(fcfs_schedule)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7bbdd4",
   "metadata": {},
   "source": [
    "In comparison, we can see that the Shortest Processing Time rule processes `job_3` before `job_2`, since its first operation `add_engine_3` is shorter than `add_engine_2` when the `engine_hoist` machine becomes ready at time 30. However, the First Come First Serve rule processes `add_engine_2` before `add_engine_3` at time 30, since `job_2` arrives earlier than `job_3`. The long `add_engine_2` causes delay of the subsequent operations, and ultimately leads to larger makespan of the schedule.\n",
    "\n",
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399d4d66",
   "metadata": {},
   "source": [
    "## 3. Local Search <a name='ls'></a> \n",
    "\n",
    "Most states in the state space are not goal states, i.e., they correspond to incomplete schedules. Local search can search among the **goal states only**, which leads to a much smaller search space than the state space.\n",
    "\n",
    "### Solution/Schedule Representation\n",
    "\n",
    "A complete schedule can be represented as a list of process actions `Process[operation, machine, time]` for each operation. In other words, it specifies the start time to process each operation subject to the *resource constraint* (each machine can process at most one operation at a time) and *precedence constraint* (an operation cannot start processing until its precedent operation is completed).\n",
    "\n",
    "### Initial Solution/Schedule\n",
    "\n",
    "We can randomly generate an initial schedule. We can follow the state space search framework, start from the initial state, and randomly select an action at each state until we reach a goal state.\n",
    "\n",
    "Alternatively, we can also use a dispatching rule (e.g., First Come First Serve, Shortest Processing Time) to generate an initial schedule.\n",
    "\n",
    "### Neighbourhood\n",
    "\n",
    "The neighbourhood of a solution/schedule is defined by a **move operator** $\\mathtt{op}$, such as swapping the order of two process actions on the same machine. Given a move operator $\\mathtt{op}$, the corresponding neighbourhood of a solution is the set of all the possible solutions that can be generated by applying the operator to the current solution, i.e.,\n",
    "\n",
    "$$\n",
    "\\mathcal{N}^{(\\mathtt{op})}(S) = \\{S' | S' = \\mathtt{op}(S)\\}.\n",
    "$$\n",
    "\n",
    "For example, given the following solution for car manufacturing:\n",
    "\n",
    "| Machine |  Process Operation Order  |\n",
    "| ------- | --------------  |\n",
    "| `engine_hoist` | `add_engine_1` $\\rightarrow$ `add_engine_2` $\\rightarrow$ `add_engine_3` |\n",
    "| `wheel_stateion` | `add_wheels_1` $\\rightarrow$ `add_wheels_2` $\\rightarrow$ `add_wheels_3` |\n",
    "| `inspector` | `inspect_1` $\\rightarrow$ `inspect_2` $\\rightarrow$ `inspect_3` |\n",
    "\n",
    "There are 3 possible swaps for each machine. For example, for `engine_hoist`, we have the following three swaps:\n",
    "\n",
    "- (`add_engine_1`, `add_engine_2`), \n",
    "- (`add_engine_1`, `add_engine_3`), \n",
    "- (`add_engine_2`, `add_engine_3`). \n",
    "\n",
    "Therefore, there are $3 \\times 3 \\times 3 = 27$ possible neighbours in the neighbourhood by the swap operator. \n",
    "\n",
    "Note that for each neighouring solution, we need to **re-calculate the starting time** of the process actions. To this end, we modify the state space search to generate a schedule guided by the order of the solution, i.e., the order of operations by each machine. Specifically, we add an **additional precedence constraint** specified by the order of operations in the solution.\n",
    "\n",
    "Below is the modified state space search to generate the schedule guided by the solution. Initially, the first operation in each machine sequence of the solution is ready. During the search, after getting the applicable actions, it further checks which applicable actions are processing the ready operation specified by the solution. Then, after processing each operation, the next operation in its machine sequence of the solution becomes ready."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2d43c927",
   "metadata": {},
   "outputs": [],
   "source": [
    "def schedule_from_solution(job_shop, solution):\n",
    "    # Initialise the state and fringe\n",
    "    init_state = State(job_shop)\n",
    "    fringe = [init_state]\n",
    "\n",
    "    # The current ready operations from the solution, initially the first operations are ready\n",
    "    solution_ready_op_idx = {}\n",
    "    for machine in solution.op_sequences.keys():\n",
    "        solution_ready_op_idx[machine] = 0\n",
    "    \n",
    "    while len(fringe) > 0:\n",
    "        state = fringe[0] # select the first and only state in the fringe\n",
    "        \n",
    "        if len(state.completed) == len(job_shop.operations):\n",
    "            return state.schedule\n",
    "        \n",
    "        actions = applicable_actions(state, job_shop)\n",
    "        \n",
    "        # Check if each action is processing the ready operation specified by the solution\n",
    "        ready_actions = []\n",
    "        for a in actions:\n",
    "            solution_op = solution.op_sequences[a.machine][solution_ready_op_idx[a.machine]]\n",
    "            if a.operation.name == solution_op.name:\n",
    "                ready_actions.append(a)\n",
    "        \n",
    "        # Apply the next actions for each machine simultaneously\n",
    "        next_state = state\n",
    "        for a in ready_actions:\n",
    "            # The next operation in the machine sequence becomes ready\n",
    "            solution_ready_op_idx[a.machine] = solution_ready_op_idx[a.machine] + 1\n",
    "            next_state = a.apply(next_state)\n",
    "        \n",
    "        fringe.append(next_state)\n",
    "        fringe.remove(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2220bf53",
   "metadata": {},
   "source": [
    "We define the Python class for `solution` as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e37233aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class Solution:\n",
    "    '''\n",
    "    Initialise a solution from a job shop.\n",
    "    It simply places the operations to its corresponding machine sequences.\n",
    "    '''\n",
    "    def __init__(self, job_shop):\n",
    "        self.op_sequences = {}\n",
    "        for machine in job_shop.machines:\n",
    "            self.op_sequences[machine] = []\n",
    "        \n",
    "        for job in job_shop.jobs:\n",
    "            for op in job.operations:\n",
    "                self.op_sequences[op.machine].append(op)\n",
    "    \n",
    "    '''\n",
    "    Randomly shuffle the machine sequences with a random seed. This is for randomly generating a solution.\n",
    "    '''\n",
    "    def shuffle(self, seed):\n",
    "        # Randomly shuffle the sequence of each machine\n",
    "        random.seed(seed)\n",
    "        for machine in job_shop.machines:\n",
    "            random.shuffle(self.op_sequences[machine])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9630de1a",
   "metadata": {},
   "source": [
    "Then, we can design the local search (hill climbing) method based on swapping two operations on the same machine. The Python code of the local search is given as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d7a22fb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def local_search(solution, job_shop):\n",
    "    # Get the schedule and makespan of the initial solution\n",
    "    schedule = schedule_from_solution(job_shop, solution)\n",
    "    mk = makespan(schedule)\n",
    "    \n",
    "    improved = True\n",
    "    while(improved):\n",
    "        improved = False\n",
    "        \n",
    "        # Enumerate the neighbours and find the best neighbour\n",
    "        best_neighbour = None\n",
    "        best_nb_schedule = None\n",
    "        best_nb_mk = float('inf')\n",
    "        \n",
    "        for machine in job_shop.machines:\n",
    "            machine_seq = solution.op_sequences[machine]\n",
    "            \n",
    "            for i in range(len(machine_seq)-1):\n",
    "                for j in range(i+1, len(machine_seq)):\n",
    "                    neighbour = copy.deepcopy(solution)\n",
    "                    neighbour.op_sequences[machine][i] = machine_seq[j]\n",
    "                    neighbour.op_sequences[machine][j] = machine_seq[i]\n",
    "                    \n",
    "                    nb_schedule = schedule_from_solution(job_shop, neighbour)\n",
    "                    nb_mk = makespan(nb_schedule)\n",
    "                    \n",
    "                    if nb_mk < best_nb_mk:\n",
    "                        best_neighbour = neighbour\n",
    "                        best_nb_schedule = nb_schedule\n",
    "                        best_nb_mk = nb_mk\n",
    "        \n",
    "        # Check if the best neighbour is better than the current solution\n",
    "        if best_nb_mk < mk:\n",
    "            improved = True\n",
    "            solution = best_neighbour\n",
    "            schedule = best_nb_schedule\n",
    "            mk = best_nb_mk   \n",
    "    \n",
    "    return schedule"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851b1cbf",
   "metadata": {},
   "source": [
    "### Computational Complexity\n",
    "\n",
    "Assume that there are $N$ jobs and $M$ machines. Each job has $M$ operations, each to be processed by a different machine. There are $NM$ operations in total.\n",
    "\n",
    "At each step of the local search, we need to explore $O(MN^2)$ neighbours generated by the swap operator. For each neighbour, we need to use the `schedule_from_solution()` to get the schedule (start time of each operation) and calculate its makespan.\n",
    "\n",
    "The analysis of the `schedule_from_solution()` method is similar to that of the state space search. There are at most $NM$ steps, and in each step there are at most $N$ applicable actions. Therefore, the computational complexity is $O(MN^2)$.\n",
    "\n",
    "Overall, the computational complexity of the local search is \n",
    "\n",
    "$$\n",
    "O(T \\cdot MN^2 \\cdot MN^2) = O(T M^2 N^4),\n",
    "$$\n",
    "\n",
    "where $T$ is the number of steps for the local search to reach a local optimum.\n",
    "\n",
    "Obviously, local search is much slower than the dispatching rule approach, and its complexity grows much faster with the problem size. However, *if the problem information is exactly known in advance*, it can usually obtain better solutions than dispatching rules since it explores the solution space more comprehensively."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c95bd1f",
   "metadata": {},
   "source": [
    "### A Case Study for Car Manufacturing\n",
    "\n",
    "To show how the local search works, we first randomly generate a solution and visualise it. We can see that its makespan is very large, i.e., 215."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1a344571",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "solution = Solution(job_shop)\n",
    "solution.shuffle(3)\n",
    "\n",
    "schedule = schedule_from_solution(job_shop, solution)\n",
    "visualise(schedule)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf0eb6a",
   "metadata": {},
   "source": [
    "Then, we run the local search (swapping the operations on the same machine) and obtain a much better schedule with a makespan of 135.\n",
    "\n",
    "By comparing the two schedules, we can see that the following swaps have been done:\n",
    "\n",
    "- On `engine_hoist`, swap `add_engine_2` and `add_engine_1`.\n",
    "- On `inspector`, swap `inspect_2` and `inspect_3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3876fa59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ls_schedule = local_search(solution, job_shop)\n",
    "visualise(ls_schedule)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5a4246e",
   "metadata": {},
   "source": [
    "> Local search is easily stuck into local optima, thus its performance is very sensitive to the initial solution. To address this issue, we can use more advanced search techniques, such as simulated annealing, tabu search, genetic algorithms, to jump out of local optima and reach better solutions.\n",
    "\n",
    "------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dec4cbf5",
   "metadata": {},
   "source": [
    "The original Juypter Notebook can be downloaded [here](https://homepages.ecs.vuw.ac.nz/~yimei/tutorials/job-shop-scheduling-heuristics.ipynb).\n",
    "\n",
    "More tutorials can be found [here](https://meiyi1986.github.io/tutorials/).\n",
    "\n",
    "[Yi Mei's homepage](https://meiyi1986.github.io/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d934375c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "job-shop-scheduling-solution-optimisation.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}