Maintenance_Planning_Environment_b.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPFj9J7Ga9pZ7X7jdHGMFtX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Ogunfool/Maintenance-Planning-with-reinforcement-learning/blob/main/Maintenance_Planning_Environment_b.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Survival Analysis"
      ],
      "metadata": {
        "id": "Lszxp-cMDSCB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "a0dcicTG9lwo"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install reliability\n",
        "! pip install lifelines"
      ],
      "metadata": {
        "id": "Lrv17JPR-I39"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from lifelines import KaplanMeierFitter,WeibullFitter\n",
        "from numpy.random import Generator as gen\n",
        "from numpy.random import PCG64 as pcg"
      ],
      "metadata": {
        "id": "dGehBRHbG07t"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Data Generation\n",
        "from reliability.Datasets import system_growth\n",
        "failure_times = system_growth().failures\n",
        "censorship = np.ones_like(failure_times)"
      ],
      "metadata": {
        "id": "hHcQL-87q7a6"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data = np.array([failure_times,censorship])\n",
        "data = data.transpose()\n",
        "data.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xd975UjmrwRg",
        "outputId": "55d4f32e-3845-4e61-d0df-bfb5667008cc"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(22, 2)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "failure_times_a = np.array(failure_times)\n",
        "failure_times_a.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sfBG4AN-Ecm9",
        "outputId": "17fedf6f-e380-4427-85c6-15da984ecedd"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(22,)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.mean(failure_times_a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R1la05vnU_so",
        "outputId": "67f63df4-4594-44f8-b3be-b3d71bb94030"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "220.33181818181814"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.std(failure_times_a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mLQ7CojUVKo1",
        "outputId": "1a5fcbf3-678e-4a55-9438-2f08258205a8"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "176.7256049420931"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate Data for 2 other machines\n",
        "array_rg = gen(pcg(365))\n",
        "failure_times_b = array_rg.normal((np.mean(failure_times_a)), (np.std(failure_times_a)), size = (failure_times_a.shape))\n",
        "failure_times_b = np.where(failure_times_b < 0, -failure_times_b, failure_times_b)\n",
        "sum(failure_times_b < 0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hhngbmp4ElKf",
        "outputId": "c55189c7-12dc-4816-ab77-620c34254999"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "failure_times_b.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RBgPpnZ9FR81",
        "outputId": "2ed30a4f-cb13-4242-94a9-365067dfb9cd"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(22,)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Data for machine 3\n",
        "array_rg = gen(pcg(365))\n",
        "failure_times_c = array_rg.normal((np.mean(failure_times_a)/2.17), 100, size = (failure_times_a.shape))\n",
        "failure_times_c = np.where(failure_times_c < 0, -failure_times_c, failure_times_c)\n",
        "sum(failure_times_c < 0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hBWENNwKFVM_",
        "outputId": "16eb285c-04a2-4e2d-a201-9b2d66d0a662"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "failure_times_c.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_XyrbaDoFHyL",
        "outputId": "1538361f-7f63-40de-e0c6-a74e66dc679c"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(22,)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Instantiate weibullfitter objects for all 3 machines\n",
        "failures_a_wb = WeibullFitter()\n",
        "failures_b_wb = WeibullFitter()\n",
        "failures_c_wb = WeibullFitter()"
      ],
      "metadata": {
        "id": "48XLKD5lGAlF"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit all\n",
        "failures_a_wb.fit(durations=failure_times_a, label='component_1')\n",
        "failures_b_wb.fit(durations=failure_times_b, label='component_2')\n",
        "failures_c_wb.fit(durations=failure_times_c, label='component_3')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q57_0OgJGfcz",
        "outputId": "00f745e2-7f83-4a8a-803c-9ef491e88522"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<lifelines.WeibullFitter:\"component_3\", fitted with 22 total observations, 0 right-censored observations>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "failures_a_wb.plot_survival_function(ci_show=False)\n",
        "failures_b_wb.plot_survival_function(ci_show=False)\n",
        "failures_c_wb.plot_survival_function(ci_show=False)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "4imN6YsRIAPB",
        "outputId": "7a8cd4c1-c56f-4570-f4b4-0a5fc2a34eb9"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "machine_failure_times = np.array([failures_a_wb,failures_b_wb,failures_c_wb])\n",
        "machine_failure_times"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C3OUJw0BG4e9",
        "outputId": "893c1bbb-a252-4d59-aa26-2e335fb2df7e"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([<lifelines.WeibullFitter:\"component_1\", fitted with 22 total observations, 0 right-censored observations>,\n",
              "       <lifelines.WeibullFitter:\"component_2\", fitted with 22 total observations, 0 right-censored observations>,\n",
              "       <lifelines.WeibullFitter:\"component_3\", fitted with 22 total observations, 0 right-censored observations>],\n",
              "      dtype=object)"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(failures_a_wb.median_survival_time_)\n",
        "print(failures_b_wb.median_survival_time_)\n",
        "print(failures_c_wb.median_survival_time_)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qUhpPl-NH-KD",
        "outputId": "91c84da6-b736-4ba7-d647-73052c6a7319"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "157.22900074291118\n",
            "178.33931322824708\n",
            "83.18437645779817\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "no_of_machine = 3\n",
        "no_of_state = 5\n",
        "# copied from iterative_policy_evaluation\n",
        "def get_transition_probs(machine_failure_times):\n",
        "  ### define transition probabilities and planner ###\n",
        "  # the key is (s, a, s'), the value is the probability\n",
        "  # that is, transition_probs[(s, a, s')] = p(s' | s, a)\n",
        "  # any key NOT present will considered to be impossible (i.e. probability 0)\n",
        "  transition_probs = {}\n",
        "\n",
        "  # to reduce the dimensionality of the dictionary, we'll use deterministic\n",
        "  # rewards, r(s, a, s')\n",
        "  # note: you could make it simpler by using r(s') since the reward doesn't\n",
        "  # actually depend on (s, a)\n",
        "\n",
        "# for m in range(1,(no_of_machine+1)):\n",
        "  for i in range(3):\n",
        "    for p in range(6):\n",
        "      transition_probs[(i,p,'NM')] = machine_failure_times[i].predict(p*100)\n",
        "          \n",
        "  return transition_probs"
      ],
      "metadata": {
        "id": "puUVovWQ9sxR"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "transition_probs = get_transition_probs(machine_failure_times)"
      ],
      "metadata": {
        "id": "nmVLYW5D9GCD"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "transition_probs"
      ],
      "metadata": {
        "id": "4lU4YM09nNPD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "dnaR6oNj8rtr"
      },
      "outputs": [],
      "source": [
        "# # AI-Based Maintenance Planner Environment\n",
        "# import numpy as np\n",
        "\n",
        "# # \"NM\" = No Maintenance, \"PM\" = Preventive Maintenance\n",
        "# ACTION_SPACE = ('NM', 'PM')\n",
        "\n",
        "# class Planner: # Environment for 3 machines\n",
        "#   def __init__(self, start=(0,0,0)):\n",
        "#     self.s = start\n",
        "\n",
        "#   def set(self, rewards, actions):\n",
        "#     # rewards should be a dict of: (\"action\"): r (\"NM\"): reward\n",
        "#     # actions should be a dict of: (int): A (1): list of actions for all 3 machines\n",
        "#     self.rewards = rewards\n",
        "#     self.actions = actions\n",
        "\n",
        "#   # Use to set next state to current state\n",
        "#   def set_state(self, s):\n",
        "#     self.s = tuple(s)\n",
        "\n",
        "#   def current_state(self):\n",
        "#     return (self.s)\n",
        "\n",
        "#   def is_terminal(self):  #Takes tuple of states for all machines, Returns a boolean tuple\n",
        "#     status = []\n",
        "#     for t in range(3):\n",
        "#       status.append(self.s[t] >= 5)\n",
        "      \n",
        "#     return(status)\n",
        "\n",
        "#   def is_terminal_single(self, s):  # Takes single machine state, Returns a boolean \n",
        "#     return s >= 5\n",
        "\n",
        "#   def reset(self):\n",
        "#     # put agent back in start position\n",
        "#     self.s = (0,0,0)\n",
        "#     return (self.s)\n",
        "\n",
        "#   def get_next_state(self,a):\n",
        "#     # This answers: where would I end up if I perform action 'a' in state 's'?\n",
        "#     s_next = [0,0,0]\n",
        "#     for m in range(3):\n",
        "#       # Check if state is terminal\n",
        "#       # When in terminal state, the next state is independent of the action taken\n",
        "#       if self.is_terminal_single(self.s[m]):\n",
        "#         s_next[m] = 0\n",
        "#         # Debugging tool\n",
        "#         print(\"episode end:\", m, self.s[m], s_next[m], a[m])\n",
        "#       else:\n",
        "#         print(\"Not terminal state:\", m, self.s[m], s_next[m], a[m])\n",
        "      \n",
        "#       if a[m] == \"NM\":\n",
        "#         if (self.is_terminal_single(self.s[m]) == 0):\n",
        "#           s_next[m] = np.random.choice([self.s[m] + 1, 0], p=[transition_probs[m,self.s[m],a[m]], 1-transition_probs[m,self.s[m],a[m]]])\n",
        "#           # Debugging \n",
        "#           print(\"Action is AM:\", m, self.s[m], s_next[m], a[m])\n",
        "\n",
        "#       if a[m] == \"PM\":\n",
        "#         s_next[m] = 0\n",
        "#         # Debugging\n",
        "#         print(\"action is PM:\", m, self.s[m], s_next[m], a[m])\n",
        "    \n",
        "#     # Set next state as new state\n",
        "#     self.set_state(s_next)\n",
        "#     return s_next\n",
        "\n",
        "#   def act(self, a):\n",
        "#     a_array = np.copy(a)\n",
        "#     reward = np.zeros((3,))\n",
        "#     # this answers: where would I end up if I perform action 'a' in state 's'?\n",
        "#     s_next = np.zeros((3,))\n",
        "#     for m in range(3):\n",
        "#       # Check if state is terminal\n",
        "#       if self.is_terminal_single(self.s[m]):\n",
        "#         s_next[m] = 0\n",
        "#         a_array[m] = \"CM\"\n",
        "\n",
        "#       if a[m] == \"NM\":\n",
        "#         if (self.is_terminal_single(self.s[m]) == 0):\n",
        "#           s_next[m] = np.random.choice([self.s[m] + 1, 0], p=[transition_probs[m,self.s[m],a[m]], 1-transition_probs[m,self.s[m],a[m]]])\n",
        "#           if s_next[m] == 0:\n",
        "#             a_array[m] = \"CM\"\n",
        "            \n",
        "\n",
        "#       if a[m] == \"PM\":\n",
        "#         s_next[m] = 0\n",
        "\n",
        "#       # Collect reward for action taken on each machine\n",
        "#       reward[m] = self.rewards[a_array[m]]\n",
        "\n",
        "#     # Set next state as new state\n",
        "#     self.set_state(s_next)\n",
        "#     return reward.sum()\n",
        "\n",
        "# def standard_planner():\n",
        "#   # define a planner that describes the reward for arriving at each state\n",
        "#   # and possible actions at each state\n",
        "#   # s means start position\n",
        "#   g = Planner()\n",
        "#   rewards = {(\"NM\"): 0, (\"PM\"): -100, (\"CM\"): -200}\n",
        "#   actions = {\n",
        "#     (0): ('NM', 'NM', 'NM'),\n",
        "#     (1): ('PM', 'PM', 'PM'),\n",
        "#     (2): ('NM', 'NM', 'PM'),\n",
        "#     (3): ('NM', 'PM', 'NM'),\n",
        "#     (4): ('PM', 'NM', 'NM'),\n",
        "#     (5): ('PM', 'PM', 'NM'),\n",
        "#     (6): ('PM', 'NM', 'PM'),\n",
        "#     (7): ('NM', 'PM', 'PM'),\n",
        "#   }\n",
        "#   g.set(rewards, actions)\n",
        "#   return g"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "bp2cw3lhNZe4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "rVc4j_hNNZ1Q"
      },
      "outputs": [],
      "source": [
        "# AI-Based Maintenance Planner Environment\n",
        "import numpy as np\n",
        "\n",
        "# \"NM\" = No Maintenance, \"PM\" = Preventive Maintenance\n",
        "ACTION_SPACE = ('NM', 'PM')\n",
        "\n",
        "class Planner: # Environment for m_no of machines\n",
        "  def __init__(self, no_of_machines, no_of_states):\n",
        "    self.no_of_machines = no_of_machines\n",
        "    self.no_of_states = no_of_states\n",
        "    self.s = tuple(np.zeros(no_of_machines))\n",
        "\n",
        "  def set(self, rewards, actions):\n",
        "    # rewards should be a dict of: (\"action\"): r (\"NM\"): reward\n",
        "    # actions should be a dict of: (int): A (1): list of actions for all 3 machines\n",
        "    self.rewards = rewards\n",
        "    self.actions = actions\n",
        "\n",
        "  # Use to set next state to current state\n",
        "  def set_state(self, s):\n",
        "    self.s = tuple(s)\n",
        "\n",
        "  def current_state(self):\n",
        "    return (self.s)\n",
        "\n",
        "  def is_terminal(self):  #Takes tuple of states for all machines, Returns a boolean tuple\n",
        "    status = []\n",
        "    for t in range(self.no_of_machines):\n",
        "      status.append(self.s[t] >= self.no_of_states)\n",
        "      \n",
        "    return(status)\n",
        "\n",
        "  def is_terminal_single(self, s):  # Takes single machine state, Returns a boolean \n",
        "    return s >= self.no_of_states\n",
        "\n",
        "  def reset(self):\n",
        "    # put agent back in start position\n",
        "    self.s = tuple(np.zeros(self.no_of_machines))\n",
        "    return (self.s)\n",
        "\n",
        "  def get_next_state(self,a):\n",
        "    # This answers: where would I end up if I perform action 'a' in state 's'?\n",
        "    s_next = np.zeros(self.no_of_machines)\n",
        "    for m in range(self.no_of_machines):\n",
        "      # Check if state is terminal\n",
        "      # When in terminal state, the next state is independent of the action taken\n",
        "      if self.is_terminal_single(self.s[m]):\n",
        "        s_next[m] = 0\n",
        "        # Debugging tool\n",
        "        print(\"episode end:\", m, self.s[m], s_next[m], a[m])\n",
        "      else:\n",
        "        print(\"Not terminal state:\", m, self.s[m], s_next[m], a[m])\n",
        "      \n",
        "      if a[m] == \"NM\":\n",
        "        if (self.is_terminal_single(self.s[m]) == 0):\n",
        "          prob_m = transition_probs[m,self.s[m],a[m]]\n",
        "          s_next[m] = np.random.choice([self.s[m] + 1, 0], p=[prob_m, 1-prob_m])\n",
        "          # Debugging \n",
        "          print(\"Action is AM:\", m, self.s[m], s_next[m], a[m])\n",
        "\n",
        "      if a[m] == \"PM\":\n",
        "        s_next[m] = 0\n",
        "        # Debugging\n",
        "        print(\"action is PM:\", m, self.s[m], s_next[m], a[m])\n",
        "    \n",
        "    # Set next state as new state\n",
        "    self.set_state(s_next)\n",
        "    return s_next\n",
        "\n",
        "  def act(self, a):\n",
        "    a_array = np.copy(a)\n",
        "    reward = np.zeros(self.no_of_machines)\n",
        "    # this answers: where would I end up if I perform action 'a' in state 's'?\n",
        "    s_next = np.zeros(self.no_of_machines)\n",
        "    for m in range(self.no_of_machines):\n",
        "      # Check if state is terminal\n",
        "      if self.is_terminal_single(self.s[m]):\n",
        "        s_next[m] = 0\n",
        "        a_array[m] = \"CM\"\n",
        "\n",
        "      if a[m] == \"NM\":\n",
        "        if (self.is_terminal_single(self.s[m]) == 0):\n",
        "          prob_m = transition_probs[m,self.s[m],a[m]]\n",
        "          s_next[m] = np.random.choice([self.s[m] + 1, 0], p=[prob_m, 1-prob_m])\n",
        "          if s_next[m] == 0:\n",
        "            a_array[m] = \"CM\"\n",
        "            \n",
        "\n",
        "      if a[m] == \"PM\":\n",
        "        s_next[m] = 0\n",
        "\n",
        "      # Collect reward for action taken on each machine\n",
        "      reward[m] = self.rewards[a_array[m]]\n",
        "\n",
        "    # Set next state as new state\n",
        "    self.set_state(s_next)\n",
        "    return reward.sum()\n",
        "\n",
        "def standard_planner(no_of_machines=3, no_of_states=5):\n",
        "  # define a planner that describes the reward for arriving at each state\n",
        "  # and possible actions at each state\n",
        "  # s means start position\n",
        "  g = Planner(no_of_machines=3, no_of_states=5)\n",
        "  rewards = {(\"NM\"): 0, (\"PM\"): -100, (\"CM\"): -200}\n",
        "  actions = {\n",
        "    (0): ('NM', 'NM', 'NM'),\n",
        "    (1): ('PM', 'PM', 'PM'),\n",
        "    (2): ('NM', 'NM', 'PM'),\n",
        "    (3): ('NM', 'PM', 'NM'),\n",
        "    (4): ('PM', 'NM', 'NM'),\n",
        "    (5): ('PM', 'PM', 'NM'),\n",
        "    (6): ('PM', 'NM', 'PM'),\n",
        "    (7): ('NM', 'PM', 'PM'),\n",
        "  }\n",
        "  g.set(rewards, actions)\n",
        "  return g"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# What if my state is just a tuple and not a dico\n",
        "# Not a list of lists but a list of tuples.... (Take Note)\n",
        "def get_all_states():\n",
        "  states= []\n",
        "  count = 0\n",
        "  for i in range(6):\n",
        "    for j in range(6):\n",
        "      for p in range(6):\n",
        "        states.append((i,j,p))\n",
        "        \n",
        "\n",
        "        \n",
        "  return states"
      ],
      "metadata": {
        "id": "DYfQSnf0O-pB"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# get_all_states()"
      ],
      "metadata": {
        "id": "CtEY9sntBB__"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's create a state dict\n",
        "states_dict = {}\n",
        "for idx,stat in enumerate(get_all_states()):\n",
        "  states_dict[idx] = stat"
      ],
      "metadata": {
        "id": "-dIil8zUDRj2"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# states_dict"
      ],
      "metadata": {
        "id": "Ntf9xXimD_88"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Q-Learning\n",
        "GAMMA = 0.9\n",
        "ALPHA = 0.1\n",
        "ALL_POSSIBLE_ACTIONS = np.arange(8)\n",
        "\n",
        "def max_dict(d):\n",
        "  # returns the argmax (key) and max (value) from a dictionary\n",
        "  # put this into a function since we are using it so often\n",
        "\n",
        "  # find max val\n",
        "  max_val = max(d.values())\n",
        "\n",
        "  # find keys corresponding to max val\n",
        "  max_keys = [key for key, val in d.items() if val == max_val]\n",
        "\n",
        "  return np.random.choice(max_keys), max_val\n",
        "\n",
        "\n",
        "def epsilon_greedy(Q, s, eps=0.2):\n",
        "  if np.random.random() < eps:\n",
        "    return np.random.choice(ALL_POSSIBLE_ACTIONS)\n",
        "  else:\n",
        "    a_opt = max_dict(Q[s])[0]\n",
        "    return a_opt\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  # planner = standard_planner()\n",
        "  planner = standard_planner()\n",
        "\n",
        "\n",
        "  # initialize Q(s,a)\n",
        "  Q = {}\n",
        "  sample_counts = {}\n",
        "  states = get_all_states()\n",
        "  for s in states:\n",
        "    Q[s] = {}\n",
        "    sample_counts[s] = {}\n",
        "    for a in ALL_POSSIBLE_ACTIONS:\n",
        "      Q[s][a] = 0\n",
        "      sample_counts[s][a] = 0\n",
        "\n",
        "  # let's also keep track of how many times Q[s] has been updated\n",
        "  update_counts = {}\n",
        "\n",
        "  # repeat until convergence\n",
        "  reward_per_episode = []\n",
        "  for it in range(100000):\n",
        "    if it % 200 == 0:\n",
        "      print(\"it:\", it)\n",
        "\n",
        "    # begin a new episode\n",
        "    # s = planner.reset()\n",
        "    # episode_reward = 0\n",
        "\n",
        "    # Trying random state-action pair\n",
        "    st = np.random.choice(np.arange(216))\n",
        "    s = states_dict[st]\n",
        "    a = np.random.choice(ALL_POSSIBLE_ACTIONS)\n",
        "    episode_reward = 0\n",
        "    for i in range(1000):\n",
        "      # perform action and get next state + reward\n",
        "      # a = epsilon_greedy(Q, s, eps=0.2)\n",
        "      r = planner.act(planner.actions[a])\n",
        "      s2 = planner.current_state()\n",
        "\n",
        "      # update reward\n",
        "      episode_reward += r\n",
        "\n",
        "      # update Q(s,a)\n",
        "      maxQ = max_dict(Q[s2])[1]\n",
        "      Q[s][a] = Q[s][a] + ALPHA*(r + GAMMA*maxQ - Q[s][a])\n",
        "\n",
        "      # we would like to know how often Q(s) has been updated too\n",
        "      update_counts[s] = update_counts.get(s,0) + 1\n",
        "\n",
        "      # How many times Q[s][a] has been updated\n",
        "      sample_counts[s][a] += 1\n",
        "\n",
        "      # next state becomes current state\n",
        "      s = s2\n",
        "\n",
        "      a = epsilon_greedy(Q, s, eps=0.2)\n",
        "\n",
        "    # log the reward for this episode\n",
        "    reward_per_episode.append(episode_reward)\n"
      ],
      "metadata": {
        "id": "C4S8w9VFj32h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "  # determine the policy from Q*\n",
        "  # find V* from Q*\n",
        "  policy = {}\n",
        "  V = {}\n",
        "  for s in get_all_states():\n",
        "    a, max_q = max_dict(Q[s])\n",
        "    policy[s] = a\n",
        "    V[s] = max_q"
      ],
      "metadata": {
        "id": "UG3QvfjA_KNe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "  plt.plot(reward_per_episode)\n",
        "  plt.title(\"reward_per_episode\")\n",
        "  plt.xlabel('episode')\n",
        "  plt.ylabel('reward')\n",
        "  plt.show()\n",
        "  plt.savefig('rewards2-per-episode.png')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        },
        "id": "uOF2KY6DB2TP",
        "outputId": "88e9dfae-fca9-4d12-d139-f28b01425421"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "policy"
      ],
      "metadata": {
        "id": "DAaVpq3AxDLe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('reward-per-episode', reward_per_episode, fmt='%s', delimiter = ',' )"
      ],
      "metadata": {
        "id": "7FPgRbb1sCFn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Writing nested dictionary to csv\n",
        "import csv\n",
        "import itertools\n",
        "field_names= ['state', 0,1,2,3,4,5,6,7]\n",
        "with open('Sample_counts.csv', 'w') as csvfile:\n",
        "  writer = csv.DictWriter(csvfile, field_names)\n",
        "  for key, val in sample_counts.items():\n",
        "    row = {'state': key}\n",
        "    row.update(val)\n",
        "    writer.writerow(row)"
      ],
      "metadata": {
        "id": "BvaOnYVAsnXq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Writing nested dictionary to csv\n",
        "import csv\n",
        "import itertools\n",
        "field_names= ['state', 0,1,2,3,4,5,6,7]\n",
        "with open('Q.csv', 'w') as csvfile:\n",
        "  writer = csv.DictWriter(csvfile, field_names)\n",
        "  for key, val in Q.items():\n",
        "    row = {'state': key}\n",
        "    row.update(val)\n",
        "    writer.writerow(row)"
      ],
      "metadata": {
        "id": "JZtepA9ftFqn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "policy_view = policy.items()\n",
        "policy_list = list(policy_view)\n",
        "policy_list"
      ],
      "metadata": {
        "id": "FSCR858du6k-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('policy-list.csv', policy_list, fmt='%s', delimiter=',')"
      ],
      "metadata": {
        "id": "cia3jOETqqZD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "V_view = V.items()\n",
        "V_list = list(V_view)\n",
        "V_list"
      ],
      "metadata": {
        "id": "t6E192xAtcPn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('V_list.csv', V_list, fmt='%s', delimiter=',')"
      ],
      "metadata": {
        "id": "qxuCsoXYuyBF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# transitionprobs_view = transition_probs.items()\n",
        "# transitionprobs_list = list(transitionprobs_view)\n",
        "# transitionprobs_list"
      ],
      "metadata": {
        "id": "r5IiXJY2zJkn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# np.savetxt('transitionprobs-list.csv', transitionprobs_list, fmt='%s', delimiter=',')"
      ],
      "metadata": {
        "id": "EXo-snEqL6HE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "LET'S BEGIN SIMULATION....\n",
        "\n",
        "\n",
        "*   Seperate Simulation programs for were created for the three policies below - The major change to the programs are the policies used.\n",
        "*   A modified planner class helper function named standard_planner_sim() was created for the simulation. It collects info about the number of preventive and corrective maintenance carried out in each iteration.\n",
        "\n"
      ],
      "metadata": {
        "id": "lTUofqKsJ00-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XlVKszVXxI3A"
      },
      "outputs": [],
      "source": [
        "# AI-Based Maintenance Planner Environment for Simulation\n",
        "import numpy as np\n",
        "\n",
        "# \"NM\" = No Maintenance, \"PM\" = Preventive Maintenance\n",
        "ACTION_SPACE = ('NM', 'PM')\n",
        "\n",
        "class Planner: # Environment for 3 machines\n",
        "  def __init__(self, start=(0,0,0)):\n",
        "    self.s = start\n",
        "\n",
        "  def set(self, rewards, actions):\n",
        "    # rewards should be a dict of: (\"action\"): r (\"NM\"): reward\n",
        "    # actions should be a dict of: (int): A (1): list of actions for all 3 machines\n",
        "    self.rewards = rewards\n",
        "    self.actions = actions\n",
        "    # self.PM_counts = PM_counts\n",
        "\n",
        "  # Use to set next state to current state\n",
        "  def set_state(self, s):\n",
        "    self.s = tuple(s)\n",
        "\n",
        "  def current_state(self):\n",
        "    return (self.s)\n",
        "\n",
        "  def is_terminal(self):  #Takes tuple of states for all machines, Returns a boolean tuple\n",
        "    status = []\n",
        "    for t in range(3):\n",
        "      status.append(self.s[t] >= 5)\n",
        "      \n",
        "    return(status)\n",
        "\n",
        "  def is_terminal_single(self, s):  # Takes single machine state, Returns a boolean \n",
        "    return s >= 5\n",
        "\n",
        "  def reset(self):\n",
        "    # put agent back in start position\n",
        "    self.s = (0,0,0)\n",
        "    return (self.s)\n",
        "\n",
        "  def get_next_state(self,a):\n",
        "    # This answers: where would I end up if I perform action 'a' in state 's'?\n",
        "    s_next = [0,0,0]\n",
        "\n",
        "    for m in range(3):\n",
        "      # Check if state is terminal\n",
        "      # When in terminal state, the next state is independent of the action taken\n",
        "      if self.is_terminal_single(self.s[m]):\n",
        "        s_next[m] = 0\n",
        "        # Debugging tool\n",
        "        print(\"episode end:\", m, self.s[m], s_next[m], a[m])\n",
        "      else:\n",
        "        print(\"Not terminal state:\", m, self.s[m], s_next[m], a[m])\n",
        "      \n",
        "      if a[m] == \"NM\":\n",
        "        if (self.is_terminal_single(self.s[m]) == 0):\n",
        "          s_next[m] = np.random.choice([self.s[m] + 1, 0], p=[transition_probs[m,self.s[m],a[m]], 1-transition_probs[m,self.s[m],a[m]]])\n",
        "          # Debugging \n",
        "          print(\"Action is AM:\", m, self.s[m], s_next[m], a[m])\n",
        "\n",
        "      if a[m] == \"PM\":\n",
        "        s_next[m] = 0\n",
        "        # Debugging\n",
        "        print(\"action is PM:\", m, self.s[m], s_next[m], a[m])\n",
        "    \n",
        "    # Set next state as new state\n",
        "    self.set_state(s_next)\n",
        "    return s_next\n",
        "\n",
        "  def act(self, a):\n",
        "    a_array = np.copy(a)\n",
        "    reward = np.zeros((3,))\n",
        "    PM_counts = np.zeros((3,))\n",
        "    CM_counts = np.zeros((3,))\n",
        "\n",
        "    # this answers: where would I end up if I perform action 'a' in state 's'?\n",
        "    s_next = np.zeros((3,))\n",
        "    for m in range(3):\n",
        "      # Check if state is terminal\n",
        "      if self.is_terminal_single(self.s[m]):\n",
        "        s_next[m] = 0\n",
        "        a_array[m] = \"CM\"\n",
        "        CM_counts[m] = 1\n",
        "\n",
        "      if a[m] == \"NM\":\n",
        "        if (self.is_terminal_single(self.s[m]) == 0):\n",
        "          s_next[m] = np.random.choice([self.s[m] + 1, 0], p=[transition_probs[m,self.s[m],a[m]], 1-transition_probs[m,self.s[m],a[m]]])\n",
        "          if s_next[m] == 0:\n",
        "            a_array[m] = \"CM\"\n",
        "            CM_counts[m] = 1\n",
        "            \n",
        "\n",
        "      if a[m] == \"PM\":\n",
        "        s_next[m] = 0\n",
        "        PM_counts[m] = 1\n",
        "\n",
        "      # Collect reward for action taken on each machine\n",
        "      reward[m] = self.rewards[a_array[m]]\n",
        "\n",
        "       \n",
        "\n",
        "    # Set next state as new state\n",
        "    self.set_state(s_next)\n",
        "    return reward.sum(), PM_counts, CM_counts\n",
        "\n",
        "def standard_planner_sim():\n",
        "  # define a planner that describes the reward for arriving at each state\n",
        "  # and possible actions at each state\n",
        "  # s means start position\n",
        "  g = Planner()\n",
        "  rewards = {(\"NM\"): 0, (\"PM\"): -100, (\"CM\"): -500}\n",
        "  actions = {\n",
        "    (0): ('NM', 'NM', 'NM'),\n",
        "    (1): ('PM', 'PM', 'PM'),\n",
        "    (2): ('NM', 'NM', 'PM'),\n",
        "    (3): ('NM', 'PM', 'NM'),\n",
        "    (4): ('PM', 'NM', 'NM'),\n",
        "    (5): ('PM', 'PM', 'NM'),\n",
        "    (6): ('PM', 'NM', 'PM'),\n",
        "    (7): ('NM', 'PM', 'PM'),\n",
        "  }\n",
        "  g.set(rewards, actions)\n",
        "  return g"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Q-Learning Simulation / Agent Play\n",
        "if __name__ == '__main__':\n",
        "  # planner = standard_planner()\n",
        "  planner = standard_planner_sim()\n",
        "\n",
        "  # repeat until convergence\n",
        "  reward_per_episode = []\n",
        "  # Create lists to store PMs and CMs/episode: These will be a list of lists (3 machines/episode)\n",
        "  PM_counts_per_episode = []\n",
        "  CM_counts_per_episode = []\n",
        "\n",
        "  for it in range(1000):\n",
        "    if it % 200 == 0:\n",
        "      print(\"it:\", it)\n",
        "\n",
        "    # begin a new episode\n",
        "    s = planner.reset()\n",
        "    episode_reward = 0\n",
        "    episode_PM_counts = np.zeros((3,))\n",
        "    episode_CM_counts = np.zeros((3,))\n",
        "\n",
        "    for i in range(100):\n",
        "      # perform action and get next state + reward\n",
        "      a = policy[s]\n",
        "      # print(a)\n",
        "      r, PM_counts_per_timestep, CM_counts_per_timestep = planner.act(planner.actions[a])\n",
        "      s2 = planner.current_state()\n",
        "\n",
        "      # update reward\n",
        "      episode_reward += r\n",
        "\n",
        "      # From the envir returns a list of PMs/timestep, which we can update\n",
        "      # Update PM_counts\n",
        "      episode_PM_counts += PM_counts_per_timestep \n",
        "\n",
        "      episode_CM_counts += CM_counts_per_timestep \n",
        "\n",
        "      # next state becomes current state\n",
        "      s = s2\n",
        "    \n",
        "    # log the reward for this episode\n",
        "    reward_per_episode.append(episode_reward)\n",
        "\n",
        "\n",
        "    # log PM/s per episode\n",
        "    PM_counts_per_episode.append(episode_PM_counts)\n",
        "    CM_counts_per_episode.append(episode_CM_counts)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BHV1p7aqxS-7",
        "outputId": "6202b1df-a113-473e-8365-5827f27277ca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "it: 0\n",
            "it: 200\n",
            "it: 400\n",
            "it: 600\n",
            "it: 800\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Periodic Maintenance Simulation\n",
        "# Policy function\n",
        "def periodic_policy(i):\n",
        "  if (((i+1) % 3 == 0) & (i != 0)):\n",
        "    policy = 1\n",
        "  else:\n",
        "    policy = 0\n",
        "  return policy\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  # planner = standard_planner()\n",
        "  planner = standard_planner_sim()\n",
        "\n",
        "  # repeat until convergence\n",
        "  reward_per_episode = []\n",
        "  # Create lists to store PMs and CMs/episode: These will be a list of lists (3 machines/episode)\n",
        "  PM_counts_per_episode = []\n",
        "  CM_counts_per_episode = []\n",
        "\n",
        "  for it in range(1000):\n",
        "    if it % 200 == 0:\n",
        "      print(\"it:\", it)\n",
        "\n",
        "    # begin a new episode\n",
        "    s = planner.reset()\n",
        "    episode_reward = 0\n",
        "    episode_PM_counts = np.zeros((3,))\n",
        "    episode_CM_counts = np.zeros((3,))\n",
        "\n",
        "    for i in range(100):\n",
        "      # perform action and get next state + reward\n",
        "      a = periodic_policy(i)\n",
        "      # print(a)\n",
        "      r, PM_counts_per_timestep, CM_counts_per_timestep = planner.act(planner.actions[a])\n",
        "      s2 = planner.current_state()\n",
        "\n",
        "      # update reward\n",
        "      episode_reward += r\n",
        "\n",
        "      # From the envir returns a list of PMs/timestep, which we can update\n",
        "      # Update PM_counts\n",
        "      episode_PM_counts += PM_counts_per_timestep \n",
        "\n",
        "      episode_CM_counts += CM_counts_per_timestep \n",
        "\n",
        "      # next state becomes current state\n",
        "      s = s2\n",
        "    \n",
        "    # log the reward for this episode\n",
        "    reward_per_episode.append(episode_reward)\n",
        "\n",
        "\n",
        "    # log PM/s per episode\n",
        "    PM_counts_per_episode.append(episode_PM_counts)\n",
        "    CM_counts_per_episode.append(episode_CM_counts)\n"
      ],
      "metadata": {
        "id": "Ob-kHjiUtJ8j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "728accf1-e441-4fb4-cdcc-d144369a506d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "it: 0\n",
            "it: 200\n",
            "it: 400\n",
            "it: 600\n",
            "it: 800\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Corrective Maintenance Policy\n",
        "if __name__ == '__main__':\n",
        "  # planner = standard_planner()\n",
        "  planner = standard_planner_sim()\n",
        "\n",
        "  # repeat until convergence\n",
        "  reward_per_episode = []\n",
        "  # Create lists to store PMs and CMs/episode: These will be a list of lists (3 machines/episode)\n",
        "  PM_counts_per_episode = []\n",
        "  CM_counts_per_episode = []\n",
        "\n",
        "  for it in range(1000):\n",
        "    if it % 200 == 0:\n",
        "      print(\"it:\", it)\n",
        "\n",
        "    # begin a new episode\n",
        "    s = planner.reset()\n",
        "    episode_reward = 0\n",
        "    episode_PM_counts = np.zeros((3,))\n",
        "    episode_CM_counts = np.zeros((3,))\n",
        "\n",
        "    for i in range(100):\n",
        "      # perform action and get next state + reward\n",
        "      a = 0\n",
        "      r, PM_counts_per_timestep, CM_counts_per_timestep = planner.act(planner.actions[a])\n",
        "      s2 = planner.current_state()\n",
        "\n",
        "      # update reward\n",
        "      episode_reward += r\n",
        "\n",
        "      # From the envir returns a list of PMs/timestep, which we can update\n",
        "      # Update PM_counts\n",
        "      episode_PM_counts += PM_counts_per_timestep \n",
        "\n",
        "      episode_CM_counts += CM_counts_per_timestep \n",
        "\n",
        "      # next state becomes current state\n",
        "      s = s2\n",
        "    \n",
        "    # log the reward for this episode\n",
        "    reward_per_episode.append(episode_reward)\n",
        "\n",
        "\n",
        "    # log PM/s per episode\n",
        "    PM_counts_per_episode.append(episode_PM_counts)\n",
        "    CM_counts_per_episode.append(episode_CM_counts)\n"
      ],
      "metadata": {
        "id": "KFUy21YkwvYo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fbcf24e-f0f7-4e93-eb1f-45e4c8603001"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "it: 0\n",
            "it: 200\n",
            "it: 400\n",
            "it: 600\n",
            "it: 800\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Collect relevant Info from simulation"
      ],
      "metadata": {
        "id": "f-wmtaT7K_Vq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "maintenance_cost_per_episode = -np.array(reward_per_episode)"
      ],
      "metadata": {
        "id": "9BBOn-l-D3Oy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "maintenance_cost_per_episode"
      ],
      "metadata": {
        "id": "e6AUhJIzGi-3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "reward_per_episode = np.array(reward_per_episode)"
      ],
      "metadata": {
        "id": "280wBiobxaXn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "reward_per_episode"
      ],
      "metadata": {
        "id": "ZbNSjxvdGzd6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "PM_counts_per_episode = np.array(PM_counts_per_episode)"
      ],
      "metadata": {
        "id": "gdCRPamVG-0F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "PM_counts_per_episode"
      ],
      "metadata": {
        "id": "FTtZMKxdHB3P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CM_counts_per_episode = np.array(CM_counts_per_episode)"
      ],
      "metadata": {
        "id": "TWwyNIDpHJqb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CM_counts_per_episode"
      ],
      "metadata": {
        "id": "kA8yWQswHNJt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "average_maintenance_cost = np.mean(maintenance_cost_per_episode)"
      ],
      "metadata": {
        "id": "ljtBuNNm792q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "average_maintenance_cost"
      ],
      "metadata": {
        "id": "9dJZ8_tq8MSo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "average_CM_counts_per_machine = np.mean(np.array(CM_counts_per_episode), axis=0)"
      ],
      "metadata": {
        "id": "GetTOGXm8fR9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "average_CM_counts_per_machine"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o-iGCMF88ttL",
        "outputId": "74cca169-2102-444f-c723-2aa8cf3fef6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "average_PM_counts_per_machine = np.mean(np.array(PM_counts_per_episode), axis=0)\n",
        "average_PM_counts_per_machine"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M0g9DJhn-yYx",
        "outputId": "c146c37a-27c1-4a01-81e5-27250b811e1e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([50., 50., 50.])"
            ]
          },
          "metadata": {},
          "execution_count": 160
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Save Info"
      ],
      "metadata": {
        "id": "RhWJOfOpLDwZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('RL-maintenance-sim-PM-counts-per-episode', PM_counts_per_episode, fmt='%s', delimiter = ',')"
      ],
      "metadata": {
        "id": "E4kdTtHy9oKR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('RL-maintenance-sim-CM-counts-per-episode', CM_counts_per_episode, fmt='%s', delimiter = ',')"
      ],
      "metadata": {
        "id": "FAWSPLQnBLsC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('RL-maintenance-sim-reward-per-episode', reward_per_episode, fmt='%s', delimiter = ',')"
      ],
      "metadata": {
        "id": "aTBewP21BOHZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('RL-maintenance-sim-cost-per-episode', maintenance_cost_per_episode, fmt='%s', delimiter = ',')"
      ],
      "metadata": {
        "id": "HHvkvwllEv32"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.savetxt('RL-maintenance-sim-cumresults', (average_maintenance_cost, average_CM_counts_per_machine, average_PM_counts_per_machine), fmt='%s', delimiter = ',' )"
      ],
      "metadata": {
        "id": "F09cqSF5-dX-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's Plot some figures - total maintenance cost per episode for all three(3) policies"
      ],
      "metadata": {
        "id": "H4leqmFDMJ0p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "RL_cost_per_episode = -np.array(reward_per_episode)"
      ],
      "metadata": {
        "id": "BxEP3LnWPE3l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "periodic_cost_per_episode = -np.array(reward_per_episode)"
      ],
      "metadata": {
        "id": "LrkX8d0MPOqt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "corrective_cost_per_episode = -np.array(reward_per_episode)"
      ],
      "metadata": {
        "id": "fBF7aFbhPQ_B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(RL_cost_per_episode, label='RL policy')\n",
        "plt.plot(periodic_cost_per_episode, label = 'periodic')\n",
        "plt.plot(corrective_cost_per_episode, label = 'corrective')\n",
        "# plt.title(\"maintenance cost per episode\")\n",
        "# plt.xlabel('episode')\n",
        "# plt.ylabel('costs')\n",
        "plt.legend()\n",
        "plt.savefig('maintenancecosts-per-episode.png', dpi=200)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "OCjruj6pLJsv",
        "outputId": "82bf5c93-79ac-415b-d0e2-2be281fca410"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}