DQN_for_Bearing_Fault_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2f4652d7",
   "metadata": {},
   "source": [
    "## Bearing Fault Classification using Deep Reinforcement Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35fba186",
   "metadata": {},
   "source": [
    "    Reference Paper: Intelligent fault diagnosis for rotating machinery using deep Q-network\n",
    "                     based health state classification: A deep reinforcement learning approach by:\n",
    "                     Yu Ding, Liang Ma, Jian Ma, Mingliang Suo, Laifa Tao, Yujie Cheng, Chen Lu\n",
    "    \n",
    "    Data: Case Western Bearing Data\n",
    "          https://engineering.case.edu/bearingdatacenter/download-data-file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87c2ffbb",
   "metadata": {},
   "source": [
    "### Description"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b507ce6",
   "metadata": {},
   "source": [
    "    1. In this project, bearing fault classification is done with the help of Deep Q Learning method.\n",
    "    2. A Deep Reinforcement Learning Agent is used to predict whether vibration data of a bearing state is in\n",
    "       which fualt mode.\n",
    "    3. The deep reinforcement learning agent has a 2 Convolution Layer with 2 Fully connected layers and a output \n",
    "       layer to predict q-values.\n",
    "    4. Vibration data is converted to 2D Continous Wavelet Transform Scalogram for the Training and Testing the               agent.\n",
    "    5. The training takes place as quiz game where the agent will predict N number of scalograms in an episode. \n",
    "       The scalograms in an episode contains Bearing state of 4 different conditions.\n",
    "    6. If the agent predicts correctly, then it gets a reward of +1 else -1.\n",
    "    7. The goal of the agent is to maximize rewards, thus the goal is to train the agent to predict the state of \n",
    "       the scalogram."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92987526",
   "metadata": {
    "id": "92987526"
   },
   "source": [
    "### Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "38f38fd1",
   "metadata": {
    "id": "38f38fd1"
   },
   "outputs": [],
   "source": [
    "import torch                              # Torch\n",
    "import matplotlib.pyplot as plt           # Plotting\n",
    "import numpy as np                        # Numpy\n",
    "from collections import deque, namedtuple # Special List and Tuple\n",
    "import torch.nn as nn                     # Neural Networks\n",
    "import torch.nn.functional as F           # Functional API\n",
    "import torch.optim as optim               # Optimizers\n",
    "from torchsummary import summary          # Summarizer\n",
    "import random                             # Random\n",
    "import os                                 # To handle files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a08af8",
   "metadata": {
    "id": "d3a08af8"
   },
   "source": [
    "### Implement Q Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "167418c8",
   "metadata": {
    "id": "167418c8"
   },
   "outputs": [],
   "source": [
    "class QNetwork(nn.Module):\n",
    "    '''Q-Network'''\n",
    "    def __init__(self, ch_size, action_size, seed, cnn_1, cnn_2, unit_1, unit_2, kernel_size=3, stride=2, pool_size=2):\n",
    "        '''Construct the Q-Network:\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      ch_size     : The size of the channels in an image;     ===> Type: Integer.\n",
    "                      action_size : The number of actions;                    ===> Type: Integer.\n",
    "                      seed        : To Seed;                                  ===> Type: Integer.\n",
    "                      cnn_1       : The number of filters in CNN Layer 1;     ===> Type: Integer.\n",
    "                      cnn_2       : The number of filters in CNN Layer 2;     ===> Type: Integer.\n",
    "                      units_1     : The number of units in Dense Layer 1;     ===> Type: Integer.\n",
    "                      units_2     : The number of units in Dense Layer 2;     ===> Type: Integer.\n",
    "                      kernel_size : The size of kernel in Convolution;        ===> Type: Integer.\n",
    "                      stride      : The strides in Convolution;               ===> Type: Integer.\n",
    "                      pool_size   : The pooling kernel size;                  ===> Type: Integer.\n",
    "        '''\n",
    "        super(QNetwork, self).__init__()\n",
    "        self.seed  = torch.manual_seed(seed)   # Seed Torch\n",
    "        self.cnn_layer_1  = nn.Conv2d(in_channels=ch_size, out_channels=cnn_1, kernel_size=kernel_size, stride=stride) # CNN Layer 1\n",
    "        self.pool_layer_1 = nn.MaxPool2d(kernel_size=pool_size, stride=1)            # Max Pool Layer 1\n",
    "        self.cnn_layer_2  = nn.Conv2d(in_channels=cnn_1, out_channels=cnn_2, kernel_size=kernel_size, stride=stride) # CNN Layer 2\n",
    "        self.pool_layer_2 = nn.MaxPool2d(kernel_size=pool_size, stride=1)            # Max Pool Layer 2\n",
    "        self.dense_1      = nn.Linear(in_features=cnn_2*13*13, out_features=unit_1)  # Dense Layer 1\n",
    "        self.dense_2      = nn.Linear(in_features=unit_1, out_features=unit_2)       # Dense Layer 2\n",
    "        self.dense_3      = nn.Linear(in_features=unit_2, out_features=action_size)  # Dense Layer 3\n",
    "\n",
    "    def forward(self, state):\n",
    "        '''Makes a Forward Pass of the Neural Network.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      state: The state of the environment i.e. here an image; ===> Type: 3D-Tensor; Size: (3X64x64).\n",
    "           Return:\n",
    "           ===========\n",
    "                      x: The action values; Type ===> Tensor; Size: action_size.\n",
    "        '''\n",
    "        x = F.relu(self.cnn_layer_1(state)) # CNN Layer gets Relu Activation\n",
    "        x = self.pool_layer_1(x)            # Pool\n",
    "        x = F.relu(self.cnn_layer_2(x))     # CNN Layer gets Relu Activation\n",
    "        x = self.pool_layer_2(x)            # Pool\n",
    "        x = torch.flatten(x, 1)             # Flatten\n",
    "        x = F.relu(self.dense_1(x))         # Dense Layer gets Relu Activation\n",
    "        x = F.relu(self.dense_2(x))         # Dense Layer fets Relu Activation\n",
    "        x = self.dense_3(x)                 # Output Dense Layer\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc20eb28",
   "metadata": {
    "id": "bc20eb28"
   },
   "source": [
    "### Summarize the Network with Dummy Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "986c9b42",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "986c9b42",
    "outputId": "f20b6174-ec3f-4199-c448-efa11ddd7afc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==========================================================================================\n",
      "Layer (type:depth-idx)                   Output Shape              Param #\n",
      "==========================================================================================\n",
      "├─Conv2d: 1-1                            [-1, 64, 31, 31]          1,792\n",
      "├─MaxPool2d: 1-2                         [-1, 64, 30, 30]          --\n",
      "├─Conv2d: 1-3                            [-1, 32, 14, 14]          18,464\n",
      "├─MaxPool2d: 1-4                         [-1, 32, 13, 13]          --\n",
      "├─Linear: 1-5                            [-1, 64]                  346,176\n",
      "├─Linear: 1-6                            [-1, 32]                  2,080\n",
      "├─Linear: 1-7                            [-1, 4]                   132\n",
      "==========================================================================================\n",
      "Total params: 368,644\n",
      "Trainable params: 368,644\n",
      "Non-trainable params: 0\n",
      "Total mult-adds (M): 5.62\n",
      "==========================================================================================\n",
      "Input size (MB): 0.05\n",
      "Forward/backward pass size (MB): 0.52\n",
      "Params size (MB): 1.41\n",
      "Estimated Total Size (MB): 1.97\n",
      "==========================================================================================\n",
      "==========================================================================================\n",
      "Layer (type:depth-idx)                   Output Shape              Param #\n",
      "==========================================================================================\n",
      "├─Conv2d: 1-1                            [-1, 64, 31, 31]          1,792\n",
      "├─MaxPool2d: 1-2                         [-1, 64, 30, 30]          --\n",
      "├─Conv2d: 1-3                            [-1, 32, 14, 14]          18,464\n",
      "├─MaxPool2d: 1-4                         [-1, 32, 13, 13]          --\n",
      "├─Linear: 1-5                            [-1, 64]                  346,176\n",
      "├─Linear: 1-6                            [-1, 32]                  2,080\n",
      "├─Linear: 1-7                            [-1, 4]                   132\n",
      "==========================================================================================\n",
      "Total params: 368,644\n",
      "Trainable params: 368,644\n",
      "Non-trainable params: 0\n",
      "Total mult-adds (M): 5.62\n",
      "==========================================================================================\n",
      "Input size (MB): 0.05\n",
      "Forward/backward pass size (MB): 0.52\n",
      "Params size (MB): 1.41\n",
      "Estimated Total Size (MB): 1.97\n",
      "==========================================================================================\n"
     ]
    }
   ],
   "source": [
    "q = QNetwork(3, 4, 2, 64, 32, 64, 32, 3, 2, 2) # Create Q network\n",
    "input_shape = (3,64,64) # Input Shape of Image\n",
    "print(summary(q, input_shape)) # Summarize"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f61bd269",
   "metadata": {
    "id": "f61bd269"
   },
   "source": [
    "### Replay Buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "795897ce",
   "metadata": {
    "id": "795897ce"
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    '''Stores Experiences in Buffer'''\n",
    "    def __init__(self, action_size, buffer_size, seed, batch_size):\n",
    "        '''Constructs the Replay Buffer.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      action_size : The number of actions; ===> Type: Integer.\n",
    "                      buffer_size : The buffer dimensions; ===> Type: Integer.\n",
    "                      seed        : To seed;               ===> Type: Integer.\n",
    "                      batch_size  : The batch size;        ===> Type: Integer.\n",
    "        '''\n",
    "        self.action_size = action_size               # Action Size\n",
    "        self.batch_size  = batch_size                # Batch Size\n",
    "        self.memory      = deque(maxlen=buffer_size) # Special List\n",
    "        self.experiences = namedtuple('Experience', field_names=['state', 'action', 'reward', 'next_state', 'done']) # Special Dictionary\n",
    "        self.seed        = random.seed(seed)         # Seed\n",
    "        \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        '''Adds Experiences to the Memory.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      state  :  The state i.e. here an image;       ===> Type: 2D Tensor; Size: (3x64x64).\n",
    "                      action : The Action taken in that state;      ===> Type: Integer.\n",
    "                      reward : The reward obtained from the action; ===> Type: Integer.\n",
    "                      state  :  The next state i.e. here an image;  ===> Type: 2D Tensor; Size: (3x64x64).\n",
    "                      done   :   If the task in completed ot not;   ===> Type: Bool.\n",
    "           Return:\n",
    "           ===========\n",
    "                      None.\n",
    "        ''' \n",
    "        e = self.experiences(state, action, reward, next_state, done) # Add Experience \n",
    "        self.memory.append(e) # Append To Memory\n",
    "        \n",
    "    def __len__(self):\n",
    "        '''Returns the current size of memory.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      None.\n",
    "           Return:\n",
    "           ===========\n",
    "                      Length of memory; ===> Type: Integer.\n",
    "        '''\n",
    "        return len(self.memory) # Return.\n",
    "    \n",
    "    def sample(self):\n",
    "        '''Sample Experiences from Memory.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      None.\n",
    "           Return:\n",
    "           ===========\n",
    "                      Tuple of (state, action, reward, next_state, done); ===> Type: Tuple.\n",
    "        '''\n",
    "        experiences = random.sample(self.memory, k=self.batch_size) # Sample from Memory\n",
    "        states      = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)   # State Tensor.\n",
    "        actions     = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)   # Action Tensor.\n",
    "        rewards     = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)  # Reward Tensor.\n",
    "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(device)            # Next States Tensor.\n",
    "        dones       = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device) # Dones Tensor.\n",
    "        \n",
    "        return (states, actions, rewards, next_states, dones) # Return tuple of tensors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8552e542",
   "metadata": {
    "id": "8552e542"
   },
   "source": [
    "### Define Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "37f070c5",
   "metadata": {
    "id": "37f070c5"
   },
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    '''Interacts with the Environment and Learns from Experiences.'''\n",
    "    def __init__(self, action_size, seed):\n",
    "        '''Constructs the Agent.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      action_size : The action-space dimension; ===> Type: Integer.\n",
    "                      seed        : The random seed;            ===> Type: Integer.\n",
    "        '''\n",
    "        self.action_size = action_size         # Action Size\n",
    "        self.seed        = random.seed(seed)   # Seed\n",
    "         \n",
    "        # Deep-Q-Network\n",
    "        self.qnet_local  = QNetwork(ch_size=3, action_size=action_size, seed=seed, cnn_1=64, cnn_2=32, unit_1=64, unit_2=32).to(device) # Local Q Network\n",
    "        self.qnet_target = QNetwork(ch_size=3, action_size=action_size, seed=seed, cnn_1=64, cnn_2=32, unit_1=64, unit_2=32).to(device) # Target Q Network\n",
    "        self.optimizer   = optim.Adam(self.qnet_local.parameters(), lr=LR) # Optimizer Adam\n",
    "        \n",
    "        # Replay Memory\n",
    "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, seed, BATCH_SIZE) # Replay Memory\n",
    "        self.t_step = 0 # Time Step to update every x iterations\n",
    "        \n",
    "    def step(self, state, action, reward, next_state, done):\n",
    "        '''Saves Experiences in Memory and Learns from experiences.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      state      : The state i.e. here an image;        ===> Type: 3D Tensor; Size: (3x64x64).\n",
    "                      action     : The Action taken in that state;      ===> Type: Integer.\n",
    "                      reward     : The reward obtained from the action; ===> Type: Integer.\n",
    "                      next_state : The next state i.e. here an image;   ===> Type: 3D Tensor; Size: (3x64x64).\n",
    "                      done       : If the task in completed ot not;     ===> Type: Bool.\n",
    "           Return:\n",
    "           ===========\n",
    "                      None.\n",
    "        '''\n",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device) # State Tensor - Convert to 4D\n",
    "        next_state = torch.from_numpy(next_state).float().unsqueeze(0).to(device) # State Tensor - Convert to 4D\n",
    "        self.memory.add(state, action, reward, next_state, done) # Add Experiences to Memory\n",
    "\n",
    "        # Learn EVERY UPDATE Steps\n",
    "        self.t_step = (self.t_step + 1) % UPDATE_EVERY # Get Remainder\n",
    "        \n",
    "        if self.t_step == 0:                           # When Remainder is 0\n",
    "            if len(self.memory) > BATCH_SIZE:          # If enough experiences are there in the memory, then learn\n",
    "                experiences = self.memory.sample()     # Samples Experiences\n",
    "                self.learn(experiences, GAMMA)         # Learn\n",
    "    \n",
    "    def action(self, state, eps=0.0):\n",
    "        '''Returns actions as per current policy.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      state :  The state i.e. here an image; ===> Type: 3D Tensor; Size: (3x64x64).\n",
    "                      eps   :  Epsilon-greedy parameter;     ===> Type: Float.\n",
    "           Return:\n",
    "           ===========\n",
    "                      Action to take; ===> Type: Integer.\n",
    "        '''\n",
    "        state = torch.from_numpy(state).float().unsqueeze(0).to(device) # State Tensor - Convert to 4D\n",
    "        \n",
    "        # Get Actions\n",
    "        self.qnet_local.eval()   # Evaluation Mode\n",
    "        with torch.no_grad():\n",
    "            action_values = self.qnet_local(state) # Get action Values\n",
    "            \n",
    "        self.qnet_local.train()  # Train Mode\n",
    "        \n",
    "        # Epsilon-Greedy Action Selection\n",
    "        if random.random() > eps:\n",
    "            return np.argmax(action_values.cpu().data.numpy()) # Greedy Action.\n",
    "        else: \n",
    "            return random.choice(np.arange(self.action_size))  # Random Action.\n",
    "        \n",
    "    def learn(self, experiences, gamma):\n",
    "        '''Learns from experiences by updating the network.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      experiences : Experiences of state, action, reward, next state and done; ===> Type: Tuple.\n",
    "                      gamma       : Discount factor;                                           ===>  Type: Float.\n",
    "           Return:\n",
    "           ===========\n",
    "                      None.\n",
    "        '''\n",
    "        states, actions, rewards, next_states, dones = experiences # Extract Tensors\n",
    "\n",
    "        # Get Maximum predicted Q-Values from Target Network.\n",
    "        Q_targets_next = self.qnet_target(next_states).detach().max(1)[0].unsqueeze(1) # Actions\n",
    "        \n",
    "        # Compute Q-Targets for current states.\n",
    "        Q_targets = rewards + (gamma*Q_targets_next*(1-dones))\n",
    "        \n",
    "        # Get expected Q values from Local Network.\n",
    "        Q_expected = self.qnet_local(states).gather(1, actions)\n",
    "        \n",
    "        # Compute Loss\n",
    "        loss = F.mse_loss(Q_expected, Q_targets)\n",
    "        \n",
    "        # Minimize The Loss by Back Propagation of Q-Net Local\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        # Update Target Network\n",
    "        self.soft_update(self.qnet_local, self.qnet_target, TAU)\n",
    "        \n",
    "    def soft_update(self, local_model, target_model, tau):\n",
    "        \"\"\"Soft update model parameters.\n",
    "        θ_target = τ*θ_local + (1 - τ)*θ_target\n",
    "        Paramaters:\n",
    "        ===========\n",
    "                   local_model  : Q Network Local where weights will be copied from; ===> Type: Object\n",
    "                   target_model : Q Network Target where weights will be copied to;  ===> Type: Object\n",
    "                   tau          : Interpolation parameter;                           ===> Type: Float\n",
    "        \"\"\"\n",
    "        for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n",
    "            target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)\n",
    "            \n",
    "    @staticmethod\n",
    "    def test_agent(qnet, image, image_name):\n",
    "        '''Tests the trained agent.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      qnet       : The trained neural network; ===> Type: Object.\n",
    "                      image      : The Test image;             ===> Type: String.\n",
    "                      image_name : The name of image file;     ===> Type: String.\n",
    "           Return:\n",
    "           ===========\n",
    "                      None.\n",
    "        '''\n",
    "        image_t = torch.from_numpy(image).float().unsqueeze(0).to(device) # To 4-D Tensor\n",
    "        action = qnet(image_t)  # Get Action values\n",
    "        fault_pred = np.argmax(action.cpu().data.numpy()) # Get maximum of the action values\n",
    "        \n",
    "        # Print Real Result\n",
    "        if int(image_name[0]) == 0:\n",
    "            print('Real State: Normal')\n",
    "        elif int(image_name[0]) == 1:\n",
    "            print('Real State: Inner Race Fault')\n",
    "        elif int(image_name[0]) == 2:\n",
    "            print('Real State: Ball Fault')\n",
    "        elif int(image_name[0]) == 3:\n",
    "            print('Real State: Outer Race Fault')\n",
    "        \n",
    "        # Print Predicted Result\n",
    "        if fault_pred == 0:\n",
    "            print(f'Predicted Fault: Normal State') # Print\n",
    "        elif fault_pred == 1:\n",
    "            print(f'Predicted Fault: Inner Race Fault') # Print\n",
    "        elif fault_pred == 2:\n",
    "            print(f'Predicted Fault: Ball Fault') # Print\n",
    "        elif fault_pred == 3:\n",
    "            print(f'Predicted Fault: Outer Race Fault') # Print\n",
    "            \n",
    "        # Plot Scalogram\n",
    "        plt.figure(figsize=(6,6))\n",
    "        plt.imshow(image.reshape((64,64,3)), cmap=plt.cm.jet)\n",
    "        plt.title('Scalogram')\n",
    "        plt.axis('off')\n",
    "        plt.show()\n",
    "    \n",
    "    @staticmethod\n",
    "    def test(qnet, test_dir):\n",
    "        '''Tests the trained agent.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      qnet       : The trained neural network; ===> Type: Object.\n",
    "                      test_dir   : The Test directory;         ===> Type: String. \n",
    "           Return:\n",
    "           ===========\n",
    "                      None.\n",
    "        '''\n",
    "        test_image_list = os.listdir(test_dir) # Get List of Test Images\n",
    "        score = 0                              # Score\n",
    "        for i in range(len(test_image_list)):\n",
    "            image = plt.imread(test_dir + test_image_list[i])                  # Read Image\n",
    "            image = image.reshape((3,64,64))                                   # Reshape Images\n",
    "            fault = test_image_list[i][0]                                      # Read Image Fault\n",
    "            image_t = torch.from_numpy(image).float().unsqueeze(0).to(device)  # To 4-D Tensor\n",
    "            action = qnet(image_t)                                             # Get Action\n",
    "            fault_pred = np.argmax(action.cpu().data.numpy())                  # Get maximum of the action values\n",
    "            \n",
    "            if int(fault) == fault_pred:\n",
    "                score = score + 1                # Correct Answer get +1 Score\n",
    "        \n",
    "        print(\"Total Images in Test Set: \", len(test_image_list), 'Images')                       # Total Data set \n",
    "        print(\"Highest Score that can be obtained: \", len(test_image_list))                       # Highest Score\n",
    "        print(\"Score Obtained with trained agent: \", score)                                       # Score\n",
    "        print(\"Accuracy of Agent: \", np.around(score/len(test_image_list), decimals=2)*100, ' %') # Accuracy\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27dff34e",
   "metadata": {
    "id": "27dff34e"
   },
   "source": [
    "### Define Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1730a636",
   "metadata": {
    "id": "1730a636"
   },
   "outputs": [],
   "source": [
    "BUFFER_SIZE  = int(1e6)  # Size of Buffer.\n",
    "BATCH_SIZE   = 32        # Batch size to sample Experiences.\n",
    "GAMMA        = 0.99      # Discount Factor.\n",
    "TAU          = 1e-03     # Soft Update Parameter.\n",
    "LR           = 5e-04     # Learning Rate.\n",
    "UPDATE_EVERY = 4         # Update every __ number of steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "85791d4d",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "85791d4d",
    "outputId": "1bb74741-afc4-4c3e-97f0-ccf8d77ef03a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: cpu\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # Device\n",
    "print('Device:', device) # Print Device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "BG4XZHz8uCsq",
   "metadata": {
    "id": "BG4XZHz8uCsq"
   },
   "source": [
    "### Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "10e34879",
   "metadata": {
    "id": "10e34879"
   },
   "outputs": [],
   "source": [
    "class Environment:\n",
    "    '''The Environment of the Model'''\n",
    "    def __init__(self, directory_data, num_folders, train, test):\n",
    "        '''Constructs the Environment.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      directory_data : The name of directory;              ===> Type: String.\n",
    "                      num_folders    : The number of folders for training; ===> Type: Integer.\n",
    "                      train          : The name of Training batch folders; ===> Type: String\n",
    "                      test           : The name of Testing directory;      ===> Type: String.\n",
    "        '''\n",
    "        self.dir = directory_data # Directory name\n",
    "        self.num = num_folders    # Number of Folders\n",
    "        self.train = train        # Training folder\n",
    "        self.test = test          # Testing Folder\n",
    "        self.list_images =[]      # List of names of images in folder\n",
    "        self.directory = None     # Directory name with Data + Batch_n\n",
    "        \n",
    "    def step(self, state, action, real_class, i_state):\n",
    "        '''Takes Action on a State, gets next state, rewards and if game is over or not.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      state      : The current state i.e. here an image; ===> Type: 3D Tensor; Size: (3x64x64). \n",
    "                      action     : The action taken by the agent;        ===> Type: Integer.\n",
    "                      real_class : The class of fault the state belongs; ===> Type: Integer.\n",
    "                      i_state    : The index of current state;           ===> Type: Integer.\n",
    "           Return:\n",
    "           ===========\n",
    "                      reward     : The reward obtained from the action; ===> Type: Integer.\n",
    "                      next_state : The next state i.e. here an image;   ===> Type: 3D Tensor; Size: (3x64x64).\n",
    "                      done       : If the task in completed ot not;     ===> Type: Bool.\n",
    "                      real_class_next_state: The class of fault the state belongs; ===> Type: Integer.\n",
    "        '''\n",
    "        # Decide Reward\n",
    "        if int(action) == int(real_class):    # If agent predicts right action\n",
    "            reward = 1 \n",
    "        else:\n",
    "            reward = -1\n",
    "            \n",
    "        # Get Next State\n",
    "        if i_state < len(self.list_images) -1:                       # When there are images in the batch\n",
    "            next_state_name = self.list_images[i_state+1]            # Get  Next State Name i.e. Image names\n",
    "            real_class_next_state = int(next_state_name[0])          # Get class of fault the image belongs to \n",
    "            next_state = plt.imread(self.directory+next_state_name)  # Get State\n",
    "            next_state = next_state.reshape((3,64,64))               # Reshape Image\n",
    "            done = False                                             # Game is not over\n",
    "            \n",
    "        else:  # When there are no images in the batch\n",
    "            done = True                    # Game is over\n",
    "            next_state = None              # There is no next state\n",
    "            real_class_next_state = None   # There are no faults\n",
    "            \n",
    "        return reward, next_state, done, real_class_next_state # Return\n",
    "        \n",
    "    def get_num_images(self, i_episode):\n",
    "        '''Gives the Number of images in the Episode/Batch.\n",
    "           Parameters:\n",
    "           ===========\n",
    "                      i_episode: The episode/batch number; ===> Type: Integer.\n",
    "           Return:\n",
    "           ===========\n",
    "                      episode_img : The number of images in the natch;         ===> Type: Integer\n",
    "                      list_images : The list of image names which are shuffled ===> Type: List.\n",
    "                      directory   : The directory name;                        ===> Type: String.\n",
    "        '''\n",
    "        episode_img = len(os.listdir(self.dir + self.train + f'_{i_episode+1}/')) # Get the number of images\n",
    "        list_images = os.listdir(self.dir + self.train + f'_{i_episode+1}/')      # Get Names of Images\n",
    "        random.shuffle(list_images)                                               # Shuffle Images\n",
    "        directory = self.dir + self.train + f'_{i_episode+1}/'                    # Directory name\n",
    "        \n",
    "        self.list_images = list_images  # Update List\n",
    "        self.directory = directory      # Directory name with Data + Batch_n\n",
    "        \n",
    "        return episode_img, list_images, directory  # Return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab3ec490",
   "metadata": {
    "id": "ab3ec490"
   },
   "source": [
    "### Define Environment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "583c0056",
   "metadata": {
    "id": "583c0056"
   },
   "source": [
    "### DQN Fault Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f5ec660b",
   "metadata": {
    "id": "f5ec660b"
   },
   "outputs": [],
   "source": [
    "def DQN_Fault_Classification(n_episodes=1700, eps_start=1.0, eps_end=0.075, eps_decay=0.995):\n",
    "    '''Trains Agent to Classify Faults.\n",
    "       Parameters:\n",
    "       ===========\n",
    "                  n_episodes : The maximum number of training episodes; ===> Type: Integer.\n",
    "                  eps_start  : Starting value of epsilon;               ===> Type: Float.\n",
    "                  eps_end    : Ending value of epsilon ;                ===> Type: Float.\n",
    "                  eps_decay  : Decaying factor of epsilon;              ===> Type: Float.\n",
    "       Return:\n",
    "       ===========\n",
    "                  scores: Score obtained in each episode; ===> Type: List.\n",
    "    '''\n",
    "    scores        = []                # Scores List \n",
    "    scores_window = deque(maxlen=100) # Score Windows to store last 100 scores\n",
    "    eps           = eps_start         # Epsilon Greedy\n",
    "    \n",
    "    # Objects of Agent and Environment \n",
    "    agent = Agent(action_size=4, seed=6)  # Agent\n",
    "    env   = Environment(directory_data='Data/', num_folders=n_episodes, train='Batch', test='test') # Environment\n",
    "    \n",
    "    # Train\n",
    "    for i_episode in range(n_episodes):\n",
    "        score = 0                                                           # Initialise Score to zero\n",
    "        EPISODE_IMG, list_images, directory = env.get_num_images(i_episode) # Get Episode Details\n",
    "        \n",
    "        # Get states of the first image in the list\n",
    "        state_name = list_images[0]                                         # Get State Name i.e. Image names\n",
    "        real_class = int(state_name[0])                                     # Get class of fault the image belongs to \n",
    "        state = plt.imread(directory+state_name)                            # Get State\n",
    "        state = state.reshape((3,64,64))                                    # Reshape Image\n",
    "\n",
    "        for i_state in range(EPISODE_IMG): \n",
    "\n",
    "            action = agent.action(state)                                                        # Get Action for the state\n",
    "            reward, next_state, done, real_class = env.step(state, action, real_class, i_state) # Pass Action to get rewards and next state\n",
    "            if next_state is not None:\n",
    "                agent.step(state, action, reward, next_state, done)         # Learn from experience\n",
    "            state = next_state                                          # Update State\n",
    "            score = score + reward                                      # Update Score\n",
    "\n",
    "        \n",
    "        scores_window.append(score)        # Append to List\n",
    "        scores.append(score)               # Append to list\n",
    "        eps = max(eps_end, eps_decay*eps)  # Decay Epsilon Values\n",
    "        \n",
    "        # Print Scores\n",
    "        if i_episode % 10 == 0:                                                          # Print Every 100 Episodes\n",
    "            print(f'Episode: {i_episode} =====> Average Score: {np.mean(scores_window)}') # Print \n",
    "    \n",
    "        if np.mean(scores_window) >=36:                                           # If Score average is x plus      \n",
    "            torch.save(agent.qnet_local.state_dict(), 'DQN_FC.pth')               # Save Weights.\n",
    "            print(f'\\nEnvironment solved in {i_episode-100} episodes! =====> Average Score: {np.mean(scores_window)}') # Print.\n",
    "            break\n",
    "            \n",
    "        if i_episode == n_episodes-1:                              # If Last Episode\n",
    "            torch.save(agent.qnet_local.state_dict(),'DQN_FC.pth') # Save Weights.\n",
    "            \n",
    "    return scores # Return Scores\n",
    "          "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1dfd9aa",
   "metadata": {
    "id": "d1dfd9aa"
   },
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6654d11f",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6654d11f",
    "outputId": "ff8c45bb-5beb-4f71-813f-229dc845d36b",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "scores = DQN_Fault_Classification(n_episodes=1700, eps_start=1.0, eps_end=0.075, eps_decay=0.995)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1953ba8c",
   "metadata": {
    "id": "72ac1ef8"
   },
   "source": [
    "### Load Saved Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "07689c37",
   "metadata": {
    "id": "07689c37",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "QNetwork(\n",
       "  (cnn_layer_1): Conv2d(3, 64, kernel_size=(3, 3), stride=(2, 2))\n",
       "  (pool_layer_1): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)\n",
       "  (cnn_layer_2): Conv2d(64, 32, kernel_size=(3, 3), stride=(2, 2))\n",
       "  (pool_layer_2): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False)\n",
       "  (dense_1): Linear(in_features=5408, out_features=64, bias=True)\n",
       "  (dense_2): Linear(in_features=64, out_features=32, bias=True)\n",
       "  (dense_3): Linear(in_features=32, out_features=4, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qnet = QNetwork(ch_size=3, action_size=4, seed=6, cnn_1=64, cnn_2=32, unit_1=64, unit_2=32) # Model\n",
    "qnet.load_state_dict(torch.load('DQN_FC.pth')) # Load Model\n",
    "qnet.eval() # Evaluation Mode"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df9263ad",
   "metadata": {
    "id": "73e0652e"
   },
   "source": [
    "### Get Test Data Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bdd91df1",
   "metadata": {
    "id": "bdd91df1"
   },
   "outputs": [],
   "source": [
    "test_dir = 'Data/Test/' # Test Data Directory\n",
    "test_list = os.listdir(test_dir) # Test Image Names"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de0ee101",
   "metadata": {
    "id": "9f208b87"
   },
   "source": [
    "### Normal Condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "32fcedc2",
   "metadata": {
    "id": "32fcedc2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real State: Normal\n",
      "Predicted Fault: Normal State\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = plt.imread(test_dir + test_list[0]) # Read  Image\n",
    "image = image.reshape((3,64,64))            # Reshape Image\n",
    "Agent.test_agent(qnet, image, test_list[0]) # Test Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cf07bc6",
   "metadata": {
    "id": "b5099396"
   },
   "source": [
    "### Inner Race Fault"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f1d3d2ce",
   "metadata": {
    "id": "f1d3d2ce"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real State: Inner Race Fault\n",
      "Predicted Fault: Outer Race Fault\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = plt.imread(test_dir + test_list[9]) # Read  Image\n",
    "image = image.reshape((3,64,64))            # Reshape Image\n",
    "Agent.test_agent(qnet, image, test_list[9]) # Test Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a60798ab",
   "metadata": {},
   "source": [
    "### Ball Fault"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8f8f788b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real State: Ball Fault\n",
      "Predicted Fault: Ball Fault\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVQAAAFkCAYAAAB/6MMYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAA9uElEQVR4nO2daaxm2Vmd1977fNOd6ta9Vd1VPQ9uY2yDjcEYOyDkAIHIgANJIAGBjAI/kBJFgYREJEpsCUj+MChSBgV+2MhACBEhjGEIIcgO2EbGNna3bWi75+6a73y/4Zyz8+MW0PRa5/Op7t0uG9YjWbLfOufsfab3Hu/1rfcNOWcYY4x54cSbPQFjjPnLghOqMcYUwgnVGGMK4YRqjDGFcEI1xphCOKEaY0whnFDNTSWE8JYQwrtu9jyMKYETqrkhQghfGkL4fyGE3RDC1RDCu0MIr73Z8zLmM4HqZk/AfPYQQtgA8MsAvhvAfwMwBPBlAGY3c16KEEKVc65v9jzMXy38hWpuhJcCQM75Z3LOTc75OOf8GznnDwFACOG7QggPhRD2QwgPhhBecz3+L0IIDz8r/g1dA4QQ3hBCeN/1L+D3hRDe8Kx/uzeE8LvXj/NbIYT/EEJ45/V/uyeEkEMI/yCE8BiA374e/7kQwjPXj/e7IYRXPOt4bw8h/McQwq+FEA6uf22fCyH8WAjhWgjhoyGEL3hRrqT5S4kTqrkRPg6gCSG8I4TwN0MIp//0H0IIfxfAWwF8O4ANAF8P4Mr1f34YJ1+ypwC8DcA7Qwjnn3vwEMIWgF8B8O8BbAP4EQC/EkLYvr7JTwN47/V/eyuAbxNz/HIAnwvgq6//718D8ACAWwC8H8BPPWf7bwLwrwCcwcmX9u9d3+4MgP9+fQ7G9CPn7P/4P73/g5Nk9XYATwCoAfwigFsB/DqAf9zzGB8A8Obr//0tAN51/b9/G4D3Pmfb37u+zV3Xx1t51r+9E8A7r//3ewBkAPctGXfz+janrv/vtwP48Wf9+z8C8NCz/vfnAdi52dfc//ns+Y+/UM0NkXN+KOf8lpzzHQBeCeA2AD8G4E6cfIkSIYRvDyF8IISwE0LYub7fGbHpbQAefU7sUQC3X/+3qznno2f92+PiGH8WCyGkEMK/u77csAfgkev/9OyxLzzrvx+L/72mzskYhROqed7knD+Kk6+8V+Ikkd3/3G1CCHcD+HEA/xDAds55E8CHAQRxyKcA3P2c2F0AngTwNICtEMLKs/7tTjWtZ/33bwHwZgBfiZPlhnv+dFrdZ2XM88cJ1fQmhPCyEML3hhDuuP6/7wTw9wH8PoCfAPBPQwhfGE54yfVkuoqTJHfp+j7fgZMErPhVAC8NIXxLCKEKIXwzgJcD+OWc86MA/gDAW0MIwxDC6wF83aeY8jpO1kWvAFgB8EPP/+yN+dQ4oZobYR/A6wC8J4RwiJNE+mEA35tz/jkAP4gT4WgfwC8A2Mo5Pwjgh3GyFnoBJ+uS71YHzzlfAfC1AL4XJ0nw+wB8bc758vVNvhXA66//2w8A+Fks/8nWT+JkyeBJAA9en68xLxohZxeYNp+dhBB+FsBHc87/5mbPxRjAX6jms4gQwmtDCPeHEGII4Wtwsj76Czd5Wsb8GXZKmc8mzgH4eZz8DvUJAN+dc/7DmzslY/4c/19+Y4wphP8vvzHGFMIJ1RhjCrF0DfXv4L/SesDZ+gJtN8YRxa5Vt3IMm3Kc1bxHse3mIsUWiad7gS3hWGBAsa3M815teNzd6jTFruEWigHACMcUO5OfpNjTYo7nGv5bNq5bil0acMGk3cjLNKfE38YtcTwAmLZ8zCtDvrZzse9Ww7H1OvEcR3y8K+L39BMx77Mz8Xd+eJljAC78mc3/zzmW93+XYpst3//DtEGxy+BnIohfa52teY4rlfYQXMIWxa5iyHNsdih2Pk0pdowRxZ7CKT6eeGYVuRU3GidW9edSifeyAj8TDRYcq/lZnFQTitUtX281l4GYCwBk8LaLBR8ziWd0MODn6R14i7yx/kI1xphCOKEaY0whnFCNMaYQS9dQR5nXaurI6wnHsiAPr99NsC/HSeB1lGkc8xEDjz0Ua1lJrP41gdd0jtIKxVrxN2aMQ4qdjMPrTLOwSrFR5rHrxPseRV5jQualmhWxRpjEGtG00q7MRcNjV+KYlXg8cuI5Hop70LZ8HVcjX5tKPCdHidf52plex67GYt1S3P8cNnmc5l6K1fGAjxd4XTyJ6zVreT0XDT9jAJDSVYqtg9f5IZ6n3TmvyWPI79Aa1LozH68V90A8dgCAKvKzrGjEu6HWMWPFx1Pz6UvXj0CDWBuNkZ9RtX/TeVTGX6jGGFMIJ1RjjCmEE6oxxhTCCdUYYwqxVJRaafjH0LOKBahW/CB5lFlYWG+vyXHmgX+UvB83Kaay/ziz0BUzL2ofR/6x8FQs+A+EwLKOHTEy0IjLdyQEutUFL7xPh+JHzoEX8geZxY/xXPxoWhxvTwgDACB+c42h+BX/eMD39VjMcT+xIDIQ5oGNlq9XE3m7vYpjdcP3DwDWwMLpujCaTMGC0W7iH74PxHO7FsQzJsSdq4EFqJnYDgBW8DTFtsCC2EHg5+lqy8ectCycbkV+lvfAc2yESKkEGwAI4uEJ6kfzDT+PMfB2o8jvfiNE6laMEWL/xgtSVhL7iyneEP5CNcaYQjihGmNMIZxQjTGmEE6oxhhTiKWi1Ljlxf0DUXlnLhbeR4H3XWm0UyonXujeA4sQylWz1nJVqpR5kf0wrlPsCBzbEKLUSsNiAQAcRyFCiOpHW5mPqY44FeLeabFKvtKygnTYKiGOjwdITQorDR9zLCr3HIh7dSjmvaEcXsJ5Nwu83XHgceNoh2IAMKq5OtRIiDZHQ+FqS89QrBIVkUb1GYo14jq0AxaGjjrcgSs1i42r4TYxR/7mmY35mVcv8khUtFLyzI0UmY/iG0w5m1rxPKrPtyiexnkWCqnQn5Qk1eVqkk6pIJxS4n27EZ3KX6jGGFMIJ1RjjCmEE6oxxhTCCdUYYwpxw22ko1yi5QXoINxK3fTd9vmX9VJon8UL/RujVt5ZgspC3IMQdxB2OJa4dUcrBLLc0XIGqrRaxUJHFi6mLISOIATEEFigyeJcmsBlGoMSOcHzA4CYudVOM+Xr2A55/4grFEvqvky5XN48s+g6WN+h2HGHy24xE/MWrXaqVd5/IFxW6h4s5ndSrBWtZIJwRQUhFgK6BJ+KtWL3JI4pBS0hkiXpilLH65KQxDFlBriRYzL+QjXGmEI4oRpjTCGcUI0xphBOqMYYUwgnVGOMKcRSlX8mahVWov7kRCl/QkA7Fk3aAKARVsOxqGmpGtEtRC3VOrByGEWNRdU0MAjV8TiqJoRALZoGjsD1NGcDttIlcYFGQuVXVrhjcbxa1aRVvxqAbi7YDvi8D6RBllXwVaHKp8jPyb5odqisgitgq+dENMUDgIX4JJhGUQe25XFWRcO5gfjGOBbXZjrnMSbSlqmb2jVi3vuyfi3Pe101TxTq9EEWTR8FSVwHZdUEdPM9pdRXlUotfC4zYfVVtVjVfOSvCzp+CaTqnKpfMqhxrPIbY8xNwAnVGGMK4YRqjDGFcEI1xphCLBWljhOLMZOWRZdKiA0z0RTvoNrUkxD1D9fbHYq1YrH6QAhdSggYCZFrknne8yDmHTYpBmhxZzWzLfQ4sDg0FPVHU8ML4s2IY/tgu6b627g2Z2EIAMJQ1CAVzdvU3uOaRYTTkWMzYRXcEY+bsv9tZNH0T1hUAeAgca3Z6SqLCOPMz8Rq5nq4iyDqvY6EmJb4/q0JEXAoBDYAOBzzOPvgppgjUdt3LYh5i+u4V/GzOBbbDYXg1yXuzBq+3krcGYpavFm8L9OFELkH/A6q50QJZKrhYBdB1LRN4j1yPVRjjLkJOKEaY0whnFCNMaYQTqjGGFOI5U4p4UJSYtFKywvLx0KUOhLCBwCsBhYhxqKhXy3EmEXk+py1WGRfbXmBfkU0IawTz/tYiACAdkVttlxvcifdTrExrlFsgqsU28Mpik3BtTSV6DbGJYoBADLf18PADqgjcb3HDY+zXrEo1Yp7fShqqY5a3nctcp3SxUI0bgOwGGxSbCZEwFXhlBvNhdg0EE3xRK3ZquJnLNV8/ybSMQRMAx/zWAgvacFutbGQC0Pke6WE4YnYN3W4uRSq+Z4SparI561ccYsF3/+VgartqxxMTNPRcFA1IkxSlHph+AvVGGMK4YRqjDGFcEI1xphCOKEaY0whlopSTcuug0HixWHVP6tuWARA0u6LoXKYVByrG7U/LzarElxqkXwk3Bxq31oIGgAwUmXLEh+zEQJNDE9SbDJiF8oc5yh2ObNQlRoWGwZDFvYAXfbsoOa/rcPqNoqNRn9CsWnzGMUW6W6KreKlFBtHdgfN2j+imGxgCCCA51hhg2K54XHawMLgKPK+lRDTdveeotgDGyz2XT1+nGIAsJvvotjqygMUWx9wQ76jvU9QbCrmvbnGxxuD53Nx5xmKnd5UTSSBMwO+FhcOL1DsWLgnt4RTsh6z2Lh3sEOxyRq/QxPRmDBXWpSaCtegEuOCiB3MxHvEtxqAv1CNMaYYTqjGGFMIJ1RjjCmEE6oxxhRiqSi1FnnBeCbKoC0yuzSqyILNunDzAEAS4s6RECHmQvzaUAJL5kXkvRkLPs2Qx6iEUHWWhz3ZX5QP2xWT3Byyq2YqyqBdFMIJKr5mm4FLwg0r4fDqLMHGgsFwztsOxPUOiR+ZuRAqlaNmHFncq4TgN1d/5mvtVhsIt1oWvZTU9VGC1hNX2aV1IK7XPWd534stO9OGE94O0H2hDqaPUGw64OuzvcHinuqFdXHOYmE15OPdsclOvjm0M20qrvfZVX4eD2p2eF2cXqTYLeNbeI5r/fpRtVIs1s98JUp/KnFWidIrI+3wVPgL1RhjCuGEaowxhXBCNcaYQjihGmNMIYIqa/Wn/BP8KP3jrnASTBvOy6uRBZtJ0P1e5kKA2hdWhJx5wXkkelxFcUrzip0kqsRcFMJZnPMCOwC0iefYpE3e8IhL+g1XVIkynvhszuJVmvM9GK9x/68pWJwBgMOaRZbtSggL+6Ln1piPqXsA8RyPdvk65orv6coq9wk7qNl5BQArFbuqNkSJuss1i0MXrrDr516ujIhtPEKxj++xgwnpiyk0GvMYALCZ2HEGPEqR3fl5ih1O7+dxhlye8tT4oxTbn7IDakvMcXchBFIAu7sc397eptggsBC7O92hmCr9d2qkSlbye14rJ2fkcQEtNmlRq9++P4vvEJKtv1CNMaYYTqjGGFMIJ1RjjCmEE6oxxhRiqVNqFSyIXBY9jg5FD6eNwG6ltQ6n1DWx6HskxkliEXkTvEheBRZ35kLkmooyb2Ox+D2pdRk8vjrAYWLX2AMrLJL8ccMi0lHDYsy9Q75mp4bsOHl4j6/DJdwpZgjctsFCxxgskoxWWJS6INxFVzKLGhstizbbEy55N6/4Pl8DO3cO5topdaYS5d+OWag6mLNwcvZWFpGO8T6KXZ69n2Iv23g5xf7oiAWfEPlaA0CDP6RYrB+m2HjI93A0/CIeB39Msdnhr1HsltWXUOzKMbvDJhMWGgHg7Jn7KLYP0f+t5ftyVohftXA2KQfifMpv20KUCJ2s8vsH6FJ/Oy33ADs8Fr3ZxuKYHc2n/IVqjDGFcEI1xphCOKEaY0whnFCNMaYQS0Up5RDQ5bG63VZ/8Xi6tJY65jIH17PZSsLlUbNoc+2A+wc1qyxUbQd2MG2ubMqxLy943lf2eIH/3AqLMeeqV1HssYbP+aGH30uxzznHYtHLNr6cYhnaXfShh/6A99/iPkVfeCv3JALuoMgHHuR9t6pHKPbql7JoMxXFET/wqLh/e+wiAoBbX8qP8Gsmb6LYByfsxvtf7/9pit21xULHX7/nNRSrhcjx4MfeRbGNbRbYAGDrThY6zlQ8zkeusuDzoSd/imJ3n+PjfdVZfiYebtit9uRj3GdqY4MFWwA4fZ5FxGbGAtSHH3qQYqdOsbD4+ffye3AkxOvQ8ruxEOO2q9qNWQkVqWn6iV9rKywWd+EvVGOMKYQTqjHGFMIJ1RhjCuGEaowxhVhavu978COifB+LADOxYLwiyveNu3ocCafVfmYRQS1Mn08sIu1nLmV2bSasDSNeJF8PfH7DDofX3pwXxa/N+G/U69b5mB/c5cXvC5dZEPnc+1n8uEMssH9kh8WwJy6yGwsAHnjJXRR7ibhf73r0Nyl25YDL/L3qFV9BsVXwfB565JcoVgcWP1559zfydmBXCwA8coEFrKcf5bHvfiX3LrpnhWv1PV5foNi1T/K9uldcw0a4A586ZMEHAAbHmzzHMywCDsU7c1GU+Zs3oodbPsfHq1iUmogylk/uPUkxQIvF951i99QVcb+eeuYJit1+TjjBhKvxWsOi8tWrPEaXmLY5YvH6ypx7gB0fs1PyjlMsxP4Evsnl+4wx5sXECdUYYwrhhGqMMYVwQjXGmEI4oRpjTCGWWk93hdo2EYr3auDGbUctW+F2oladR6L+4WZme+VM/EjgQuJfAzRhk2IbY1bkh6L26WHmS3K10ZcpBVbbz63yOI+Iy3zLKR57c8DnnERd2Etgdbpu+b7cusoqJgCci2z3VHOcnH4txe47xXVXh/kjFDsQjRcHp7n+6GrkZ6fFhyl22PFLi8HqvRR76Re/mmLrYIX54pxrn6Lha3Pmvi+g2M6CFf39Kx+i2APntfX0aJV/JfDeh/kXBqtjriv7qtv5vdxLfP9+970fp9jrXsG/bLl1lZ+npzp+/PPIJx+h2JlX8y8/bhd1cw/W+Nl59IlPUuxld7yMYsPEvwSqEr9/bat/SaS+HFWDwBh5S/Wrgy78hWqMMYVwQjXGmEI4oRpjTCGcUI0xphBLRSnVfO+UaJQ3Ciyw7GdeyD2AbqA1AAs5q2GHYsolOwULXWyuA6o52xFXAlsKqwEv0KNioeIEFiaqGVvkHj/iOb76NF/H+ZhFpIcv8XVMwqJ4duseig2PtX3wYM7N4HbaV1MsrPB5n60eotgGeJzLqkHgmC2Kg7hDsRFY5Lq2o5vGDTf5+qh6mpixILIdN3mzCceeEeJlbjh273kWyGbH6mkEjif87L3kfm6gtwquxXl8xPdgLuyjrxbiXHXEItDTDd+/9Y4aoA88wM/e/hFbvY+HfH1Us7uzZ/kZO1bXW9RcTkKUUjEAqESqqwJ/Typ7u2oa2IW/UI0xphBOqMYYUwgnVGOMKYQTqjHGFGJpPdTvWvwo/aNa9FXuglYsIreiCV3XtjHyInIILJIpFpndEgvRkCtGsagtxo0d2p1arK4bFptS4uujFtnFerhGLKYruo6nrrdyfTVZLcaLhXyxr6Lv4n4SYugss6gIAFVm8SsJR14GC361iOWWnUQps+unEqd83HCzwmGHSBJxnmJNzUJQI+YYKq4DGoV4lRdcD7Ud8HUM4nnozgv8bsWez6Nq5pnFuzoJLEAeCSdg27DLbjTQribVcHTR8v5JbDeKfMx34NtcD9UYY15MnFCNMaYQTqjGGFMIJ1RjjCnEUqeUEptUySu5gC2XbDV9j5kDCz5KMFLHUzE5FxFTAtKy+GcMQZcyQ76Bm3NTEPMWYhEAILGrBsLNJ8mnRUxcm7QjdhavTivcRaK85AksiOQohDehLAY1b9G4MQsXmvqCejGeYiUCvZD3JfTctWsMNZ++3Mi8/YVqjDGFcEI1xphCOKEaY0whnFCNMaYQS0WpSjh8lPtGilJKp+oQhlRUySnKhTQSvWaC2Dsp4UvF5AK0dvhI4WyJ8+xTo866/N88ucD/Ga5ThZZ7awEAEgs5WQk+YCEnNNtiIFVuj0syZtEzS4lFudFlB3NitxMilxgMoqcYajHvxCUwkZ4Rx1MuMvVAaEGzr7gr9xUxNbKazwsRmrtQrihFdvk+Y4z59OOEaowxhXBCNcaYQjihGmNMIZY7pUS+zYEXaNu2Z5m31LEILNwpWR1Tlf8T1dGUKyJGjjU9BaS2Y4E+q7h0J/Urb9c1+nNR96XDE6URcwy956jmw/ve0Hz6kPX81D3IokeZ3lm47MRzEqTzSsxHuayy/mbJ8pgspqkrGYJ6bfmc9Rjq3gtxVezZhXrf+gpQ0iXZ8726EVFKOsR62q/slDLGmJuAE6oxxhTCCdUYYwrhhGqMMYX4FKIU099HJBaRuxbo+9bmkgIEj64Xyfu5L+SC+A2s0L9Q90Y/XgSh6gXRbz79/SZMTIcyHqB6CKnHWvQUq9iZpEr/KXeREqWiKCUYohKaAPl2ZS5RqAS/mPZ51yzGqYVLa+kb/+fcyHOstuwrSinkO93TKdX1hdj3mMrp2CVKK/yFaowxhXBCNcaYQjihGmNMIZxQjTGmEEuXqFuxQJ+zKo2nFnKFyyp3lMET2wrDCrLocaVcDFJYUmOI7dS8u5bT+27Zd3n/hSzkS2GoY+f+IqKYT2+tov98aDsxRkhKQALQblIoZxaqghByEC5ySAlQ7RaPIfqbheqSmKC+YFmVI2w2OCbEuBAui/lwGUsseIxQsXB2Y06g3h4oEVEvtcgdXb3QnoMuv9e1b8/5yCn275nnL1RjjCmEE6oxxhTCCdUYYwrhhGqMMYVYKkqpHk5RCEPaxSAWm7usMkqsCjxOVbFrJGchnIl9VZ+prMr8ie2aDieXKnmnHSa6c06fmFw4741eoI9KWZJ2l55utxcgVGmUgKBL8mVV1q9lUSqnHYpFzMQRx2IQFnykUJGUK6rjoc+bHGpEnyolSmEqYmKIVpQnFNspoelG3EGh53eZfEzEu6XeDCVAZfF8dlXk1K4qcd6qT5xqpNdR7dJfqMYYUwgnVGOMKYQTqjHGFMIJ1RhjCuGEaowxhViq8udWKeiiPqNQ/pWS3GUpy61QdYVPMYn8v5CNyBRKlutpUe1QDpXKqFR59WuC/ijlv89Wy+jXaE/q0z0b/N3YfPqg6p4CiKzUK+uxvgMrYjuh6EdVi1WNwSp9F7KBXjrgY8pfmPC85ass5/3p+HVJ1zPa75cD+iuvX5M++euLjvnoY6pfHfSv5OsvVGOMKYQTqjHGFMIJ1RhjCuGEaowxhVjepE8UpqyUACUOowSottWL0o1YXE6Bj6nsZ42wmar6jq1aWFY2M1VftcvPJsK1mOMocrO0RsxHXR1p6xXbKRtd7mi0pu5DKyy8lRAg1RzVor26jqpxn7q2tZhLiqJ+KIAYjig2j1cpFlquNTqM5yi2yCwMLZqnKDauVnm7BcdCFHVKAYyTsL2mPQrNG74H0xnbYwdDvranRmyFnQvRbX/GtWKHQy2wrQeuFzsD11id1myPHVQ89kjMpwHPuxHPiXw+RZ1aAFjUfL2HFZ9jJXLZrFH3Sg7jL1RjjCmFE6oxxhTCCdUYYwrhhGqMMYX4FKJUv3yrmvm1yn3RIZKopmxK/lA1GpWbC1GtGPebT5ZFW/v/3anEuchmh9KtpDqEiUHkZkoE0qhmh3I7Uac2CiGgrxNMOcvkfRECRAQLPidcE+OIGqJZNMBTTqnAYgoiC1WtOOe1we0UO5zrOq5786cpNpywuDNJd1FsvMJi2rzh67Dfspg2iucploSwq2JAh2AkREmVOyolSop9a/FOq/moGSrxCgCahscJ4mVVc9TNADX+QjXGmEI4oRpjTCGcUI0xphBOqMYYU4jlopQUP3qWshLl+zrWuZHEtrrUl3AXCdeP0r6qoBwZ/YrMdZ2zWnhXJQbnwvkT1SJ7z7XvNgtxTvbd0wccCGFpLoQA7dLq54BSoo0UFXs606IQQ06OKUQy0ZxOCWy62Z147jKXDlTnV4PFMKmPAhhXLIip61gLQbNZsACFwNdnkHgMJZAmIc50fWmp+ahmngNx4krwUYJWPedzqcb9XE3z3NHMsRbC2YjvtRKgdAlFjb9QjTGmEE6oxhhTCCdUY4wphBOqMcYUYqkoBSF+KMeCcspksZDbtHpxV4kVQZTvU9lflp3LovSYdOn0687UtSatRAQp0CjBJykhoF8pQnkusi+X/nupxunrBVFClxaqlCj1/InCEXWCcDvVLECGxGJFwCURE1diIUoHZiF8VbsUS0mfdZL9rNjNVbfsnmryMxSLop9VwiYfD3wdkhCQugRNJSIpwSeM+r0bWuRS94qFQfn+dVXaFKKkQr4bHQ5Pvb8xxpgiOKEaY0whnFCNMaYQTqjGGFOIpaJU07BjIYq+MANxGOVraVvtdmnEQvJAupB44V2WGJQCFC+8R1UiULmDOtaklRgjBRpxfnLxvP/at9hXCHtdjW/U7sppdQOL8Uw/F4rU3JTICe57dBIXZf0aFjCQroi9d0SMeyaF9jTHxLxXwf2tdjvEtKN9PsAwneFjsnaF8ZCvxVSITYfiko3W5XR6o7/Anr/cqJ4wWVaz57t2I64mhRzHopQxxnz6cUI1xphCOKEaY0whnFCNMaYQS0Wpvoux0s1zAwvVfReS1TiVqHmXxbxV2TL19yTKc+7/d0f31+Ht1DlrkYuRnq+eC/kn+4t+Vl21FcVR+Xh9759yxCkRQDlq9Biq3F4ULjR9fVi0k669yPe0GvCrM5NSrBYGhyNR3k7MUfVwapVbKfPxhsKtpAS/VpTfC6nLZcf7pyRKKIoSjKqnmHrmBwMWvlXJyjqwENfVB6+q+H6pe92IPKFzgsZfqMYYUwgnVGOMKYQTqjHGFMIJ1RhjCrFUlBoksTgsFnIXWSycq75OYmEY6HLGcK5fCDdIJcr8KQGjbUX5LrHYXIl+S0q8ALQA1Yhxqqh6EgmXlihFqIWzfn8HdV8uoBF9uFIU5ehUvyc5Tr++UEoY6nsus0ZYhgAMEpe3i0MhDgnRJmOLYm3LfaaQ2O1UCUfV4YLPbzDgMQBgdajms0Ox4wWfy3zOz9NoxLFVcR0WqudZw89sEsIeAIxEGb2mEu+BOGadhOAj3v3RgMeoF/zuLyp+xpJ4fwGde7J4D+qo3sH++AvVGGMK4YRqjDGFcEI1xphCOKEaY0whlotSQoyZit4s83k/x8JwIHo9AUhinIUSv2oeZ6XiY6o+NUokkf2jpCuif0kwtRivShEqIUe5QfqaNKQDpkOUakVvLzVHtX9fAUpfb0Zdb3UuzZxFIACoJlfF/lxGD2GbQjlzWb7cXuZdB1z6Tz2z48EtFJvP9XWYx6coVlUsiI0GZyk2TLdRrBXlDae4wGOAj9cKcUbFAN1/Sr6/olRnK0SpBBa+K5GW5kIsbETdz4EoLwp0uLnUect3pv/77y9UY4wphBOqMcYUwgnVGGMK4YRqjDGFWCpKHWOXYhnnKJbSWBz5EoUWuCjHWWCDx1nwAn8lXBoteJxKiFIp8PHQCqEjCJEjqH5EwAB83hVuFXM85PmI4yXhGspBOLx60tlRStx1VRJO/bVVsUo2BlIDK0dcP9YHk45/Uc4Wcc3EQG3DIudYln9joaOGEEmEODuM4t0AgIrjNdj1pUTOJM4lCceg6tWmnsX1sUoD+lvrKItGVcKdNB6ws03JPceqXJ4Yuxrx/VelG+sOIVaV4AvyXgtR+QZaq/kL1RhjCuGEaowxhXBCNcaYQjihGmNMIZxQjTGmEEtV/kXDSmSKbOtLlWokJhqgCasfACiXW6r4FwaqVulczVHUckyi0VobeQxl/2ybdZ4ggCTqxVYDVmpncm+BamKWlfLf94D9UX9Z+7dZ7Eu/JoRyz7TX8S/8yw8dU838uM6pPmf+FQrEfYnpgGIhdd19fvViw7VTVcPJkHY6jvmc7Vp+bpuWf4mQKn6vYlcNYNFUsVYvcFQNC/mclW21FnWBB+JXDMqiXItfbpxsy3McifdXPZHymB2Z01+oxhhTCCdUY4wphBOqMcYUwgnVGGMKsVSUaua8qB0nvJAfhF0r4BTF8kI3LMuBBYeQWDBKYPtZM1/lOQ5YqAqVGAMcy5ktc13zDqKhVwo7Yssu2+RnEkK0kdupuqkvPkFeVwAN1/dEy9c7D9hSDHH/I4QAWYsaokFYXiPboEOHuTZnYYVuhL1SiHEBXLNVPWOhFiKXqJGqhMGuLy0lBClVWdUVreRBhbinLtmLIMS+GPgL1RhjCuGEaowxhXBCNcaYQjihGmNMIZaKUimqpnqiuRzYSZDFKnIIuoFWFC4IVZewAbsvlFsJmY/XqsZ9wsMUghC55HU4OSrPka9FAAtdvRHOlNDz72D/1mI3Ah+1s+5qQRpZ9xS6i6Fw1GlNQx1TNBwUZ5jk1VXuIH0XZAnZVrwHUUl+ahz1bgnBR9YAVe+0lhqlAC1UpCCa+fWVLwdi30Xmc1bup6F0P+lt56KRoNqu6mj8p/AXqjHGFMIJ1RhjCuGEaowxhXBCNcaYQiwVpYYjFlha4cioRSmzIEpwxYrLmwFAEGXrGiHk1KL32nAoyvJlLjFYi/XwELksmxLIwpCPBwBNy6JW3QoBq7hq029x/+aaS8r+rY5dwl7gcolISrRRcJPGVsxbufYUMfO7EUXjxZODirJ+Fb8zrSg7Kd1c4lXOiRvqVUk9jKIkX9Zl8JqWtx0IIUiV/1PtJucNX4e1xPflaM7voBKQ1kb6OVHbHs25YaHabmXcX1T2F6oxxhTCCdUYYwrhhGqMMYVwQjXGmEIsd0qBF7XbzAvirSyhJ/rrhCtynAjevxGlx5qaBYiUeGG5FUJFW4tShM0mz1H0hIpQpd+ARrhOmimfi2jZ81eA598/StKKvk4AENW9UaLUJoeabQqFJESuoMrlCfGx5jGC7G8FIO7wtkK0TY0QTluetxK5cuJygpUQtGohxOSmS/hU95VjUZZ5FGX+ROm/IHrC5awcZ2ouXU9Zz2OKhm3dx2T8hWqMMYVwQjXGmEI4oRpjTCGcUI0xphDLe0phSrGcuVdUgOjhFFjQytCOo6z2F7Ek0n+j+kKJeQchSgTVP0qdc8e8VVm+FJSrQu//YtO9lP7p6ALFvJC/3jl3KXtKgGKhElmIWpkdPqFlUSpHIVSJaxiEYzC2HaXfRD+yrOatnrGGj9kKd1hQ4qxwOqr7IqvvAUCjniolGKlnjGNJOMnmogTmaCBEQOGwVPt2jT0c8jFFtcwlx2T8hWqMMYVwQjXGmEI4oRpjTCGcUI0xphBLRamFEAKCWKCVbVxEX58syqUBQKP6TyUWhwYVLywvRP+oIIShVClXBDtTcha9rKTQBAThlhmMWGzo6Ib0vNFi0wsTmvRf1rJdqV7IvFPoEvbUUVl4yUGIV5EFTVlWT7idWvHqxMhzTEkVrdM917IqUShOL4qyfFGcX8gs7C5EH6Uq8bkMOsoOLpLoP9WKc4w8ThZPWar4BBcN55hhUn3dhCgl9u3adiSPycxrccyOzOkvVGOMKYQTqjHGFMIJ1RhjCuGEaowxhVgqSrULdpcMh7xAG8GOjDrzgm8jypsBQFQuj8il/rLoUxNEWbcg+kIhin5WQYlSvJCPhksJAkAQgkMA9x9qhaihSoLp2PMXm1KHDNS3GFmbRVk3IdolYavJQtDKjRAqRAm1JPoejSMLMQCwEEJOUwuhMrILKUZVlo8FrUaUeWyFUDEesSjViOcBAOoFl3lE5uesGrKkmcDzbsS3UTMVrqgB34MRWFVuOgTJec1icSueqFHkZ14JcYc9nwn17lcqfQmBDQAWNYuNczG26rlVVR1uN4G/UI0xphBOqMYYUwgnVGOMKYQTqjHGFGKpKKV6PanSaBlK3DlLMSUgAUBIwrEixmnFwrRayIcQxFQPH4ieWbJXUKuuAwBV1i2IRXtRwq2KfOkrcX5KGqgzCxWhFQv5qt4hgCRue5Z+LhaloowJmUsIC40qeSd21UKcFqVC5nsTWiECimcsydKPfM1yu8n7ihsT5BxV6T8gBnYNJvGcRezwfHBNHJHF1GE8TbEmqOMpN5cWpZLooxZEHybVP0qJUpVwZKkeVwo9hp53EA9aFOei6Dqmwl+oxhhTCCdUY4wphBOqMcYUwgnVGGMK4YRqjDGFWKryh8T2OqWCtkIZVxZFVeMUAFJUtSFZtRTCMUJQ9Q+VKqf+drA1T24na2QCkOpoP5ta8ZqmqrtY59hCbRfbZTUfqW6L7ZR6L6ysCvWrgaB+4QEgiHujxVueeOh7r8QvN2LkcZOyf3a8YlH8qmIgbN3qGZu26lcVHBoIm2kQdYob0ehQ2UkBfW2VZbqVzRN5bPXut6LZoUKq/CpJQKv8QdZ8FfVe1XPb4d/2F6oxxhTCCdUYYwrhhGqMMYVwQjXGmEIst54mUUNUNUBr2DKXheUuVlzjFACCEqBwhmKtqMWYKlXnVDXkYzsihG0REAJUpepmAtKmik2KxKjEvX7WTEUl/Zq84B87LHNqMV9ZSpXYlMW1VaKEIvUsxKq2C1jX24JrkIZK1CAV9z9C1bllsShXl3izVlgwIazVC1FfF0AUAm0KPE5Wz9h8k8eOLF4NUr/avE0rzlnYSQGgEh05W/FdVrdKyOFjpiBs2eIZk/V1lYDUZZlV1lP5PamaEApbttZI/YVqjDGlcEI1xphCOKEaY0whnFCNMaYQS0UpiDqnyGLhvRWOI9EUDaK24wksQKHdFjGlVqgmaGIROQtRQ9VnFc0BIepmniCOKerADgLvX2cWqhqxkK9qNlZSgBJ1PGWNU6BtRaNF1WhPuE6U0KUcQmpxv1FuFSmQKVFRizshXBX7i2cv3MqhhmuSZlk3leucRlHPNop7n7rUi/A0h4SQ24Lfgyjqs4ag6q6ymBrFuxbV5e4w3vV1+EXV4FE12ZQHVOJsx3UsTIfPqvf+/kI1xphCOKEaY0whnFCNMaYQTqjGGFOIpaKUKuElHTVBlOoTq825o1yaat6FwIKKLsumgmIBO6iF7n6N6bovk5q3Kun34iNdTTd0BHFfZdkyXeivz3yiLDEo3DMilkVjws7pSAFDOGCCKG8n779yRamGiny8quuTRZSO008OR4fKoCeug3LeSZecmGPXsyNdQ+JaKDFVma/UfFopzvI7qBx6yskHAOpRbmVOYELPZn6Av1CNMaYYTqjGGFMIJ1RjjCmEE6oxxhRiqSiVG3YChSR6+FRciixnsWjfqHJpQKP61AgHTFCzbdntIpUKIUBAlROUK+fCtQV0/DnaochCrH1H0UtnIEqjqSEaIVSovjeV7JkDDCKP0+Wq4vn0k7qUYKAcOVIME/Nu47WOcZSDSvUK42sWhStOn91pMa7ohSRce1VSChLQiLJ8zZzPO1V8fYaiPKEqW3c0E6U2K77Peo7aHVQ3vL8aO1U8tirzNxciV9vy8bS4p/rbaaEpi/ejVU5A8eypWBf+QjXGmEI4oRpjTCGcUI0xphBOqMYYU4jlTqlaCD5JiEWiD1PAKXE8jgFArkRfoMT9daIoW9c2XJZN9nqqLojtVFk+FiDQdIhSQfSfCjxOXfMC/VjYXYZi3lmIKYuGy++1NYtucahv7zCwkLPoKUoptLtIiRpKgOpXGi10lFAM7XkRXeGQFKCU0MVCbBT3P0fVb+tJiqWOV0yV5Wvm3OMsRi4dOIxcVrMWLsQsRKk28n1OSTnB9H05Fi4m5agcyG81ISK1/Nx2lQ7ko/WftxKglPgVb+Ba6DkZY4wpghOqMcYUwgnVGGMK4YRqjDGFWCpK3Roeptgl4Uy5hBHFWiHYrI24xw0ArGdR1q+9hUILIQQcV7xovxDiRyUEn7XMgsaG0JlaIQwAwOXA530Zd1Ps89KfUOwS7qLYrhAqtmsWY25pdyi2P+KJX4ES7ICBGOfWY+5JVKWnKHZ1yPPZAYspm3mTYmemLCrORjsUu5T4Odmev4xiAFBFFgFjeoxiwieHhRBOkxAlk3DZNYH7VtVilGOonmdAEiLb2hr3e1qI+ewp4Qwsuq1t8Ps7rrnv1aLlZ2cubYnAyoDf1akQFqeiP1at3GXCCaaE2CnYjakcWrkjpTUVz7tVbjUh7rU30M/KX6jGGFMIJ1RjjCmEE6oxxhTCCdUYYwqxVJRaYJNiQ7E4vAJ27hyKfRfYkOO04phrLS/mR7FQfhD4mAvxd2IkRIBJ3hFjsMAyDR0OLzHOBOxiaYRol4S7bCD2Ve6iWpanE/2MwMIJAEThJFLl5ELmcYIoT1iBnW4Q978R824zzzGKazMU2wHAXIikTeCxKzHvsXgm6syCzzywWKTuy0g8x4AWNBdg0XUOdiYm4RpaEeeSA4tAcyEWtj2daV0oZ1sSoo3y3amRldtJkYUApfZtOo+nHFD93FzpBr47/YVqjDGFcEI1xphCOKEaY0whnFCNMaYQS0WpeWARoWp4cXg1CQeMcHMspJgCxMwixKRmt4TK/7liwacWp6UEnxVR8q4JLLDNlDIA3b9mRYlIwlGlhBcpSol95yKWhTAwlGIREIV40oh7rcZOQhwYCFeM6s40FWUD28Bi2EA4ZYai9xAAHA34mZgJgY2fRmAiyrcdift3KPp/KUFkXezb1YNrISSauTjmmig7t9rwc7sQjqOZ6IWkRKUgnp3YUbJOfYGp8o2VTC3i/RVb5Q75qtd2WX8jRjGfNrArKihx1qKUMcZ8+nFCNcaYQjihGmNMIZxQjTGmEE6oxhhTiKUqP0QdyFiLepEta6jDASuHjVC2ASBlVnVjw7a5IJr0pUpZLpXaygozWmGFTaxYh3iRtwOQhHachK2zjqy2qwqLUVh41ZZ1UjUkOTaQzfOAmEWTv8Qqeit+3aAUz6FSiYV8O5d/vpWVkR/LuhWN9wC0QTXvY5uqrH1Zi2MmHls1CIxijJT5eKnD6qnuTStqpw6EHbUS7wYiv0ODJK6NsFYrqb2reaL61ULVs4mdanan7NtKvW+y2Fcp+lnXLs2i5nIQz1lSjUDFryW6PkX9hWqMMYVwQjXGmEI4oRpjTCGcUI0xphBLRamq5YVzZR+tRUO2gbAKrgRthawyC0szMbNGLA6PxeK+qs+IzDbKIyVoCZFjJK2VQCuELlWfsxX7R2WGbFk4QWQhL0shhkWJJOqwAkBohRCQhO01svASRBOz2GEpfi6NaKgYo7KUslh4IJrDdaGsq6r52mEl5i0EGnX/g6g/qyzGykANAENRMbQS4yTx3NZRNJITutCKmKOSKVNQBlAtaGpUrVG1lRCbVE1TITZFEcstXwcpVAFQqS6qPNGKmEUpY4z59OOEaowxhXBCNcaYQjihGmNMIZaKUqnhRfvDIYsk88hiw3DBostKw64PAKjSDsVmo8sUq4WQM1rcxcfLPM5ieJVihxWPuyrcSsNauEugxYHjqAQo5RATopRyeUhhSDesY/T1VsTIolQUIolq5tcKd5hSJaIQJRshnEA0ypsNdbO7cStq9rbcVG+eeP9GnLNyJq3MlTOJhZyFEN3Q4Q4ci2s2Ee/MPLGsNR/yvJO4jpOGm0seCZed9DnlDlFKCTRqs57uOX08Tku5p4MpixqnAJCFENuq78kX1sPQX6jGGFMKJ1RjjCmEE6oxxhTCCdUYYwqxVJSaJeWo6VeKTrl0QoeLIQs3UIsry6b2rJ3FInSrRCQ+nnIwzVVZNVXyDEAW7pskRAjVsGwmxmlE6cCRcNSMxOJ+LRbo5x0+nZh4jmPhVlMV3NRCvio6qKSBVIuJR742U/Hc1R1CXMQWxRrhWFL3upVl+YQTUBwviPsCGVNXB8jgMphNVo4z4WAT81avcpP52lRKBBT2sFa6p4AkyuhFcd5JPAGzoMpOijKfgY+nHFW1SCe6lSPQqrFFA0TlbesqZajwF6oxxhTCCdUYYwrhhGqMMYVwQjXGmEIsFaV2h+xWGgsXy6pYHa4jL5xPJztynFHg+EQsas+FqLU35HEW4rQGQrwaBl60X4gF/8OkBRElvK0u2GkzylyO7mjIIslMCBAronzbeMbHmwoH22HkHkWAFsmGDR8ztnwux3LeLFRWQiQbLVjcmw5YBJiJ6z2CFgYPIossqr/WqhCbxkIQaUVsf7BDMSXurAn3W9VR2lD5p47EszwS5zLOfC0aoZscVlOKTaQViO9BJQUbjTqiEu3aLFx24jlRwmcjrsNCCGd1hyzVCGEpq1qNgngDpQz9hWqMMYVwQjXGmEI4oRpjTCGcUI0xphBLRal97FBskrln0mkh+FyJLGgtgnY/7cyfotjLhy+h2MVaLA4PWMCYikX2CTYptpLPUeyKcGkcCNEFANbFOKMjvj5BlGprhAARhFQxCKI83QHH0inlQtrhGIA5uMzcoN6k2FiUsrsGFjoOweLXsGEBYtzw9W4G7CSaCWEwHev+WIsJ369r4FKNY3BJv2rK5xfHfE+fwKMUWxOC5PiQ7/1KxY4oANgd8buwi2sUOyecYGviXPZqfkZ3Kj7eWIhkSYgzda37qEWx7enBJsWeOuR7sLl6J8WeyUKeE6X65lL64utddfRR2214PqMknlHlyOoowajwF6oxxhTCCdUYYwrhhGqMMYVwQjXGmEIsFaXmYoG3FT2ODucfp9jaGgsxqhAZAJwa8iL7AZ6hWE7sEJlnHmcQ2LESA4sfR0JsOhSX5Fj1fwIwEX+PRhM+y3CgFtlZYDsW8znV8PndMuJeQWHAYsFVWVgRSGLeoRW9sFq1wC/6/QihI8gGQixotaLXz0y45DYmquwcAPGMboEFzUYIcXnA57wzZ0FsMBTXW4gkSVyuNuoSiiMhkk6EeDkXZQcPMgssTcX3YIjbKLaoL1EsVKL/U9Il60LD96EVpRXbBT/LdWcG+IskITaNxLN8JNxqO612B64l1V+Nc8JClfQU5yLrU8JfqMYYUwwnVGOMKYQTqjHGFMIJ1RhjCrFUlFrFPRQ7xscotrHGToL6kEWAO1bvl+NcxSMUuyZ6QIXIC+XnhWukzdsUuxx4jH0xxgC3U2y7vZViAJCmFym2O/gT3n/MDpFV8BxbsHNjkFjciSssAjQtb5ejLnk3Ebe9TXwtmsTCWRJiylCIKTGwALUY8PVaCDdWaPnaHMWPUgwA4uJeio0yzzGIsoOX0yd538jK0nY+T7HcsKAxr9gduJ93KAYAw8VdFFuL7Ko6Aj9PT6en+Xi4g2LVnGNH4DmqAnzjyM8iAEThDsyiZN5qxd9qQyHErgUWoI4azifbiQW2Q+HkPN3xzGchQG2LkpCXa74+WwPtvlL4C9UYYwrhhGqMMYVwQjXGmEI4oRpjTCGWilJrLbsv6niL2JIFqK2KY9vH7PAAgHbCi8PXwOPcIgSj0XSHYoPAi9+XBqLMW+Q+SttCJNme8oI2AMQFCx2LFRaHDlt2WiinTJT9h9jZcpB2eIxjFhGqoNwhwPqYF9kbUU7uSLmBhECzKnpmhfgYz3HMC/7zhi0nK4v7+HgjLvEIAFui91G+IsrWnecyeI+B531bYFfU6pxFwFoYoGYVlyfcCey8AoBV0fpoW7iqLo9YtLkMFkmVWLgy5+Ptr/IzobowdZWsG2TRK6rlcVaGLFSqXl+x5dik5Wd5L/PzeUfFz+IzswsUA4Azwl144SoLfreeEgKrKmXYkTn9hWqMMYVwQjXGmEI4oRpjTCGcUI0xphBOqMYYU4ilKv+1PVaYtzbYRnmw+zjFHjjNauD+5ffLcU5PvpRij++xbS5vsOI5n/4+xeKE/06sx1dR7FTLVtim4XqKs8B2WwDYGrO9chusPD5Rsaq+fsy/HFhphZo8YQX1WuTrMBjxLyXO6R8noBJN8PZEvcmFqEs5FJLwVs11KQ8nrL5fE49bSqzyb855uwNhJwaAvGBVdyjGjs3LKXa6/nyK1RXbUZusbK/8C4HF/DUUG8/ZMgkAMfI48yE/Z6365Udmu20jGmU2yuorfsVwJGyZjVDkAWCcedsommeujnjeB4fiFwILfnbObvKvGJo93newwbEHRvxLIAA4nnEuu0s0wDwt3pk8Ew/9phzGX6jGGFMKJ1RjjCmEE6oxxhTCCdUYYwqxVJRqNnmR/ZZ9FmLub1hMGYrGXQdndD3UnWO2OL4WXC/y8Ucepli6h+1+V8CL8ZszttKdWvDpPybEnd2JFkROi3HOPM1iw2Pnv5liK+H/8hwrtmteiHdT7ClRp/auyIv7t4//iGIAcHnK4+yP+d4ciiZvd9Zso93OT1JsKmq7XgFbSleF6HJrfoJipy6ylRkAntngZ2exyTbTU5fZPvjX1lnA+OQ+Pyf7m2zXXMdZim08xs/8PStcrxcAntpki+MnAn/fbGWO3bfHItCBaKq3u8b27R1hKR1mfg/WWt2FbphVQ0be/7S4PmHA16cKwma6w3Mcz3m7+SELyNtnde3S8QFfn7u3+d1KU7bHH88553XhL1RjjCmEE6oxxhTCCdUYYwrhhGqMMYVYKko9NPsbFPuaxU9Q7NUHv0qxR868kWK/s/vFcpzNxz9Bsa+/+wMU2xpwPc3/2b6WYp+YspvrzQ27UO6rH6HYw0evo9gHb3kTxQDgVrybYp8z/36K/fzO9/C+mce+4/QfU+wyXkGxj194CcUmEz6/1288SDEAWIi6pFfxZRQ7qHnsu/P/ptjpwfso9gxeT7E98L0Kmecyavl5eu2EnS4A8EuT76DYbz/DLqZvPH4PxV5RszCYzrJD7z8dsjh7t6jh+7cjPw93BhYAAeC/7L2SYu8efiXF/t4a1+z8qlPvpdj7j9g99Yv4TopF/AbFGvFdNRbNIQGgEQaqmagXHAacWuopH7NqebtLn2T32ys+70sodiAExINP6ufk/DqLVeeFE3B2yCd4Sjj3uvAXqjHGFMIJ1RhjCuGEaowxhXBCNcaYQixdbX3wnRy7+srfpNh7fotFhNPf9xUU+x9v1Qv0X/QlvKi9c+XfUuzul7PQ8XO/zov7s9u4VNt3fi4LBi8LfC6PP8jlzT62+60UA4A3PMDN4N54N5/jm36dG4zddfsHKfa60+wQWoAX8j/2MAsiW6fZSbS68SjFAOA2Uarv8IjdRfvtPRSLkcdZG7CYlsAC5BE+h2LDmkujxZYdcXeByzQCwC74OfnIL7CD5nX3P0SxJ6/9JMXaN76ZYr/zyyz4YOUZCr3lVb9FseGObi74rsf/JcU+MmLh5eobPkyxe0Y/Q7H3XHwDxf5P+gGKffWd6zzHwC67qiM1zFt2nB1d43KQ62AR6MlHn6ZYFA0e//M//xGK/dDb30Gxf/39b6PYN/+tb6AYAPzgP/thiv3oO1hAftv3/BDFvu6r+bl909t4X8BfqMYYUwwnVGOMKYQTqjHGFMIJ1RhjChFy1o4IY4wxN4a/UI0xphBOqMYYUwgnVGOMKYQTqjHGFMIJ1RhjCuGEaowxhfj/Sgpu2O+t/4cAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = plt.imread(test_dir + test_list[4000]) # Read  Image\n",
    "image = image.reshape((3,64,64))              # Reshape Image\n",
    "Agent.test_agent(qnet, image, test_list[4000]) # Test Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a93ea223",
   "metadata": {},
   "source": [
    "### Outer Race Fault"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e4ebc3d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Real State: Outer Race Fault\n",
      "Predicted Fault: Outer Race Fault\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = plt.imread(test_dir + test_list[3900]) # Read  Image\n",
    "image = image.reshape((3,64,64))              # Reshape Image\n",
    "Agent.test_agent(qnet, image, test_list[3900]) # Test Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9160bcfb",
   "metadata": {},
   "source": [
    "### Accuracy of Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6e009ab5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Images in Test Set:  21657 Images\n",
      "Highest Score that can be obtained:  21657\n",
      "Score Obtained with trained agent:  20082\n",
      "Accuracy of Agent:  93.0  %\n"
     ]
    }
   ],
   "source": [
    "Agent.test(qnet, test_dir) # Test Accuracy on unseen data"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "DQN for Bearing Fault Classification.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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}