environment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing Jupyter notebook from config.ipynb\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import copy\n",
    "\n",
    "from IPython.core.debugger import set_trace\n",
    "\n",
    "import import_ipynb\n",
    "from config import *\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Environment(object):\n",
    "    \"\"\"\n",
    "        Implementation of the Jop Shop Problem\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, config):\n",
    "        \n",
    "        self.config = config\n",
    "\n",
    "        #Initialize environment variables\n",
    "        self.clear()\n",
    "        \n",
    "    def _place(self, job, task, machine):       \n",
    "        \n",
    "        # Task startTime\n",
    "        if task == 0:\n",
    "            self.taskTimes[job][task][0] = self.machineReadyTime[machine]\n",
    "        \n",
    "        else:\n",
    "            self.taskTimes[job][task][0] = max(self.machineReadyTime[machine], self.taskTimes[job][task-1][1])\n",
    "            \n",
    "        # Task endTime\n",
    "        self.taskTimes[job][task][1] = self.taskTimes[job][task][0] + self.duration[job][task]\n",
    "        \n",
    "        # Update machine next ready time\n",
    "        self.machineReadyTime[machine] = self.taskTimes[job][task][1]\n",
    "        \n",
    "        \n",
    "    def step(self, machines, duration, placements):\n",
    "\n",
    "        assert len(machines) == len(duration) == self.config.num_jobs\n",
    "        assert len(placements) == self.config.num_machines\n",
    "        \n",
    "        self.machines = machines\n",
    "        self.duration = duration\n",
    "        self.placements = placements\n",
    "        \n",
    "            \n",
    "        # Internal variables\n",
    "        self.taskTimes = [[[0, 0] for _ in range(self.config.num_tasksperjob)] for _ in range(self.config.num_jobs)]  #[start, end]\n",
    "        self.machineReadyTime = [0 for _ in range(self.config.num_machines)]\n",
    "        \n",
    "        self.placementsTime = copy.deepcopy(self.placements)\n",
    "        self.placementsTimePlot = copy.deepcopy(self.placements)\n",
    "        self.placementsColorPlot = copy.deepcopy(self.placements)\n",
    "        \n",
    "        \n",
    "        # Tasks still to be placed\n",
    "        todo = copy.deepcopy(placements)\n",
    "        \n",
    "        # Mask indicating tasks that can be placed (previous task in job already placed)\n",
    "        mask = np.zeros([self.config.num_jobs, self.config.num_tasksperjob], dtype=bool)\n",
    "        mask[:,0] = True\n",
    "        \n",
    "\n",
    "        # While...\n",
    "        placing = True\n",
    "        while(placing):\n",
    "            \n",
    "            for m, job_task in enumerate(todo):          \n",
    "                try:\n",
    "                    job = job_task[0][0]\n",
    "                    task = job_task[0][1]\n",
    "                \n",
    "                    if mask[job, task]:\n",
    "                        \n",
    "                        # Place task in machine\n",
    "                        self._place(job, task, m)\n",
    "                                                \n",
    "                        # Update mask\n",
    "                        if task < self.config.num_tasksperjob-1:\n",
    "                            mask[job, task+1] = True\n",
    "                            \n",
    "                        # Remove task\n",
    "                        job_task.pop(0)\n",
    "                        \n",
    "                except:\n",
    "                    pass\n",
    "\n",
    "            if all(v == [] for v in todo):\n",
    "                placing = False\n",
    "\n",
    "        # Output\n",
    "        self.makespan = max(self.machineReadyTime)\n",
    "        \n",
    "        \n",
    "    def _compute_info(self):\n",
    "        \n",
    "        # Colormap\n",
    "        cmap = plt.cm.get_cmap('tab10')\n",
    "        colormap = [cmap(np.float32(i+1)/(self.config.num_jobs+1)) for i in range(self.config.num_jobs)]\n",
    "        \n",
    "        for machine, tasks in enumerate(self.placements):\n",
    "            for i, jobtask in enumerate(tasks):\n",
    "\n",
    "                job = jobtask[0]\n",
    "                task = jobtask[1]\n",
    "                \n",
    "                # Time (start, end)\n",
    "                self.placementsTime[machine][i] = self.taskTimes[job][task]\n",
    "                \n",
    "                # Time_plot (start, duration)\n",
    "                self.placementsTimePlot[machine][i][:] = self.taskTimes[job][task]\n",
    "                self.placementsTimePlot[machine][i][1] = self.placementsTimePlot[machine][i][1] - self.placementsTimePlot[machine][i][0]\n",
    "                \n",
    "                # Color_plot\n",
    "                self.placementsColorPlot[machine][i] = colormap[jobtask[0]]\n",
    "                \n",
    "                \n",
    "    def plot(self, save=False, name=\"figure.pdf\"):\n",
    "        \n",
    "        # Compute additional variables\n",
    "        self._compute_info()\n",
    "        \n",
    "        # Matplotlib\n",
    "        mpl.style.use('seaborn')\n",
    "        fig, ax = plt.subplots(figsize=(8, 6), dpi= 80, facecolor=\"white\", edgecolor=\"white\")\n",
    "        ax.set_facecolor(\"#E4ECF5\")\n",
    "\n",
    "        for i in range(self.config.num_machines):\n",
    "            ax.broken_barh(self.placementsTimePlot[i], (10*(self.config.num_machines-i), 4), facecolors=self.placementsColorPlot[i], edgecolor=\"#E4ECF5\")\n",
    "\n",
    "        ax.set_ylim(8, 10*(self.config.num_machines+1))\n",
    "        ax.set_xlim(-2, 10+max(self.machineReadyTime))\n",
    "        ax.set_xlabel('time')\n",
    "\n",
    "        ax.set_yticks(list(range(15, 15+self.config.num_machines*10, 10)))\n",
    "        ax.set_yticklabels(['Machine'+ str(i) for i in reversed(range(self.config.num_machines))])\n",
    "        \n",
    "        ax.grid(True)\n",
    "        #ax.xaxis.grid(True, which=\"minor\", color=\"white\", linewidth=20)\n",
    "        ax.xaxis.grid(True)\n",
    "        ax.yaxis.grid(False)\n",
    "        ax.set_axisbelow(True)\n",
    "        fig.tight_layout()\n",
    "        plt.show()\n",
    "        \n",
    "        if save:\n",
    "            fig.savefig(name)\n",
    "        \n",
    "    def clear(self):\n",
    "\n",
    "        # Clear placement\n",
    "        self.machines = None\n",
    "        self.duration = None\n",
    "        self.placements = None\n",
    "        \n",
    "        # Internal variables\n",
    "        self.taskTimes = None\n",
    "        self.machineReadyTime = None\n",
    "        \n",
    "        self.placementsTime = None\n",
    "        self.placementsTimePlot = None\n",
    "        self.placementsColorPlot = None\n",
    "        \n",
    "        # Output\n",
    "        self.makespan = None\n",
    "        self.constraint_idleTime = 0\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Makespan:  139\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "if __name__ == \"__main__\":\n",
    "    \n",
    "    \n",
    "    # Import environment\n",
    "    config = Config()\n",
    "    config.machine_profile = \"medium_default\"\n",
    "    config.job_profile = \"medium_default\"\n",
    "    config.reconfigure()\n",
    "    \n",
    "    # Configure environment\n",
    "    env = Environment(config)\n",
    "    env.clear()\n",
    "    \n",
    "    \n",
    "    # Read problem instance\n",
    "    filename = \"datasets/inference/dataset_medium.data\"\n",
    "\n",
    "    with open(filename, \"r\") as file:\n",
    "        NB_JOBS, NB_MACHINES = [int(v) for v in file.readline().split()]\n",
    "        JOBS = [[int(v) for v in file.readline().split()] for i in range(NB_JOBS)]\n",
    "\n",
    "    #-----------------------------------------------------------------------------\n",
    "    # Prepare the data for modeling\n",
    "    #-----------------------------------------------------------------------------\n",
    "\n",
    "    # Build list of machines. MACHINES[j][s] = id of the machine for the operation s of the job j\n",
    "    MACHINES = [[JOBS[j][2 * s] for s in range(NB_MACHINES)] for j in range(NB_JOBS)]\n",
    "\n",
    "    # Build list of durations. DURATION[j][s] = duration of the operation s of the job j\n",
    "    DURATION = [[JOBS[j][2 * s + 1] for s in range(NB_MACHINES)] for j in range(NB_JOBS)]\n",
    "\n",
    "    \n",
    "    # Create a basic heuristic\n",
    "    #placements = [[] for m in range(NB_MACHINES)]\n",
    "    \n",
    "    #for t in range(0, NB_MACHINES):\n",
    "    #    for j in range(NB_JOBS):\n",
    "    #        placements[MACHINES[j][t]].append([j,t])\n",
    "           \n",
    "\n",
    "    # Allocate service in the environment\n",
    "    env.step(MACHINES, DURATION, placements_medium_nn)\n",
    "    \n",
    "    print(\"Makespan: \", env.makespan)\n",
    "    \n",
    "    \n",
    "    env.plot(save=False, name=\"images/medium_nn.pdf\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (ICML2020)",
   "language": "python",
   "name": "icml2020"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}