├── README.md └── Face Mask Detection.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Real-time-Face-Mask-Detector- 2 | A real-time face mask detector using Tensorflow and OpenCV 3 | 4 | #### Motivation : 5 | ⏳Keeping in mind need of the hour, I have tried to build one - REAL TIME FACE MASK DETECTOR, which needs just a camera 📹 to capture input and the person can be classified using ML model on the basis of presence of mask on their face! 😷 6 | 7 | #### To get the dataset,click [here](https://github.com/prajnasb/observations/tree/master/experiements/data). 8 | 9 | #### Accuracy : 91.94% 10 | 11 | #### Implementation : 12 | 13 | ![upload1](https://user-images.githubusercontent.com/64924874/87032414-3699e580-c202-11ea-9d77-6ed97a886e0b.png) 14 | 15 | #### Scope of Implementation : 16 | 🔰 Scope of Implementation : Taking into consideration of the current COVID pandemic situation, it can be implemented in each and every sector to monitor preventive measures. 17 | -------------------------------------------------------------------------------- /Face Mask Detection.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 3, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import cv2\n", 10 | "import os\n", 11 | "import numpy as np\n", 12 | "#from keras.models import load_model" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 4, 18 | "metadata": {}, 19 | "outputs": [ 20 | { 21 | "name": "stdout", 22 | "output_type": "stream", 23 | "text": [ 24 | "{'without_mask': 0, 'with_mask': 1}\n", 25 | "\n", 26 | "\n", 27 | "The categories are : ['without_mask', 'with_mask']\n", 28 | "\n", 29 | "\n", 30 | "The labels are : [0, 1]\n" 31 | ] 32 | } 33 | ], 34 | "source": [ 35 | "data_path = 'D:/DS/Face Mask Detection/data'\n", 36 | "categories = os.listdir(data_path)\n", 37 | "labels = [i for i in range(len(categories))]\n", 38 | "\n", 39 | "label_dict = dict(zip(categories, labels)) #empty dictionary\n", 40 | "\n", 41 | "print(label_dict)\n", 42 | "print('\\n')\n", 43 | "print('The categories are : ',categories)\n", 44 | "print('\\n')\n", 45 | "print('The labels are : ',labels)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 5, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "img_size = 100\n", 55 | "data = []\n", 56 | "target = []\n", 57 | "\n", 58 | "for category in categories:\n", 59 | " folder_path = os.path.join(data_path, category)\n", 60 | " img_names = os.listdir(folder_path)\n", 61 | " \n", 62 | " for img_name in img_names:\n", 63 | " img_path = os.path.join(folder_path, img_name)\n", 64 | " img = cv2.imread(img_path)\n", 65 | " \n", 66 | " try:\n", 67 | " gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n", 68 | " resized = cv2.resize(gray,(img_size, img_size))\n", 69 | " data.append(resized)\n", 70 | " target.append(label_dict[category])\n", 71 | " \n", 72 | " except Exception as e:\n", 73 | " print('Exception:', e)\n", 74 | " " 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 6, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [ 83 | "data = np.array(data)/255.0\n", 84 | "data= np.reshape(data,(data.shape[0], img_size, img_size, 1))\n", 85 | "target = np.array(target)\n", 86 | "\n" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 7, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "from keras.utils import np_utils\n", 96 | "new_target = np_utils.to_categorical(target)" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 8, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "np.save('datav', data)\n", 106 | "np.save('targetv', new_target)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 9, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "datav = np.load('datav.npy')\n", 116 | "targetv = np.load('targetv.npy')" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 10, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [ 125 | "from keras.models import Sequential\n", 126 | "from keras.layers import Dense,Activation,Flatten,Dropout\n", 127 | "from keras.layers import Conv2D,MaxPooling2D\n", 128 | "from keras.callbacks import ModelCheckpoint" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 11, 134 | "metadata": {}, 135 | "outputs": [], 136 | "source": [ 137 | "model=Sequential()\n", 138 | "\n", 139 | "model.add(Conv2D(200,(3,3),input_shape=datav.shape[1:]))\n", 140 | "model.add(Activation('relu'))\n", 141 | "model.add(MaxPooling2D(pool_size=(2,2)))\n", 142 | "#The first CNN layer followed by Relu and MaxPooling layers\n", 143 | "\n", 144 | "model.add(Conv2D(100,(3,3)))\n", 145 | "model.add(Activation('relu'))\n", 146 | "model.add(MaxPooling2D(pool_size=(2,2)))\n", 147 | "#The second convolution layer followed by Relu and MaxPooling layers\n", 148 | "\n", 149 | "model.add(Flatten())\n", 150 | "model.add(Dropout(0.5))\n", 151 | "#Flatten layer to stack the output convolutions from second convolution layer\n", 152 | "model.add(Dense(50,activation='relu'))\n", 153 | "#Dense layer of 64 neurons\n", 154 | "model.add(Dense(2,activation='softmax'))\n", 155 | "#The Final layer with two outputs for two categories\n", 156 | "\n", 157 | "model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 12, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "from sklearn.model_selection import train_test_split\n", 167 | "\n", 168 | "train_data,test_data,train_target,test_target=train_test_split(datav,targetv,test_size=0.1)" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": 13, 174 | "metadata": {}, 175 | "outputs": [ 176 | { 177 | "name": "stdout", 178 | "output_type": "stream", 179 | "text": [ 180 | "Train on 990 samples, validate on 248 samples\n", 181 | "Epoch 1/10\n", 182 | "990/990 [==============================] - 71s 72ms/step - loss: 0.7414 - accuracy: 0.5273 - val_loss: 0.6942 - val_accuracy: 0.5081\n", 183 | "Epoch 2/10\n", 184 | "990/990 [==============================] - 69s 69ms/step - loss: 0.6175 - accuracy: 0.6444 - val_loss: 0.5094 - val_accuracy: 0.7137\n", 185 | "Epoch 3/10\n", 186 | "990/990 [==============================] - 69s 69ms/step - loss: 0.4491 - accuracy: 0.7949 - val_loss: 0.4335 - val_accuracy: 0.8508\n", 187 | "Epoch 4/10\n", 188 | "990/990 [==============================] - 70s 71ms/step - loss: 0.3301 - accuracy: 0.8727 - val_loss: 0.3087 - val_accuracy: 0.8750\n", 189 | "Epoch 5/10\n", 190 | "990/990 [==============================] - 67s 67ms/step - loss: 0.2039 - accuracy: 0.9283 - val_loss: 0.2607 - val_accuracy: 0.9153\n", 191 | "Epoch 6/10\n", 192 | "990/990 [==============================] - 66s 66ms/step - loss: 0.1698 - accuracy: 0.9424 - val_loss: 0.2684 - val_accuracy: 0.9032\n", 193 | "Epoch 7/10\n", 194 | "990/990 [==============================] - 66s 66ms/step - loss: 0.1524 - accuracy: 0.9434 - val_loss: 0.2113 - val_accuracy: 0.9315\n", 195 | "Epoch 8/10\n", 196 | "990/990 [==============================] - 66s 67ms/step - loss: 0.0960 - accuracy: 0.9697 - val_loss: 0.2297 - val_accuracy: 0.9194\n", 197 | "Epoch 9/10\n", 198 | "990/990 [==============================] - 65s 66ms/step - loss: 0.0980 - accuracy: 0.9677 - val_loss: 0.2870 - val_accuracy: 0.9113\n", 199 | "Epoch 10/10\n", 200 | "990/990 [==============================] - 65s 65ms/step - loss: 0.0647 - accuracy: 0.9747 - val_loss: 0.2791 - val_accuracy: 0.9194\n" 201 | ] 202 | } 203 | ], 204 | "source": [ 205 | "checkpoint = ModelCheckpoint('model-{epoch:03d}.model',monitor='val_loss',verbose=0,save_best_only=True,mode='auto')\n", 206 | "history=model.fit(train_data,train_target,epochs=10,callbacks=[checkpoint],validation_split=0.2)" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": 14, 212 | "metadata": {}, 213 | "outputs": [ 214 | { 215 | "data": { 216 | "image/png": "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\n", 217 | "text/plain": [ 218 | "
" 219 | ] 220 | }, 221 | "metadata": { 222 | "needs_background": "light" 223 | }, 224 | "output_type": "display_data" 225 | } 226 | ], 227 | "source": [ 228 | "from matplotlib import pyplot as plt\n", 229 | "\n", 230 | "plt.plot(history.history['loss'],'r',label='training loss')\n", 231 | "plt.plot(history.history['val_loss'],label='validation loss')\n", 232 | "plt.xlabel('# epochs')\n", 233 | "plt.ylabel('loss')\n", 234 | "plt.legend()\n", 235 | "plt.show()" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 15, 241 | "metadata": {}, 242 | "outputs": [ 243 | { 244 | "data": { 245 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3hUZfbA8e9J7yGkUUJXBEQIGBBUEKWIqIAKgl1ZG/5EXNvaQdlVV7EXWFSwK4hURUAQRFQkCZ2AdEmBJARIg/T398cdQhICZEKGSTLn8zx5MjO35GQg98xb7nnFGINSSinX5ebsAJRSSjmXJgKllHJxmgiUUsrFaSJQSikXp4lAKaVcnIezA7BXWFiYadmypbPDUEqpOiU+Pv6AMSa8sm11LhG0bNmSuLg4Z4ehlFJ1ioj8fbJt2jWklFIuThOBUkq5OE0ESinl4jQRKKWUi9NEoJRSLk4TgVJKuThNBEop5eLq3H0ESilV7+XkQFoapKZaX8ce9+gB/fvX+I/TRKCUUo5mDBw6dOKF/WSPjxyp/DxPPqmJQCnlIoyBtWshIQG8vKwvb2/7vrs5uOe7qAjS009/UT/2uKjoxHO4uUF4OERGQkQEnHPO8cdlv0dGWvt5ezvkV9FEoJSqHYyB2FiYOdP62r37zM7n4WFf4jjVtiNHTrywZ2RYMVfk7X38It6kCXTpUv6CXvZxw4bg7n5mv2cN0ESglHKekhL488/jF/+9e60LeL9+8OyzcPHFUFwMBQWQn3/q71XZp7LvOTmnP4ePz/GLd7t20Lt35Rf2iAgICgIRZ7+zdtFEoJQ6u0pK4LffrAv/d99BcrL1qXvAAHjxRRg8GEJCnB2lS9FEoJRyvOJi+PVX6+I/axbs22d1oQwcCP/9L1xzDQQHOztKl6WJQCnlGEVF8Msvxy/+aWng6wuDBsGwYXD11RAY6OwoFZoIlFI1qbAQfv7ZuvjPnm0NqPr5WZ/4hw2zkoC/v7OjVBVoIlBKnZmCAliyxLr4z5ljzZcPCLD6+ocNgyuvtJKBqrU0ESil7JeXB4sXWxf/efMgM9OaLTNkiHXxHzDAmmmj6gRNBEqpqjl6FBYutC7+8+dDdjY0aADXXQfDh0Pfvg674Uk5liYCpdTJ5ebCjz9aF//vv7eeh4bCiBHWJ//LL7emfqo6TROBUvVFSYk1U6e4+PjX6Z6fbJ/ERGumz4IFVksgPBxuvdW6+PfpY930peoN/ddUylmMse6k3bgRNmywvm/bZvW/V+ciXtMaNYJRo6yLf69etaIUgnIMTQRKnQ2ZmeUv+Me+srKO79OiBbRvb02vdHe3PnW7u5f/qvja6Z5Xd58GDaBrV734uwhNBErVpMJC+OuvEy/6e/ce3yc4GDp1srpaLrjAetyxozXrRikn0ESgVHUYY9XIqXjB37LFSgZgfcpu3x4uvfT4Bf+CCyAqqs4VJVP1myYCpU4nOxs2bTqxW+fQoeP7NGtmXeSvuur4Bf+88+rkjJqi4hL2ZebRKNgHT3ddzdYVaCJQ6piiIti+/cRP+WXr4gcGWhf5G288fsHv2LHOV8s0xrA28TDz1qXw/YYUDuQU4O4mNG/oR+swf1qH+9MqLIDW4dbj8ABvRFs19YYmAqXWroWxY2H1aqv2PFiDpOedB927w913Wxf8Cy6wBnTr0QVwR1oOc9clM3ddCnsPHsHLw41+7SPo2SaM/ZlH2X0gl13puazccYD8opLS4wK9PWzJwZ/W4bYEERZAqzB/fL10gLmu0USgXFdxMbz2Gjz/PISFwUMPHb/gt29fb++S3Z+Zx/z1Kcxdn8ym5CzcBC5uE8aYK87hyo6NCPLxPOGYkhJD8uFjiSGHXbYEsXr3QeasSym3b5NgnzLJwZ9W4QG0DvOnaQNf3NzqTxKtTzQRKNe0axfcfru1QMrw4TBpknXHbD2VebSQhZv2MWdtCqt2Z2AMdI4K5rlrOnBtp8ZEBJ26LpCbm9CsoR/NGvrRu214uW1HC4qtBHEgh13puaXJYvaaZLLzj6/T6+3hZmtB2FoSpV1NAQT7nph81NmjiUC5FmNg2jSrK8jNDT7/HG65pV519xyTV1jMz1vTmLsumWVb0ykoLqFVmD9j+57L4M5NaB0eUCM/x9fLnQ5NgujQpPz0V2MM6Tn55ZLDrvRctuzLZtHmVIpLjq/3GxbgdUJyaBXmT/OGfnh56IA1QH5RMUXFBn/vmr9sayJQriM9He691yqV3KcPfPopNG/u7KhqVHGJ4Y+dGcxZl8yiTfvJzi8iPNCbW3u0YGiXJlzQNPisDfKKCBGBPkQE+tCjdfnWVkFRCYmHjrAr/XiC2HUgh6VbU5keV1Bu31B/LyKCfIgM8iYy0PoeHuRDZKA3kUE+RAb5EBbghUcdneFUWFxCenY+qVl5pGblk5adR2pWHmlZ+aRm55OWZT0/dKSQMVecw6MDzqvxGDQRKNfw/ffwj3/A4cPw+uvw8MNWiwCr/3vV7gy8PdxoHRZAiH/dmvJpjGFDUiZz16Uwf0MK6dn5BHp7MLBjI4ZEN6Vnm1Dca1nfvJeHG23CA2gTHgBEltuWeaSwtJsp8dAR0kovhvkkpGRxICefMo0JwGrQhQV4ExnkTYQtWVjfbQkkyIeIQG9CA7zP2ntRVFzCgZwC24U933Zxtz22vZaenceBnIITjnV3E8IDvIkI8iYqxI8LW4QQGXRiQq0pmghU/ZaTA48+ClOmWNM9lyyxBoOxEsCizft5e+l2tu7PLj0kxM+ztGvi2GyYNuH+NA/1w9uj9syI2X0glzlrk5m3PoXdB3Lxcnfj8nbhDI1uyuXtIvDxrD2x2iPYz5MuzUPo0rzyKbnFJYaMnPzSi+uxi+qxT86pWXlsSMokIzcfUyFhuLsJYQFetsRQPklEBvkQYXve0M/rpAPbxSWGjNx86xN7Vh5pZT/Nl4nnQM6JP79swmoS7EN0swblktexGEL9z17CAhBTMdJaLiYmxsTFxTk7DFUX/PEH3HabNTD8+OPw4ovg7Y0xhsUJqby1ZDtb9mXROtyfBy8/hwZ+nuxKz2Vn+vGZMenZ+aWncxOICvErTQ7H5tS3DgsgMujszKtPy8pj/oZ9zF2XzIakTESgZ+tQhkQ3YWDHxjroWkZhcQkHyiSMtAoX7WMX8YO5J34i93ATIgK9ibAlCQOln+bTc/LLjW8cExbgVaE14m3r0jp+kQ/1d14XlojEG2NiKtumLQJV/xQWWhf9l16y7vhdvhx698YYw5KEVN5aso3NKVm0DPXjzRGdGdy5aemnryvalT9VVl4he2xTJXel57DT9njVrgzyCo/Pq/f3cqdVmQTRKsyfNrZWxZkO7mXlFbJw037mrUvh950HKDHQsWkQz17dnms6NaFRsK4EVhlPdzcaB/vSONj3lPvlFxWTnp1frguqbH/9noxc3ESICPKhbWRg6YU9okxLIizAu04PamuLQNUvW7daxdzi4+HOO+HttzGBgSz7K423lmxnQ1ImLUL9GHPFuQyNblLtT2clJYb9WXmlg5zWdytZJB8+Wq5LoFGQzwk3X7UJC6BpiO9Jm//5RcUs25rO3HXJLN2aRkFRCS1C/RjSuQmDo5tyTkTNzPhRrsNpLQIRGQi8DbgDHxljXqmwPQSYCrQB8oBRxphNjoxJ1VMlJfDBB1YXkL8/fPcd5rrrWL4tnbc+38j6xMM0a+jLq8M6cV2XpmdcQ8fNTWjSwJcmDXy59NywctvyCovZk5FbOm1yp21WzPz1KWTlHZ9X7+XuRotQv9Lpkq3D/Gng58WShFQWbNpHdl4RYQFe3Ny9OUOimxDdrIGWdVAO4bBEICLuwPtAfyAJiBWRecaYhDK7PQ2sM8ZcJyLtbPv3dVRMqp5KTrYWUFm8GAYNwnz0Eb9me/DmpN9Zu/cwTRv48sr1F3DDhVFnpYiaj6c77RoF0a7RifPqM3ILys2p35mey/a0HJZuSaPI1u/s7+XOlR0bMTS6KRe3Ca2z0yJV3eHIFkF3YIcxZheAiHwDDAHKJoIOwMsAxpitItJSRCKNMakOjEvVJzNmwP33Q34+ZtJkfut7PW/O2U7834doEuzDS9ddwLALo2pF/62IEBbgTViAN91aNiy3rai4hMRDR0nNyqNzVAOt16POKkcmgqZAYpnnScBFFfZZD1wPrBSR7kALIAoolwhE5F7gXoDm9ewGIFVNhw/Dgw/Cl1/CRRfx+3//x1tbjrD649U0DvZhwtCO3BgTVaume56Kh7tVfqFVmL+zQ1EuyJGJoLLOzIoj068Ab4vIOmAjsBYoOuEgY6YAU8AaLK7hOFVds2wZ3HEHpKSw6vnXebNxD/78MYnIIG9eGHw+I7o1q7Nz6JVyBkcmgiSgWZnnUUC5MoXGmCzgLgCxRsF2276UOlFeHjzzDLzxBrE9r+TNsR/xe3oh4RlHGHdtB27q3lwTgFLV4MhEEAucKyKtgGRgJHBz2R1EpAFwxBhTANwNrLAlB6XKW7cObr2V+MPFvPnoJ6z0CCPsqPDs1e25tUcLTQBKnQGHJQJjTJGIPAgswpo+OtUYs1lE7rdtnwy0Bz4TkWKsQeR/OCoeVUcVF8PEiax9/zPevOx2VjTtSKi/F89c1oZbe7TQQVWlaoDeUKZqr927Wf/AE7wZ0JHlbWII8fXgvj7ncHvPFvh56U3xStlDS0yousUYNk7+greW72Zp5ztp4F7C4/3acsfFrQhwQC12pVyd/lWpWmXTpj28NXkBSwJaENzMl8e6R3DHoGgCK1k+USlVMzQRqFphy74s3vriVxZlQKBHGP/0S+eux24iyK9+rhusVG2iiUA5jTGGTclZTFq6lQVbDhCYn8vYvasY9fQdBF/Y2dnhKeUyNBGosyq/qJg/dx1k6ZZUlmxJI/nwUQIK8xgTO4d/9GxOg69eBm9tBSh1NmkiUA53KLeAZX+lsWRLKiu2HSAnvwgfTzcuDSrhoZ8+4Mrs3TT4aDL07u3sUJVySZoIlEPsTM+xPvUnpBH390FKDEQEenNt58b0ax/JJVtW4TNyuLVs5B+/Qqhj1mJVSp2eJgJVI4qKS4j/+xBLtqSydEsauw7kAtC+cRAPXn4OfdtHckHTYGsd2Jkz4aaboGtXWLQIGjRwcvRKuTZNBKrasvMKWbHtAEu2pLLsrzQOHynE013o0TqUOy9pyRXtIogK8St/0Fdfwe23Q48esGABBAVVfnKl1FmjiUDZJfHgEZZuSWXp1jRW7cqgsNgQ4ufJFedF0K9DJL3ODTv5nP9PP4W77rLGAr7/HgJ0uUWlagNNBOqUSkoMG5IzWZKQypItqWzdnw1A63B/Rl3Sir7tI+navMHpV9H68EO47z7o2xfmzgU/v1Pvr5Q6azQRqBMcLSjmtx1Wl8/SrWmkZ+fjJhDTsiHPDGpP3/YRtA6349P8++9bi8hcdRXMmgU+Po4LXillN00ECoC0rDyWbk1j6ZZUft1+gPyiEgK8PbisbTj9OkTQp20EIf5e9p/4zTfhkUdgyBCYPl3vEVCqFtJE4KKMMWzdn13a5bM+KROApg18ual7c/q2j+CiVqFnttbvK6/AU0/BsGHWILGn1gtSqjbSROCiHv12PbPWJAPQuVkDHhvQln4dIjkvMhBrsbgzYAxMmADjxsHNN1uDxB76X02p2kr/Ol3Q7zsOMGtNMrf3bMGDl59DRFAN9tkbA88+Cy+9ZK0r/PHH4K6LxyhVm2kicDFFxSWMn7+ZZg19eXpQ+5pd4tEYeOIJmDgR7rkHJk8GtzPoWlJKnRX6V+pivlj1N9tSc3hmUIeaTwIPP2wlgf/7P00CStUh+pfqQg7mFvDGT9u45JxQrjw/suZOXFICo0fDO+9YM4TefVeTgFJ1iP61upDXF/9FbkEx4649/8wHhI8pLoa774b//Q+efNJqEdTUuZVSZ4UmAheRkJLF16v3cluPFrSNDKyZkxYVWQPC06ZZM4ReekmTgFJ1kA4WuwBjDOPnbybY15N/9mtbMyctLIRbb4UZM+A//4Gnn66Z8yqlzjptEbiAHzbuY/Xugzw64DyC/Wrgpq6CAhgxwkoCEydqElCqjtMWQT13tKCYl37YQvvGQdzUvfmZnzAvz7pT+IcfrMHhMWPO/JxKKafSRFDPTf5lJymZebw5Ihp3tzPsvz96FIYOhcWLremh991XM0EqpZxKE0E9lnToCJN/2ck1nRpzUeszXAoyNxeuvRaWL4epU611BZRS9YImgnrs5QVbEYGnB7U/sxNlZ8PVV8Nvv8Fnn1mDxEqpekMTQT31x84Mfti4j3/2a0uTBr7VP9Hhw9Y6ArGx8PXXcOONNRekUqpW0ERQDxUVl/DC/M00beDLfZe1rv6JDh6EAQNgwwZrwfmhQ2suSKVUraGJoB76evVetu7P5oNbula/ntCBA9CvH2zZArNnW11DSql6SRNBPXP4SAGv/7SNHq0bclXHRtU7SWqqtbbwzp0wf77VKlBK1VuaCOqZN37aRtbRwurXE0pJsZLA3r3WvQJXXFHzQSqlahVNBPXI1v1ZfLHqb265qAXtGwfZf4LEROvCv38/LFwIvXrVfJBKqVrHoSUmRGSgiPwlIjtE5MlKtgeLyHwRWS8im0VEJ6dXkzGGF+YlEOjjySP9q1FPaM8e6N0b0tPhp580CSjlQhyWCETEHXgfuAroANwkIh0q7PZ/QIIxpjPQB3hdRLwcFVN9tnDTfv7YlcGjA9oS4m/nW7hjh5UEMjNhyRLo0cMxQSqlaiVHtgi6AzuMMbuMMQXAN8CQCvsYIFCszuwA4CBQ5MCY6qW8wmL+/cMW2jUK5GZ76wlt3QqXXWaVj/j5Z4iJcUyQSqlay5GJoCmQWOZ5ku21st4D2gMpwEZgrDGmpOKJROReEYkTkbj09HRHxVtnTVmxi+TDRxl37fl4uNvxT7ppE/TpYy0us2wZREc7LEalVO3lyERQ2ZQVU+H5lcA6oAkQDbwnIieMchpjphhjYowxMeHh4TUfaR2WcvgoHyzfwaALGtGzjR31hDZsgMsvt5aUXL4cOnZ0WIxKqdrNkYkgCWhW5nkU1if/su4CZhnLDmA30M6BMdU7L/+4FWPsrCdUVAQjR4K3N6xYAe30LVfKlTkyEcQC54pIK9sA8EhgXoV99gJ9AUQkEjgP2OXAmOqV1bsPMn99Cvdd1oaoEL+qH/j559Ydw+++C+ec47gAlVJ1gsPuIzDGFInIg8AiwB2YaozZLCL327ZPBiYAn4jIRqyupH8ZYw44Kqb6pLjEMH7eZpoE+zD6sjZVPzAvz1pfuHt3rR2klAIcfEOZMWYBsKDCa5PLPE4BtH5BNUyPTSRhXxbv3tQFXy876glNmmTdOPbpp7rQvFIK0DWL66TMI4W8tmgr3Vs15JpOjat+YFaWtdB8//7WQLFSSqGJoE56c8k2Mo8WMu7aDvbVE3r9dcjIgJdeclxwSqk6RxNBHbMtNZvPV/3NyO7NOb9JcNUPTEuDN96A4cP1pjGlVDmaCOoQYwwvzk/A38udxwacZ9/BL71k3T08YYJjglNK1VmaCOqQxQmprNxxgEf6t6WhPfWE9uyxBolHjYLz7EwgSql6TxNBHWHVE0qgbWQAt/ZoYd/B48dbM4Sef94hsSml6jZNBHXExyt3k3iwGvWENm+Gzz6DMWMgKspxASql6ixNBHXA/sw83l+2gyvPj+SSc8LsO/jZZyEwEJ48YTkIpZQCNBHUCa/8uIWiEsOzV1dczuE0Vq2COXPgiScg1I6CdEopl6KJoJaL//sgc9alcG+v1jRraEc9IWOsVkBkJIwd67gAlVJ1nq5ZXIuVlBjGz0ugUZAPD1xuRz0hgMWL4ZdfrMJyAQGOCVApVS9oi6AW+zY+kY3JmTw1qB1+Xnbk7JISeOopaNkS7r3XYfEppeoHbRHUUplHC3l14V/EtAhhcOcm9h08cyasXWuVm/bSJaCVUqdWpRaBiIwVkSCxfCwia0REq4Y60DtLt3PwSAHjB59vXz2hwkJrptAFF8BNNzkuQKVUvVHVrqFRxpgsrJLR4Vgri73isKhc3I60bD79fQ8juzWjY1M76gkBTJsG27dbJSXc7ShPrZRyWVVNBMc+kg4Cphlj1lP5msTqDBljePH7LfhWp57QkSPwwgtw8cVw9dWOCVApVe9UdYwgXkQWA62Ap0QkEChxXFiua+mWNFZsS+e5azoQGuBt38HvvQcpKfDNN7rojFKqyqqaCP4BRAO7jDFHRKQhVveQqkH5RcVM+CGBcyICuL2nnfWEDh+GV16BQYOgVy/HBKiUqpeq2jXUE/jLGHNYRG4FngUyHReWa5q6cg9/Zxzh+Ws64GlPPSGA116DQ4d00RmllN2qerWZBBwRkc7AE8DfwGcOi8oFpWXl8d7P2+nXPpLebcPtO3jfPnjrLbj5Zujc2TEBKqXqraomgiJjjAGGAG8bY94GAh0Xlut5ZeFWCosNz13T3v6D//1vKCiAF1+s+cCUUvVeVccIskXkKeA2oJeIuAOejgvLtazde4hZa5IZ3acNLUL97Tt4506YMgXuuQfa2FmGQimlqHqLYASQj3U/wX6gKfCaw6JyIVY9oc1EBHrzf5efY/8Jxo0DT0947rmaD04p5RKqlAhsF/8vgWARuQbIM8boGEEN+G5NEuuTMnnyqnYEeNtZ8WP9evjqK3j4YWjc2DEBKqXqvaqWmLgRWA0MB24E/hSRYY4MzBVk5xXy34V/0bV5A4ZGN7X/BM88Aw0aWOsNKKVUNVX1I+gzQDdjTBqAiIQDS4CZjgrMFbz38w4ycvOZemcMbm523gD266/www/WvQMNGjgmQKWUS6jqGIHbsSRgk2HHsaoSu9JzmPrbboZfGEWnKDsv5MZYZaYbN7bWIlZKqTNQ1RbBQhFZBHxtez4CWOCYkFzDhO8T8PFw5/Er29l/8IIF8NtvMHky+NmxaplSSlWiSonAGPO4iNwAXIJVbG6KMWa2QyOrx5ZtTWPZX+k8M6g94YF21hM6tujMOefAqFGOCVAp5VKqPE3FGPMd8J0DY3EJBUUlTPg+gdbh/txxcUv7T/D117Bxo1VYzlNv5VBKnblTJgIRyQZMZZsAY4wJckhU9dhXf/7NrgO5TLurG14edg6zFBRY9wtER8Pw4Y4JUCnlck6ZCIwxWkaiBhlj+OLPvXRp3oDLz4uw/wQffgi7d8OPP4KbjtUrpWqGXk3OojV7D7EjLYebujW3/+DcXJgwAS67DK68suaDU0q5LIcmAhEZKCJ/icgOEXmyku2Pi8g629cmESm2rXVQL02PTcTfy52rO1XjLuC334bUVHj5ZV10RilVoxyWCGyF6d4HrgI6ADeJSIey+xhjXjPGRBtjooGngF+MMQcdFZMz5eQX8f2GfVzTqQn+9paSyMiA//4XhgyBnj0dE6BSymU5skXQHdhhjNlljCkAvsEqY30yN3H8PoV65/v1KRwpKGZE92b2H/zf/0J2tlVuWimlapgjE0FTILHM8yTbaycQET9gIPV4eur0uETOjQigSzM77yJOToZ334XbboOOHR0TnFLKpTkyEVTWkV3ZVFSAa4HfTtYtJCL3ikiciMSlp6fXWIBny7bUbNbuPcyIbs0Qe/v3X3wRiovhhRccE5xSyuU5MhEkAWX7QaKAlJPsO5JTdAsZY6YYY2KMMTHh4XYu41gLTI9NxNNduL5rlH0HbtsGH38Mo0dDy5YOiU0ppRyZCGKBc0WklYh4YV3s51XcSUSCgcuAuQ6MxWnyi4qZvTaZ/h0iaejvZd/Bzz0HPj5WuWmllHIQO6evVJ0xpkhEHgQWAe7AVGPMZhG537Z9sm3X64DFxphcR8XiTEsS0jiYW8AIe+8diI+HGTOsZBBRjZvPlFKqihyWCACMMQuoUKW0TAI49vwT4BNHxuFM0+MSaRLsw6XnhNl34NNPQ2goPPqoYwJTSikbvbPYgZIOHeHX7ekMj2mGuz0LzyxbBosXW8kgONhxASqlFJoIHGpmfBIAw2PsGCQ+tuhMVBQ88ICDIlNKqeMc2jXkyopLDN/GJXHpOWFEhdixeMzcufDnn9ZsIR8fxwWolFI22iJwkN92HCD58FFGdLPjTuLiYqs7qF07uP12xwWnlFJlaIvAQabHJRLi50n/DpFVP+jzz2HLFpg5Ezz0n0YpdXZoi8ABDuYWsHjzfoZ2aYq3h3vVDsrPh3HjICYGrr/esQEqpVQZ+rHTAWavTaaw2NjXLTR5MuzdC1OnaplppdRZpS2CGmaMYUZsIp2bNaBdoyqu5Hmssmi/ftC3r2MDVEqpCjQR1LB1iYf5KzWbkfa0Bt54Aw4cgJdeclxgSil1EpoIatiMuER8Pd25pqqrkKWnw8SJcMMN0K2bY4NTSqlKaCKoQbn5Rcxbl8LVnRoT6ONZtYNefhmOHNFFZ5RSTqOJoAb9sHEfuQXFVe8W2rsX3n8f7rrLundAKaWcQBNBDZoRm0jrcH8ubBFStQPGj7dmCI0b59C4lFLqVDQR1JAdadnE/X2IkVVdhSwhAT79FP7v/6BZNdYxVkqpGqKJoIbMiEvCw82OVciefRb8/a0Cc0op5USaCGpAQVEJs9Yk0bd9BGEB3qc/YPVqmD0bHn8cwuxcp0AppWqYJoIa8PPWVA7kFDCyKquQGQNPPgnh4fDPfzo+OKWUOg0tMVEDpscm0ijIh95tw0+/808/WQvPvPMOBAQ4PjillDoNbRGcoX2ZR/llWzrDLow6/Spk2dlw//3Qpg3ce+/ZCVAppU5DWwRnaGZcEiUGboypwsyfxx+HPXtgxQrwrsJYglJKnQXaIjgDJSWGGfGJXNwmlOahp1mFbNEi+N//rMXoL7307ASolFJVoIngDPyxK4PEg1VYhezQIRg1Cjp0gAkTzk5wSilVRdo1dAamxyYS7OvJlec3OvWODz0Eqakwb56uQ6yUqnW0RVBNh48UsHDzfoZGN8HH8xSrkM2aBV98Yd1AduGFZy9ApZSqIk0E1TRnbTIFRSWMONW9A2lpcN990LUrPPPM2QtOKaXsoImgGowxfBObyAVNg+nQ5CSrkBljJYHsbPjsM/CsYllqpZQ6yzQRVMPG5Ey27s8+9SDxF1/AnDnWOkyVW5MAABeISURBVAPnn3/2glNKKTtpIqiG6bGJ+Hi6MTi6SeU7JCbCmDHWNFEtI6GUquU0EdjpaEEx89alMKhjY4IqW4XMGPjHP6CwED75BNxPMZCslFK1gE4ftdOCjfvIzi86ebfQ//5n1RP64AOrlIRSStVy2iKw0/S4RFqF+dO9VcMTN+7cCY89Bv37WzWFlFKqDtBEYIdd6Tms3n2Q4TFRJ65CVlwMd94JHh7w8cfWEpRKKVUHaNeQHWbEJeHuJgyrbBWyN9+ElSut5Sd16UmlVB2iLYIqKiwuYWZ8EpefF0FEUIUyEZs3WzeMDR0Kt93mnACVUqqaHJoIRGSgiPwlIjtE5MmT7NNHRNaJyGYR+cWR8ZyJZVvTOJCTz8iKg8SFhXD77RAUZA0Ua5eQUqqOcVjXkIi4A+8D/YEkIFZE5hljEsrs0wD4ABhojNkrIhGOiudMzYhLJCLQmz7nVViF7KWXYM0a+O47iKi14Sul1Ek5skXQHdhhjNlljCkAvgGGVNjnZmCWMWYvgDEmzYHxVFtqVh4/b03jhguj8HAv85bFx1t3Dt9yC1x/vfMCVEqpM+DIRNAUSCzzPMn2WlltgRARWS4i8SJye2UnEpF7RSROROLS09MdFO7JzYyvZBWyvDyrSygiAt5996zHpJRSNcWRs4Yq6yw3lfz8C4G+gC/wh4isMsZsK3eQMVOAKQAxMTEVz+FQxhhmxCVyUauGtArzP77huecgIQF+/BFCQs5mSEopVaMc2SJIAsqOrEYBKZXss9AYk2uMOQCsADo7MCa7rdp1kL8zjjCye5lfZeVKeP11awH6gQOdF5xSStUARyaCWOBcEWklIl7ASGBehX3mAr1ExENE/ICLgC0OjMluM+ISCfTx4KqOja0XcnLgjjugZUuYONGpsSmlVE1wWNeQMaZIRB4EFgHuwFRjzGYRud+2fbIxZouILAQ2ACXAR8aYTY6KyV6ZRwtZsHEfw2Oijq9C9sQTsHs3LF8OgYFOjU8ppWqCQ+8sNsYsABZUeG1yheevAa85Mo7qmrcumfyiEkYeW4Vs8WKYNAkeeQR693ZucEopVUP0zuJTmB6XSIfGQXRsGgyHD8OoUdCunTVlVCml6glNBCexKTmTTclZx8tNjx0L+/dby076+jo3OKWUqkGaCE5iRlwiXh5uDI1uai05+dln8PTT0K2bs0NTSqkapYmgEnmFxcxem8xVHRsRnHvYmibapQs8+6yzQ1NKqRqnZagrsXDTfrLzihgR0wzuvw8yM2HpUvDycnZoSilV4zQRVGJ6bCLNG/rRY9UimDULXnkFLrjA2WEpdYLCwkKSkpLIy8tzdiiqlvDx8SEqKgpPz0rWVD8JTQQV/J2Ryx+7MnisRyPc7roeeva0lp9UqhZKSkoiMDCQli1bnrhqnnI5xhgyMjJISkqiVatWVT5OxwgqmBGXiJvAsI9fhvx8a8Uxd3dnh6VUpfLy8ggNDdUkoAAQEUJDQ+1uIWqLoIyi4hK+jUuij28ejb7/zqoqeu65zg5LqVPSJKDKqs7/B00EZfyyLZ207HxG/PAu9O0LDzzg7JCUUsrhtGuojOmxiYQV5HBF0gaYOhXc9O1R6lQOHz7MBx98UK1jBw0axOHDh0+5z/PPP8+SJUuqdX5VdXqls0nLzmNpwn5uWLsIzzffgObNnR2SUrXeqRJBcXHxKY9dsGABDRo0OOU+L774Iv369at2fM5QVFTk7BDspl1DNrMWrqUY4cbQQqvMtFJ1zcMPw7p1NXvO6Gh4662Tbn7yySfZuXMn0dHR9O/fn6uvvpoXXniBxo0bs27dOhISEhg6dCiJiYnk5eUxduxY7r33XgBatmxJXFwcOTk5XHXVVVx66aX8/vvvNG3alLlz5+Lr68udd97JNddcw7Bhw2jZsiV33HEH8+fPp7CwkG+//ZZ27dqRnp7OzTffTEZGBt26dWPhwoXEx8cTFhZWLtbRo0cTGxvL0aNHGTZsGC+88AIAsbGxjB07ltzcXLy9vVm6dCl+fn7861//YtGiRYgI99xzD2PGjCmNOSwsjLi4OB577DGWL1/O+PHjSUlJYc+ePYSFhfHSSy9x2223kZubC8B7773HxRdfDMCrr77K559/jpubG1dddRX33HMPw4cPZ82aNQBs376dkSNHEh8fX7P/lqegiQAwBQXMWLGNbtkZtHnvNdDBN6Wq5JVXXmHTpk2ssyWg5cuXs3r1ajZt2lQ6fXHq1Kk0bNiQo0eP0q1bN2644QZCQ0PLnWf79u18/fXXfPjhh9x4441899133HrrrSf8vLCwMNasWcMHH3zAxIkT+eijj3jhhRe44ooreOqpp1i4cCFTpkypNNb//Oc/NGzYkOLiYvr27cuGDRto164dI0aMYPr06XTr1o2srCx8fX2ZMmUKu3fvZu3atXh4eHDw4MHTvhfx8fGsXLkSX19fjhw5wk8//YSPjw/bt2/npptuIi4ujh9//JE5c+bw559/4ufnx8GDB2nYsCHBwcGsW7eO6Ohopk2bxp133mnnv8SZ0UQAxL70Hrv8z2N0h0Bo1MjZ4ShVPaf45H42de/evdwc9nfeeYfZs2cDkJiYyPbt209IBK1atSI6OhqACy+8kD179lR67uuvv750n1mzZgGwcuXK0vMPHDiQkJMsHTtjxgymTJlCUVER+/btIyEhARGhcePGdLPVEAsKCgJgyZIl3H///Xh4WJfIhg0bnvb3Hjx4ML62gpSFhYU8+OCDrFu3Dnd3d7Zt21Z63rvuugs/P79y57377ruZNm0ab7zxBtOnT2f16tWn/Xk1SRPBmjVMj0smoEMrrv7HYGdHo1Sd5+9/fG3v5cuXs2TJEv744w/8/Pzo06dPpXPcvb29Sx+7u7tz9OjRSs99bD93d/fSvnhjTr+M+e7du5k4cSKxsbGEhIRw5513kpeXhzGm0umWJ3vdw8ODkpISgBN+j7K/95tvvklkZCTr16+npKQEHx+fU573hhtuKG3ZXHjhhSckSkdz7cHi/HyyRt3LD+0u4douUfh5aV5Uyh6BgYFkZ2efdHtmZiYhISH4+fmxdetWVq1aVeMxXHrppcyYMQOAxYsXc+jQoRP2ycrKwt/fn+DgYFJTU/nxxx8BaNeuHSkpKcTGxgKQnZ1NUVERAwYMYPLkyaXJ5ljXUMuWLUv77r/77ruTxpSZmUnjxo1xc3Pj888/Lx04HzBgAFOnTuXIkSPlzuvj48OVV17J6NGjueuuu874PbGXayeCceOYTzh5Ht6MvFRvHFPKXqGhoVxyySV07NiRxx9//ITtAwcOpKioiE6dOvHcc8/Ro0ePGo9h3LhxLF68mK5du/Ljjz/SuHFjAissI9u5c2e6dOnC+eefz6hRo7jkkksA8PLyYvr06YwZM4bOnTvTv39/8vLyuPvuu2nevDmdOnWic+fOfPXVV6U/a+zYsfTq1Qv3U1QceOCBB/j000/p0aMH27ZtK20tDBw4kMGDBxMTE0N0dDQTy6x7fssttyAiDBgwoKbfotOSqjSrapOYmBgTFxd35if6/Xfo1Ysh//yU/Kjm/Di2l96hqeqcLVu20L59e2eH4VT5+fm4u7vj4eHBH3/8wejRo0sHr+uSiRMnkpmZyYQJE874XJX9vxCReGNMTGX7u2ZfSG4u3HEHWzpexHqPEJ6PaaZJQKk6au/evdx4442UlJTg5eXFhx9+6OyQ7Hbdddexc+dOfv75Z6f8fNdMBP/6F+zYwfQP3sMrqYTrujR1dkRKqWo699xzWbt2rbPDOCPHZj05i+uNESxZAu+/T97YfzI7TRhwfiQh/rrgjFLKdblWIsjMhFGjoG1bFt88hsyjhYzspqUklFKuzbW6hh5+GJKT4fffmbEhjagQXy5uc3bn6yqlVG3jOi2CefPgk0/gySdJPPcCVu44wPALm+HmpoPESinX5jqJoHNnGD0axo3j27hERGB4TJSzo1LK5QQEBACQkpLCsGHDKt2nT58+nG6a+FtvvVV6YxZUray1qpzrJIIWLeCDDyj28OTb+CR6nxtOkwa+zo5KKZfVpEkTZs6cWe3jKyaCqpS1rk2MMaXlKpzNtcYIgBXb09mXmcdz13RwdihK1agX5m8mISWrRs/ZoUkQ4649/6Tb//Wvf9GiRQsesK3mN378eAIDA7nvvvsYMmQIhw4dorCwkH//+98MGTKk3LF79uzhmmuuYdOmTRw9epS77rqLhIQE2rdvX67WUGXlo9955x1SUlK4/PLLCQsLY9myZeVKRL/xxhtMnToVsAq6Pfzww+zZs+ek5a7Lmj9/Pv/+978pKCggNDSUL7/8ksjISHJychgzZgxxcXGICOPGjeOGG25g4cKFPP300xQXFxMWFsbSpUsZP348AQEBPPbYYwB07NiR77//HoCrrrqKyy+/nD/++IM5c+bwyiuvVLk89qBBg3j33XdLC/RdcsklTJo0iU6dOp3JP7PrJYIZsYk09PeiX/tIZ4eiVJ03cuRIHn744dJEMGPGDBYuXIiPjw+zZ88mKCiIAwcO0KNHDwYPHnzSGzcnTZqEn58fGzZsYMOGDXTt2rV0W2Xlox966CHeeOMNli1bdsK6A/Hx8UybNo0///wTYwwXXXQRl112GSEhIVUqd33ppZeyatUqRISPPvqIV199lddff50JEyYQHBzMxo0bATh06BDp6encc889rFixglatWlWpXPVff/3FtGnTShf0sac89t13380nn3zCW2+9xbZt28jPzz/jJAAulggO5OTzU0Iqd17cEi8P1+kVU67hVJ/cHaVLly6kpaWRkpJCeno6ISEhNG/enMLCQp5++mlWrFiBm5sbycnJpKam0ugkZd5XrFjBQw89BECnTp3KXdwqKx99qovfypUrue6660rr+1x//fX8+uuvDB48uErlrpOSkhgxYgT79u2joKCgtKT2kiVL+Oabb0r3CwkJYf78+fTu3bt0n6qUq27RokW5mkv2lMcePnw4EyZM4LXXXmPq1Kk1tm6BSyWC2WuSKSoxjOjWzNmhKFVvDBs2jJkzZ7J//35GjhwJwJdffkl6ejrx8fF4enrSsmXLSstPl1VZa+Fk5aNP5VT106pS7nrMmDE88sgjDB48uHT1sWPnrRhjVcpVQ/mS1WXLVdtbHtvPz4/+/fszd+5cZsyYcdoB9apymY/Fxhi+id1L1+YNODcy8PQHKKWqZOTIkXzzzTfMnDmzdBZQZmYmEREReHp6smzZMv7+++9TnqN37958+eWXAGzatIkNGzYAJy8fDScvgd27d2/mzJnDkSNHyM3NZfbs2fTq1avKv09mZiZNm1plZz799NPS1wcMGMB7771X+vzQoUP07NmTX375hd27dwPly1UfW3pyzZo1pdsrsrc8NlhjHg899BDdunWrUgukKlwmEazZe4id6bnaGlCqhp1//vlkZ2fTtGlTGjduDFgllePi4oiJieHLL7+kXbt2pzzH6NGjycnJoVOnTrz66qt0794dOHn5aIB77723dOC1rK5du3LnnXfSvXt3LrroIu6++266dOlS5d9n/PjxDB8+nF69epUbf3j22Wc5dOgQHTt2pHPnzixbtozw8HCmTJnC9ddfT+fOnRkxYgRgLTRz8OBBoqOjmTRpEm3btq30Z9lbHhusLq2goKAaXbfAoWWoRWQg8DbgDnxkjHmlwvY+wFzgWLqcZYx58VTnrG4Z6vi/D/L20h18cEtXArxdqkdM1WNahtr1pKSk0KdPH7Zu3YqbW+Wf5e0tQ+2wFoGIuAPvA1cBHYCbRKSyOZu/GmOibV+nTAJn4sIWDflsVHdNAkqpOuuzzz7joosu4j//+c9Jk0B1OPKq2B3YYYzZBSAi3wBDgAQH/kyllKq3br/9dm6//fYaP68jxwiaAollnifZXquop4isF5EfRaTS+W8icq+IxIlIXHp6uiNiVarOqmurDCrHqs7/B0cmgsruHKkY4RqghTGmM/AuMKeyExljphhjYowxMeHh4TUcplJ1l4+PDxkZGZoMFGAlgYyMDHx8fOw6zpFdQ0lA2Sk6UUBK2R2MMVllHi8QkQ9EJMwYc8CBcSlVb0RFRZGUlIS2lNUxPj4+REXZV1DTkYkgFjhXRFoBycBI4OayO4hIIyDVGGNEpDtWCyXDgTEpVa94enqW3tWqVHU5LBEYY4pE5EFgEdb00anGmM0icr9t+2RgGDBaRIqAo8BIo21cpZQ6qxx6H4EjVPc+AqWUcmVOuY9AKaVU3VDnWgQikg6cunDJyYUBOhB9nL4f5en7cZy+F+XVh/ejhTGm0mmXdS4RnAkRiTtZ08gV6ftRnr4fx+l7UV59fz+0a0gppVycJgKllHJxrpYIpjg7gFpG34/y9P04Tt+L8ur1++FSYwRKKaVO5GotAqWUUhVoIlBKKRfnMolARAaKyF8iskNEnnR2PM4kIs1EZJmIbBGRzSIy1tkxOZuIuIvIWhH53tmxOJuINBCRmSKy1fZ/pKezY3IWEfmn7W9kk4h8LSL2lfWsI1wiEdixWpqrKAIeNca0B3oA/+fi7wfAWGCLs4OoJd4GFhpj2gGdcdH3RUSaAg8BMcaYjlg100Y6NyrHcIlEQJnV0owxBcCx1dJckjFmnzFmje1xNtYfemWLBrkEEYkCrgY+cnYsziYiQUBv4GMAY0yBMeawc6NyKg/AV0Q8AD8qlNKvL1wlEVR1tTSXIyItgS7An86NxKneAp4ASpwdSC3QGkgHptm6yj4SEX9nB+UMxphkYCKwF9gHZBpjFjs3KsdwlURQldXSXI6IBADfAQ+XXSTIlYjINUCaMSbe2bHUEh5AV2CSMaYLkAu45JiaiIRg9Ry0ApoA/iJyq3OjcgxXSQSnXS3N1YiIJ1YS+NIYM8vZ8TjRJcBgEdmD1WV4hYh84dyQnCoJSDLGHGshzsRKDK6oH7DbGJNujCkEZgEXOzkmh3CVRFC6WpqIeGEN+MxzckxOIyKC1Qe8xRjzhrPjcSZjzFPGmChjTEus/xc/G2Pq5ae+qjDG7AcSReQ820t9gQQnhuRMe4EeIuJn+5vpSz0dOHfkUpW1xslWS3NyWM50CXAbsFFE1tlee9oYs8CJManaYwzwpe1D0y7gLifH4xTGmD9FZCawBmum3VrqaakJLTGhlFIuzlW6hpRSSp2EJgKllHJxmgiUUsrFaSJQSikXp4lAKaVcnCYC5bJE5GUR6SMiQ51VkVZElotIvV0UXdUNmgiUK7sIq8bSZcCvTo5FKafRRKBcjoi8JiIbgG7AH8DdwCQReb6SfcNF5DsRibV9XWJ7fbyIfC4iP4vIdhG5x/a62M6/SUQ2isiIMud6wvbaehF5pcyPGS4iq0Vkm4j0su17vu21dSKyQUTOdeBbolycS9xZrFRZxpjHReRbrLurHwGWG2MuOcnubwNvGmNWikhzrLvT29u2dcJaz8EfWCsiPwA9gWisOv5hQKyIrLC9NhS4yBhzREQalvkZHsaY7iIyCBiHVePmfuBtY8yxO3zda+wNUKoCTQTKVXUB1gHtOHUtnX5AB6vUDABBIhJoezzXGHMUOCoiy7DWvbgU+NoYUwykisgvWC2Py4BpxpgjAMaYg2V+xrGif/FAS9vjP4BnbGslzDLGbK/2b6rUaWgiUC5FRKKBT7Aq0B7AWmxEbDWXetou7GW5Vfa6LTFUrM9iqLzkObbXT1bPJd/2vRjb36Qx5isR+RNrwZxFInK3MebnU/92SlWPjhEol2KMWWeMiQa2YS1b+jNwpTEmupIkALAYePDYE1siOWaIiPiISCjQB6vK7QpghG0N5HCs1b5W284zSkT8bOcp2zV0AhFpDewyxryDVSm3U7V+YaWqQBOBcjm2C/QhY0wJ0M4Yc6quoYeAGNuAbQJW3/0xq4EfgFXABGNMCjAb2ACsx0oyTxhj9htjFmJd0ONsrY/HThPmCGCTbd92wGd2/6JKVZFWH1WqGkRkPJBjjJno7FiUOlPaIlBKKRenLQKllHJx2iJQSikXp4lAKaVcnCYCpZRycZoIlFLKxWkiUEopF/f/MDk3dnAASFQAAAAASUVORK5CYII=\n", 246 | "text/plain": [ 247 | "
" 248 | ] 249 | }, 250 | "metadata": { 251 | "needs_background": "light" 252 | }, 253 | "output_type": "display_data" 254 | } 255 | ], 256 | "source": [ 257 | "plt.plot(history.history['accuracy'],'r',label='training accuracy')\n", 258 | "plt.plot(history.history['val_accuracy'],label='validation accuracy')\n", 259 | "plt.xlabel('# epochs')\n", 260 | "plt.ylabel('loss')\n", 261 | "plt.legend()\n", 262 | "plt.show()" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 29, 268 | "metadata": {}, 269 | "outputs": [], 270 | "source": [ 271 | "model = load_model('model-009.model')\n", 272 | "\n", 273 | "face_clsfr=cv2.CascadeClassifier('D:/DS/Face Mask Detection/haarcascade_frontalface_default.xml')\n", 274 | "\n", 275 | "source=cv2.VideoCapture(0)\n", 276 | "\n", 277 | "labels_dict={1:'MASK',0:'NO MASK'}\n", 278 | "color_dict={1:(0,255,0),0:(0,0,255)}" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": 30, 284 | "metadata": {}, 285 | "outputs": [], 286 | "source": [ 287 | "while(True):\n", 288 | "\n", 289 | " ret,img=source.read()\n", 290 | " gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n", 291 | " faces=face_clsfr.detectMultiScale(gray,1.3,5) \n", 292 | "\n", 293 | " for (x,y,w,h) in faces:\n", 294 | " \n", 295 | " face_img=gray[y:y+w,x:x+w]\n", 296 | " resized=cv2.resize(face_img,(100,100))\n", 297 | " normalized=resized/255.0\n", 298 | " reshaped=np.reshape(normalized,(1,100,100,1))\n", 299 | " result=model.predict(reshaped)\n", 300 | "\n", 301 | " label=np.argmax(result,axis=1)[0]\n", 302 | " \n", 303 | " cv2.rectangle(img,(x,y),(x+w,y+h),color_dict[label],2)\n", 304 | " cv2.rectangle(img,(x,y-40),(x+w,y),color_dict[label],-1)\n", 305 | " cv2.putText(img, labels_dict[label], (x, y-10),cv2.FONT_HERSHEY_SIMPLEX,0.8,(255,255,255),2)\n", 306 | " \n", 307 | " \n", 308 | " cv2.imshow('LIVE',img)\n", 309 | " key=cv2.waitKey(1)\n", 310 | " \n", 311 | " if(key==27):\n", 312 | " break\n", 313 | " \n", 314 | "cv2.destroyAllWindows()\n", 315 | "source.release()" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [] 324 | } 325 | ], 326 | "metadata": { 327 | "kernelspec": { 328 | "display_name": "Python 3", 329 | "language": "python", 330 | "name": "python3" 331 | }, 332 | "language_info": { 333 | "codemirror_mode": { 334 | "name": "ipython", 335 | "version": 3 336 | }, 337 | "file_extension": ".py", 338 | "mimetype": "text/x-python", 339 | "name": "python", 340 | "nbconvert_exporter": "python", 341 | "pygments_lexer": "ipython3", 342 | "version": "3.6.10" 343 | } 344 | }, 345 | "nbformat": 4, 346 | "nbformat_minor": 4 347 | } 348 | --------------------------------------------------------------------------------