Image_Data_Preprocessing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "KPtZv60kY022"
      },
      "outputs": [],
      "source": [
        "import cv2\n",
        "import os\n",
        "import numpy as np\n",
        "from keras.utils import to_categorical"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data='/content/drive/MyDrive/dataset'"
      ],
      "metadata": {
        "id": "uPyV3UGgZjtt"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "categories=os.listdir(data)\n",
        "labels=[i for i in range(len(categories))]\n",
        "\n",
        "label_dict=dict(zip(categories,labels))"
      ],
      "metadata": {
        "id": "WkpbTOj5ZrLx"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(label_dict)\n",
        "print(categories)\n",
        "print(labels)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jy-DSvkpaMIm",
        "outputId": "543a2b3a-ab6c-484e-8aae-ef7d7c1cad73"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'without mask': 0, 'with mask': 1}\n",
            "['without mask', 'with mask']\n",
            "[0, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# converting every image to grayscale\n",
        "new_data=[]\n",
        "target=[]\n",
        "\n",
        "for category in categories:\n",
        "  folder=os.path.join(data,category)\n",
        "  img_names=os.listdir(folder)\n",
        "\n",
        "  for img_name in img_names:\n",
        "    img_path=os.path.join(folder,img_name)\n",
        "    img=cv2.imread(img_path)\n",
        "\n",
        "    try:\n",
        "      # rgb_img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #convrt in grayscale\n",
        "      resized_img=cv2.resize(img,(100,100))    #resize resolution\n",
        "      new_data.append(resized_img)                  #put process img into new_data\n",
        "      target.append(label_dict[category])         #put label of img into targt\n",
        "    except Exception as e:\n",
        "      print('Exception',e)\n"
      ],
      "metadata": {
        "id": "DpiDzsz1aUTD"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "#normalizing the data\n",
        "import numpy as np\n",
        "new_data=np.array(new_data)/255.0 #normalize 0 to 1 all pixel\n",
        "new_data=np.reshape(new_data,(new_data.shape[0],100,100,3)) #reshaping 1d with 100,100 pixel size\n",
        "target=np.array(target)"
      ],
      "metadata": {
        "id": "vQLvJ9Y0cBQb"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#converting to categorical\n",
        "from keras.utils import to_categorical\n",
        "new_target=to_categorical(target)"
      ],
      "metadata": {
        "id": "uKvRCt5idey7"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "np.save('data',new_data)\n",
        "np.save('target',new_target)"
      ],
      "metadata": {
        "id": "fhgj7w6deHr0"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data=np.load('data.npy')\n",
        "target=np.load('target.npy')"
      ],
      "metadata": {
        "id": "zTpLWF6Oivce"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "x_train,x_test,y_train,y_test=train_test_split(data,target,test_size=0.2)"
      ],
      "metadata": {
        "id": "fXlVKzjBvLQO"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow import keras\n",
        "import keras\n",
        "from keras.layers import Conv2D,Flatten,MaxPooling2D,Dense,Dropout\n",
        "from keras.models import Sequential\n",
        "\n",
        "# Convolutional layers\n",
        "model=Sequential()\n",
        "model.add(Conv2D(32, (3, 3), input_shape=(100,100,3), activation='relu'))\n",
        "model.add(MaxPooling2D((2, 2),padding='valid'))\n",
        "\n",
        "model.add(Conv2D(64, (3,3), activation='relu'))\n",
        "model.add(MaxPooling2D((2,2),padding='valid'))\n",
        "\n",
        "# model.add(Conv2D(128, (3,3), activation='relu'))\n",
        "# model.add(MaxPooling2D((2,2),padding='valid'))\n",
        "\n",
        "# model.add(Conv2D(, (3, 3), activation='relu'))\n",
        "# model.add(MaxPooling2D((2, 2)))\n",
        "\n",
        "# Flatten and fully connected layers\n",
        "model.add(Flatten())\n",
        "model.add(Dropout(0.5))\n",
        "model.add(Dense(2, activation='softmax',kernel_regularizer='l1',))"
      ],
      "metadata": {
        "id": "pwRpnklvpns2"
      },
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hQnzsTgyraYj",
        "outputId": "5f2a8251-6f3c-4d7d-811e-21720f95bc86"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d_6 (Conv2D)           (None, 98, 98, 32)        896       \n",
            "                                                                 \n",
            " max_pooling2d_6 (MaxPoolin  (None, 49, 49, 32)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_7 (Conv2D)           (None, 47, 47, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_7 (MaxPoolin  (None, 23, 23, 64)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten_3 (Flatten)         (None, 33856)             0         \n",
            "                                                                 \n",
            " dropout_3 (Dropout)         (None, 33856)             0         \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 2)                 67714     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 87106 (340.26 KB)\n",
            "Trainable params: 87106 (340.26 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile( optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "_0n0euyxzqfJ"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "from keras.callbacks import ModelCheckpoint\n",
        "checkpoint = ModelCheckpoint('model-{epoch:03d}.model',monitor='val_loss',verbose=0,save_best_only=True,mode='auto')\n",
        "history=model.fit(x_train,y_train,epochs=20,callbacks=[checkpoint],validation_split=0.2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8aGSeM2REA-F",
        "outputId": "4a8df169-e9d8-4a27-b9f4-5f2d02c24d61"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "4/4 [==============================] - 2s 295ms/step - loss: 4.4888 - accuracy: 0.8776 - val_loss: 3.5159 - val_accuracy: 0.9600\n",
            "Epoch 2/20\n",
            "4/4 [==============================] - 1s 235ms/step - loss: 3.0834 - accuracy: 0.9694 - val_loss: 2.3309 - val_accuracy: 0.9600\n",
            "Epoch 3/20\n",
            "4/4 [==============================] - 1s 228ms/step - loss: 2.0112 - accuracy: 0.9694 - val_loss: 1.6537 - val_accuracy: 0.9600\n",
            "Epoch 4/20\n",
            "4/4 [==============================] - 1s 237ms/step - loss: 1.5221 - accuracy: 0.9694 - val_loss: 1.4313 - val_accuracy: 0.9600\n",
            "Epoch 5/20\n",
            "4/4 [==============================] - 1s 231ms/step - loss: 1.2931 - accuracy: 0.9694 - val_loss: 1.1495 - val_accuracy: 0.9600\n",
            "Epoch 6/20\n",
            "4/4 [==============================] - 1s 227ms/step - loss: 1.0003 - accuracy: 0.9694 - val_loss: 0.9173 - val_accuracy: 0.9600\n",
            "Epoch 7/20\n",
            "4/4 [==============================] - 1s 311ms/step - loss: 0.7964 - accuracy: 0.9694 - val_loss: 0.7745 - val_accuracy: 0.9600\n",
            "Epoch 8/20\n",
            "4/4 [==============================] - 1s 352ms/step - loss: 0.6577 - accuracy: 0.9694 - val_loss: 0.6407 - val_accuracy: 0.9600\n",
            "Epoch 9/20\n",
            "4/4 [==============================] - 1s 490ms/step - loss: 0.5414 - accuracy: 0.9694 - val_loss: 0.5603 - val_accuracy: 0.9600\n",
            "Epoch 10/20\n",
            "4/4 [==============================] - 1s 332ms/step - loss: 0.4694 - accuracy: 0.9694 - val_loss: 0.5141 - val_accuracy: 0.9600\n",
            "Epoch 11/20\n",
            "4/4 [==============================] - 1s 229ms/step - loss: 0.4162 - accuracy: 0.9694 - val_loss: 0.4450 - val_accuracy: 0.9600\n",
            "Epoch 12/20\n",
            "4/4 [==============================] - 1s 237ms/step - loss: 0.3626 - accuracy: 0.9694 - val_loss: 0.4400 - val_accuracy: 0.9600\n",
            "Epoch 13/20\n",
            "4/4 [==============================] - 1s 232ms/step - loss: 0.3429 - accuracy: 0.9694 - val_loss: 0.4050 - val_accuracy: 0.9600\n",
            "Epoch 14/20\n",
            "4/4 [==============================] - 1s 231ms/step - loss: 0.3235 - accuracy: 0.9694 - val_loss: 0.3874 - val_accuracy: 0.9600\n",
            "Epoch 15/20\n",
            "4/4 [==============================] - 0s 19ms/step - loss: 0.3032 - accuracy: 0.9694 - val_loss: 0.4028 - val_accuracy: 0.9600\n",
            "Epoch 16/20\n",
            "4/4 [==============================] - 1s 230ms/step - loss: 0.2976 - accuracy: 0.9694 - val_loss: 0.3787 - val_accuracy: 0.9600\n",
            "Epoch 17/20\n",
            "4/4 [==============================] - 0s 19ms/step - loss: 0.2961 - accuracy: 0.9694 - val_loss: 0.4689 - val_accuracy: 0.9600\n",
            "Epoch 18/20\n",
            "4/4 [==============================] - 0s 18ms/step - loss: 0.3238 - accuracy: 0.9694 - val_loss: 0.4002 - val_accuracy: 0.9600\n",
            "Epoch 19/20\n",
            "4/4 [==============================] - 0s 20ms/step - loss: 0.2802 - accuracy: 0.9694 - val_loss: 0.3975 - val_accuracy: 0.9600\n",
            "Epoch 20/20\n",
            "4/4 [==============================] - 0s 18ms/step - loss: 0.2794 - accuracy: 0.9694 - val_loss: 0.3932 - val_accuracy: 0.9600\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import matplotlib.pyplot as plt\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "U2EBOGpQVXX5",
        "outputId": "2c2d4d89-85a9-4906-f2b6-0c36281ade3d"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fd5dde57190>]"
            ]
          },
          "metadata": {},
          "execution_count": 42
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAsSUlEQVR4nO3de3RU5aH38d/kOgGSiQoEEyK3hVIVg+WSBfS0PTUvUXwtWk9FyymYVlps0NqcU4UaLgffmva0zcIiB+hZRSnUiucF8azaxoWp0KIIleCplopYeIFGEsBFJjEh19nvHzA7puQye2ZfJuH7WWvWMjvP3vPsbGbNz+fqMwzDEAAAQBxL8LoCAAAAfSGwAACAuEdgAQAAcY/AAgAA4h6BBQAAxD0CCwAAiHsEFgAAEPcILAAAIO4leV0Bu4RCIX344YdKT0+Xz+fzujoAACAChmGooaFB2dnZSkjouR1lwASWDz/8ULm5uV5XAwAAROHkyZMaOXJkj78fMIElPT1d0oUbzsjI8Lg2AAAgEvX19crNzTW/x3syYAJLuBsoIyODwAIAQD/T13AOBt0CAIC4R2ABAABxj8ACAADiHoEFAADEPQILAACIewQWAAAQ9wgsAAAg7hFYAABA3COwAACAuEdgAQAAcY/AAgAA4h6BBQAAxL0Bs/lhf/Wr/Sf0fm2D19UAAKBPJf/rWqX7kz15bwKLh/7f2UYt3f6O19UAACAiD35+HIHlclRb3yxJunJwiu6blutxbQAA6N2gFO9iA4HFQ3Xn2yRJo68apO8WTvC4NgAAxC8G3Xoo2HQhsGQOSvG4JgAAxDcCi4fONbVKkjLTvOkPBACgvyCweCjcJRQYRGABAKA3BBYP1V3sErqCLiEAAHpFYPFQ8PzFLiFaWAAA6BWBxUPhFpYAY1gAAOgVgcVDdcwSAgAgIgQWDwUvDrpllhAAAL0jsHiorokxLAAARILA4pHW9pAaWzskSZlpdAkBANAbAotHwt1BPp+U7meHBAAAekNg8Uh4SnMgLVkJCT6PawMAQHwjsHjEnCHEgFsAAPpEYPHIufAaLExpBgCgTwQWj9Sx8SEAABEjsHjEXIOFKc0AAPSJwOIRNj4EACByBBaP1H1ilhAAAOgdgcUjnfsIEVgAAOgLgcUjjGEBACByBBaPdK7DwhgWAAD6QmDxiDmGhRYWAAD6RGDxCCvdAgAQOQKLB9o7QmpobpckZTKtGQCAPhFYPFB/MaxIUgY7NQMA0CcCiwfOXVyWP92fpKREHgEAAH3h29IDrMECAIA1BBYPBM+HNz5k/AoAAJGIKrCsXbtWo0ePlt/vV35+vvbv399j2ba2Nq1atUrjxo2T3+9XXl6eKioqLilXXV2tf/7nf9ZVV12ltLQ0TZw4UW+99VY01Yt7tLAAAGCN5cCydetWlZSUaMWKFaqqqlJeXp4KCwt1+vTpbsuXlpZqw4YNWrNmjQ4dOqRFixbprrvu0sGDB80y586d08yZM5WcnKzf/va3OnTokH7yk5/oiiuuiP7O4lhnYKGFBQCASPgMwzCsnJCfn6+pU6fq6aefliSFQiHl5ubqoYce0pIlSy4pn52drccff1zFxcXmsbvvvltpaWnasmWLJGnJkiV6/fXX9Yc//CHqG6mvr1cgEFAwGFRGRkbU1+nCMKS2Jnuu9Qk//d0HWrfrA9039Rotv+N6268PAIAjkgdJPp+tl4z0+9vSnNrW1lYdOHBAS5cuNY8lJCSooKBAe/fu7faclpYW+f3+LsfS0tK0Z88e8+f//u//VmFhob785S9r9+7dysnJ0be+9S0tXLiwx7q0tLSopaXF/Lm+vt7KrUSmrUl6Mtv2yz4s6WG/pHcuvgAA6A++96GUMtiTt7bUJXT27Fl1dHQoKyury/GsrCzV1NR0e05hYaHKy8t15MgRhUIh7dy5U9u3b9epU6fMMkePHtW6des0fvx4vfLKK3rwwQf18MMPa9OmTT3WpaysTIFAwHzl5uZauRUAANCPOL5q2VNPPaWFCxdqwoQJ8vl8GjdunIqKirRx40azTCgU0pQpU/Tkk09Kkm6++Wa9++67Wr9+vRYsWNDtdZcuXaqSkhLz5/r6evtDS/KgC2nSZgt/8Zb2fHBWT941UXfdnGP79QEAcETyIM/e2lJgGTp0qBITE1VbW9vleG1trUaMGNHtOcOGDdOOHTvU3Nysjz76SNnZ2VqyZInGjh1rlrn66qt1/fVdx3J86lOf0rZt23qsS2pqqlJTU61U3zqfz5Gmr9MtSTovv9LTA541rQEA0J9Y6hJKSUnR5MmTVVlZaR4LhUKqrKzU9OnTez3X7/crJydH7e3t2rZtm+bMmWP+bubMmTp8+HCX8u+//75GjRplpXr9RvDiSrdMawYAIDKWu4RKSkq0YMECTZkyRdOmTdPq1avV2NiooqIiSdL8+fOVk5OjsrIySdK+fftUXV2tSZMmqbq6WitXrlQoFNKjjz5qXvM73/mOZsyYoSeffFL33HOP9u/fr5/97Gf62c9+ZtNtxpe686zDAgCAFZYDy9y5c3XmzBktX75cNTU1mjRpkioqKsyBuCdOnFBCQmfDTXNzs0pLS3X06FENGTJEs2fP1ubNm5WZmWmWmTp1ql588UUtXbpUq1at0pgxY7R69WrNmzcv9juMM6GQoeDFwBJgpVsAACJieR2WeOXIOiwOqGtq1aRVOyVJ7/+f25SSxO4IAIDLV6Tf33xbuiy8yu3glETCCgAAEeIb02Wd41foDgIAIFIEFpfVMUMIAADLCCwuCzJDCAAAywgsLjN3amaGEAAAESOwuCwcWAK0sAAAEDECi8vqzl8cw5JGYAEAIFIEFpcFmxjDAgCAVQQWl5nTmhnDAgBAxAgsLgtPa2YMCwAAkSOwuKyzhYXAAgBApAgsLjOnNbPSLQAAESOwuCgUMljpFgCAKBBYXPRxa7tCF/fGDtAlBABAxAgsLgpPafYnJ8ifnOhxbQAA6D8ILC4Kj1+5gvErAABYQmBxUXiVW7qDAACwhsDiojpWuQUAICoEFhexyi0AANEhsLgoyJRmAACiQmBxUbhLiGX5AQCwhsDiIrqEAACIDoHFRQy6BQAgOgQWFwUvTmtm40MAAKwhsLjoHGNYAACICoHFRWaXEGNYAACwhMDiEsMwOruEaGEBAMASAotLmlo71NZxYatm9hICAMAaAotLwlOaU5IS5E/mzw4AgBV8c7qkrqlzhpDP5/O4NgAA9C8EFpcEWYMFAICoEVhcwiq3AABEj8DiEvYRAgAgegQWl9Sxyi0AAFEjsLiEMSwAAESPwOKSzo0PGcMCAIBVBBaXnLs4rTlAlxAAAJYRWFxizhKiSwgAAMsILC4JsvEhAABRI7C4pI6NDwEAiBqBxSV1zBICACBqBBYXNLd1qKU9JIlZQgAARIPA4oJw60pSgk+DUxI9rg0AAP0PgcUFnxy/wk7NAABYR2BxgbmPEGuwAAAQFQKLC1jlFgCA2BBYXBBk40MAAGJCYHGB2SXElGYAAKJCYHHBOVa5BQAgJgQWFwRZ5RYAgJgQWFzAKrcAAMSGwOICpjUDABAbAosL6s5fCCxXMK0ZAICoEFhcEGxiDAsAALEgsLgg3MLCLCEAAKJDYHFYS3uHmlo7JLEOCwAA0SKwOCx4sXUlwSelpyZ5XBsAAPonAovDgp+YIZSQwE7NAABEg8DiMHP8CjOEAACIGoHFYazBAgBA7AgsDqtjSjMAADEjsDjMXJafFhYAAKIWVWBZu3atRo8eLb/fr/z8fO3fv7/Hsm1tbVq1apXGjRsnv9+vvLw8VVRU9Fj+Bz/4gXw+nx555JFoqhZ36syNDxnDAgBAtCwHlq1bt6qkpEQrVqxQVVWV8vLyVFhYqNOnT3dbvrS0VBs2bNCaNWt06NAhLVq0SHfddZcOHjx4Sdk//vGP2rBhg2666SbrdxKnGMMCAEDsLAeW8vJyLVy4UEVFRbr++uu1fv16DRo0SBs3buy2/ObNm/W9731Ps2fP1tixY/Xggw9q9uzZ+slPftKl3Mcff6x58+bpP//zP3XFFVdEdzdxqHOWEIEFAIBoWQosra2tOnDggAoKCjovkJCggoIC7d27t9tzWlpa5Pf7uxxLS0vTnj17uhwrLi7W7bff3uXavWlpaVF9fX2XVzwKr8PCxocAAETPUmA5e/asOjo6lJWV1eV4VlaWampquj2nsLBQ5eXlOnLkiEKhkHbu3Knt27fr1KlTZpnnn39eVVVVKisri7guZWVlCgQC5is3N9fKrbgmPIaFZfkBAIie47OEnnrqKY0fP14TJkxQSkqKFi9erKKiIiUkXHjrkydP6tvf/rZ++ctfXtIS05ulS5cqGAyar5MnTzp1CzFhlhAAALGzFFiGDh2qxMRE1dbWdjleW1urESNGdHvOsGHDtGPHDjU2Nur48eN67733NGTIEI0dO1aSdODAAZ0+fVqf/vSnlZSUpKSkJO3evVs//elPlZSUpI6Ojm6vm5qaqoyMjC6veBTuEmKWEAAA0bMUWFJSUjR58mRVVlaax0KhkCorKzV9+vRez/X7/crJyVF7e7u2bdumOXPmSJJuueUWvfPOO3r77bfN15QpUzRv3jy9/fbbSkxMjOK24kNbR0gNLe2SaGEBACAWlrcPLikp0YIFCzRlyhRNmzZNq1evVmNjo4qKiiRJ8+fPV05OjjkeZd++faqurtakSZNUXV2tlStXKhQK6dFHH5Ukpaen68Ybb+zyHoMHD9ZVV111yfH+pv7iDCFJyiCwAAAQNcuBZe7cuTpz5oyWL1+umpoaTZo0SRUVFeZA3BMnTpjjUySpublZpaWlOnr0qIYMGaLZs2dr8+bNyszMtO0m4lV4SnOGP0mJ7NQMAEDUfIZhGF5Xwg719fUKBAIKBoNxM57lwPFzunvdG7rmykH6/aP/6HV1AACIO5F+f7OXkIPY+BAAAHsQWBzEsvwAANiDwOKgzmX5mdIMAEAsCCwOCoa7hGhhAQAgJgQWB7HxIQAA9iCwOKiOVW4BALAFgcVBZgsLXUIAAMSEwOKgINOaAQCwBYHFQYxhAQDAHgQWB3Wuw8IYFgAAYkFgcUhHyFB9My0sAADYgcDikIbmNoV3aWKlWwAAYkNgcci5i91BQ1KTlJzInxkAgFjwTeqQ8MaHtK4AABA7AotDmCEEAIB9CCwOCTYRWAAAsAuBxSF15saHTGkGACBWBBaH0CUEAIB9CCwOqaNLCAAA2xBYHBI0Nz6kSwgAgFgRWBxiTmumhQUAgJgRWBxijmFhHRYAAGJGYHFI57RmuoQAAIgVgcUhzBICAMA+BBYHhELGJ9ZhIbAAABArAosDGlraFbq4U3MGgQUAgJgRWBwQHr+Slpwof3Kix7UBAKD/I7A4oO78xe4gxq8AAGALAosDwqvcBugOAgDAFgQWBzBDCAAAexFYHBC8OEPoCtZgAQDAFgQWB7DxIQAA9iKwOCDcJRRg40MAAGxBYHEALSwAANiLwOKA4HlWuQUAwE4EFgfQwgIAgL0ILA5gDAsAAPYisDjA3PiQFhYAAGxBYLGZYRh0CQEAYDMCi80aWzvUfnGr5ky6hAAAsAWBxWbh7qCUpAT5k/nzAgBgB75RbWZ2B6Uly+fzeVwbAAAGBgKLzYIXZwixjxAAAPYhsNgs3MISYMAtAAC2IbDYrI5VbgEAsB2BxWZMaQYAwH4EFpuFx7BkMoYFAADbEFhsFp7WHKBLCAAA2xBYbEaXEAAA9iOw2KxzHRa6hAAAsAuBxWbmLCFaWAAAsA2BxWbmOiyMYQEAwDYEFhsZhqG684xhAQDAbgQWGzW3hdTaHpLEtGYAAOxEYLFRePxKUoJPg1MSPa4NAAADB4HFRp1TmlPYqRkAABsRWGzEGiwAADiDwGKjIBsfAgDgCAKLjWhhAQDAGQQWG4WnNAdY5RYAAFsRWGxECwsAAM4gsNiIMSwAADgjqsCydu1ajR49Wn6/X/n5+dq/f3+PZdva2rRq1SqNGzdOfr9feXl5qqio6FKmrKxMU6dOVXp6uoYPH64777xThw8fjqZqnjrXSAsLAABOsBxYtm7dqpKSEq1YsUJVVVXKy8tTYWGhTp8+3W350tJSbdiwQWvWrNGhQ4e0aNEi3XXXXTp48KBZZvfu3SouLtabb76pnTt3qq2tTbNmzVJjY2P0d+aB8MJxAVa5BQDAVj7DMAwrJ+Tn52vq1Kl6+umnJUmhUEi5ubl66KGHtGTJkkvKZ2dn6/HHH1dxcbF57O6771ZaWpq2bNnS7XucOXNGw4cP1+7du/XZz342onrV19crEAgoGAwqIyPDyi3Z5tbVv9d7NQ36xdem6bPXDvOkDgAA9CeRfn9bamFpbW3VgQMHVFBQ0HmBhAQVFBRo79693Z7T0tIiv9/f5VhaWpr27NnT4/sEg0FJ0pVXXtljmZaWFtXX13d5eS3IxocAADjCUmA5e/asOjo6lJWV1eV4VlaWampquj2nsLBQ5eXlOnLkiEKhkHbu3Knt27fr1KlT3ZYPhUJ65JFHNHPmTN1444091qWsrEyBQMB85ebmWrkVR5izhJjWDACArRyfJfTUU09p/PjxmjBhglJSUrR48WIVFRUpIaH7ty4uLta7776r559/vtfrLl26VMFg0HydPHnSiepHrLmtQ+fbOiRJmYNpYQEAwE6WAsvQoUOVmJio2traLsdra2s1YsSIbs8ZNmyYduzYocbGRh0/flzvvfeehgwZorFjx15SdvHixfr1r3+t1157TSNHjuy1LqmpqcrIyOjy8lL9xe6gxASf0lOTPK0LAAADjaXAkpKSosmTJ6uystI8FgqFVFlZqenTp/d6rt/vV05Ojtrb27Vt2zbNmTPH/J1hGFq8eLFefPFF/e53v9OYMWMs3ob3Ole5TWanZgAAbGa5KaCkpEQLFizQlClTNG3aNK1evVqNjY0qKiqSJM2fP185OTkqKyuTJO3bt0/V1dWaNGmSqqurtXLlSoVCIT366KPmNYuLi/Xcc8/ppZdeUnp6ujkeJhAIKC0tzY77dFzn+BW6gwAAsJvlwDJ37lydOXNGy5cvV01NjSZNmqSKigpzIO6JEye6jE9pbm5WaWmpjh49qiFDhmj27NnavHmzMjMzzTLr1q2TJH3+85/v8l7PPPOM7r//fut35YG6pvAaLAQWAADsZnkdlnjl9TosL7x1Uo/+3z/pH68bpmeKprn+/gAA9EeOrMOCngXNjQ+Z0gwAgN0ILDY5F+4SYgwLAAC2I7DYpI5VbgEAcAyBxSZBZgkBAOAYAotNwjs1M4YFAAD7EVhsEl6HhWnNAADYj8BiExaOAwDAOQQWmwQvDrq9gi4hAABsR2CxQVtHSB+3tEtilhAAAE4gsNgg3Lri80npfgILAAB2I7DYIDx+JcOfrMQEdmoGAMBuBBYbBM0pzbSuAADgBAKLDZghBACAswgsNjhnrsHCDCEAAJxAYLFB3cWND2lhAQDAGQQWGwTZ+BAAAEcRWGzAGBYAAJxFYLFB3XnGsAAA4CQCiw0YwwIAgLMILDZgDAsAAM4isNjAHMNClxAAAI4gsNjA7BKihQUAAEcQWGLUETJU33xxp2bGsAAA4AgCS4zqL45fkaQAgQUAAEcQWGIUntKcnpqkpET+nAAAOIFv2BiFx68EGL8CAIBjCCwx6pwhRGABAMApBJYY1Z0PLxrHlGYAAJxCYIlRuIWFLiEAAJxDYIkRGx8CAOA8AkuMWJYfAADnEVhi1LnxIWNYAABwCoElRnW0sAAA4DgCS4zY+BAAAOcRWGLEGBYAAJxHYIlR5xgWAgsAAE4hsMQgFDLMFhbWYQEAwDkElhg0tLQrZFz4b3ZqBgDAOQSWGIS7gwalJCo1KdHj2gAAMHARWGLAKrcAALiDwBKDOnP8ClOaAQBwEoElBswQAgDAHQSWGLAGCwAA7iCwxKBzlVsCCwAATiKwxCAcWAJsfAgAgKMILDGoO39hDMsVtLAAAOAoAksMgnQJAQDgCgJLDMxpzXQJAQDgKAJLDMxpzbSwAADgKAJLDJjWDACAOwgsUTIM4xNL89MlBACAkwgsUfq4pV3tF7dqpoUFAABnEViiFG5dSU1KkD+ZnZoBAHASgSVKjF8BAMA9BJYoMX4FAAD3EFiiFF7lNkALCwAAjiOwRKmzhYXAAgCA0wgsUQqPYbliEF1CAAA4jcASJVa5BQDAPQSWKIW7hBjDAgCA8wgsUQpvfMgsIQAAnEdgiVKwiXVYAABwS1SBZe3atRo9erT8fr/y8/O1f//+Hsu2tbVp1apVGjdunPx+v/Ly8lRRURHTNeNBeFozs4QAAHCe5cCydetWlZSUaMWKFaqqqlJeXp4KCwt1+vTpbsuXlpZqw4YNWrNmjQ4dOqRFixbprrvu0sGDB6O+Zjw4xxgWAABc4zMMw7ByQn5+vqZOnaqnn35akhQKhZSbm6uHHnpIS5YsuaR8dna2Hn/8cRUXF5vH7r77bqWlpWnLli1RXbM79fX1CgQCCgaDysjIsHJLlhmGoetKK9TaEdLrS76gnMw0R98PAICBKtLvb0stLK2trTpw4IAKCgo6L5CQoIKCAu3du7fbc1paWuT3+7scS0tL0549e6K+Zvi69fX1XV5uOd/WodaOkCS6hAAAcIOlwHL27Fl1dHQoKyury/GsrCzV1NR0e05hYaHKy8t15MgRhUIh7dy5U9u3b9epU6eivqYklZWVKRAImK/c3FwrtxKT8JTm5ESfBqWwUzMAAE5zfJbQU089pfHjx2vChAlKSUnR4sWLVVRUpISE2N566dKlCgaD5uvkyZM21bhv5hosaSny+XyuvS8AAJcrS6lh6NChSkxMVG1tbZfjtbW1GjFiRLfnDBs2TDt27FBjY6OOHz+u9957T0OGDNHYsWOjvqYkpaamKiMjo8vLLeYMIQbcAgDgCkuBJSUlRZMnT1ZlZaV5LBQKqbKyUtOnT+/1XL/fr5ycHLW3t2vbtm2aM2dOzNf0SpCNDwEAcFWS1RNKSkq0YMECTZkyRdOmTdPq1avV2NiooqIiSdL8+fOVk5OjsrIySdK+fftUXV2tSZMmqbq6WitXrlQoFNKjjz4a8TXjjbnKLRsfAgDgCsuBZe7cuTpz5oyWL1+umpoaTZo0SRUVFeag2RMnTnQZn9Lc3KzS0lIdPXpUQ4YM0ezZs7V582ZlZmZGfM14U8cqtwAAuMryOizxys11WMp++xdt2H1UD3xmjEr/9/WOvhcAAAOZI+uw4AL2EQIAwF0EliiY05oZwwIAgCsILFE418TGhwAAuInAEoXgebqEAABwE4ElCuYsoTS6hAAAcAOBJQqsdAsAgLsILBY1t3Woue3CTs0BAgsAAK4gsFgUHr+SmOBTeqrldfcAAEAUCCwWde7UnMxOzQAAuITAYlFdE+NXAABwG4HFInPjQ9ZgAQDANQQWizqX5WdKMwAAbiGwWGROaaaFBQAA1xBYLOrcR4jAAgCAWwgsFp1jlVsAAFxHYLEoyCq3AAC4jsBikbmPEIEFAADXEFgs+uTCcQAAwB0EFovCS/MzrRkAAPcQWCwyV7qlhQUAANcQWCxobQ+psbVDEmNYAABwE4HFgnB3kM8npfsJLAAAuIXAYkF4SnMgLVmJCezUDACAWwgsFphTmhm/AgCAqwgsFnQuy88MIQAA3ERgsaDuPC0sAAB4gcBigTmlmRlCAAC4isBiAWNYAADwBoHFgrrwLCHGsAAA4CoCiwW0sAAA4A0CiwWd+wgRWAAAcBOBxQKzhYXAAgCAqwgsFphjWNIYwwIAgJsILBbQwgIAgDcILBFq7wipobldEoNuAQBwG4ElQvUXw4p0YfNDAADgHgJLhMKr3Kb7k5SUyJ8NAAA38c0boTqmNAMA4BkCS4SC5qJxzBACAMBtBJYInWPjQwAAPENgiVB4SjMDbgEAcB+BJUKMYQEAwDsElggFw11CjGEBAMB1BJYI0cICAIB3CCwRYgwLAADeIbBEqLOFhS4hAADcRmCJUJBpzQAAeIbAEqFwC8sVBBYAAFxHYIlAKGQoeD48hoUuIQAA3EZgiUBDc7sM48J/M+gWAAD3EVgiUHf+wviVwSmJSkniTwYAgNv49o3AuSZmCAEA4CUCSwTqLs4QojsIAABvEFgiEGSVWwAAPEVgiUBdE4EFAAAvEVgi0LksP2NYAADwAoElAuFZQrSwAADgDQJLBILhLiEG3QIA4AkCSwTqGHQLAICnCCwR6JzWzBgWAAC8QGCJABsfAgDgLQJLBIKsdAsAgKeiCixr167V6NGj5ff7lZ+fr/379/dafvXq1bruuuuUlpam3Nxcfec731Fzc7P5+46ODi1btkxjxoxRWlqaxo0bpyeeeEJGeMdBDxmGwRgWAAA8lmT1hK1bt6qkpETr169Xfn6+Vq9ercLCQh0+fFjDhw+/pPxzzz2nJUuWaOPGjZoxY4bef/993X///fL5fCovL5ck/fCHP9S6deu0adMm3XDDDXrrrbdUVFSkQCCghx9+OPa7jMHHLe3qCF0ITizNDwCANyy3sJSXl2vhwoUqKirS9ddfr/Xr12vQoEHauHFjt+XfeOMNzZw5U1/5ylc0evRozZo1S/fdd1+XVpk33nhDc+bM0e23367Ro0frn/7pnzRr1qw+W27cEF40zp+cIH9yose1AQDg8mQpsLS2turAgQMqKCjovEBCggoKCrR3795uz5kxY4YOHDhgho+jR4/qN7/5jWbPnt2lTGVlpd5//31J0v/8z/9oz549uu222yzfkN3MZfmZIQQAgGcsdQmdPXtWHR0dysrK6nI8KytL7733XrfnfOUrX9HZs2f1mc98RoZhqL29XYsWLdL3vvc9s8ySJUtUX1+vCRMmKDExUR0dHfr+97+vefPm9ViXlpYWtbS0mD/X19dbuZWIscotAADec3yW0K5du/Tkk0/qP/7jP1RVVaXt27fr5Zdf1hNPPGGWeeGFF/TLX/5Szz33nKqqqrRp0yb9+Mc/1qZNm3q8bllZmQKBgPnKzc11pP6d+wgRWAAA8IqlFpahQ4cqMTFRtbW1XY7X1tZqxIgR3Z6zbNkyffWrX9UDDzwgSZo4caIaGxv1jW98Q48//rgSEhL03e9+V0uWLNG9995rljl+/LjKysq0YMGCbq+7dOlSlZSUmD/X19c7ElqYIQQAgPcstbCkpKRo8uTJqqysNI+FQiFVVlZq+vTp3Z7T1NSkhISub5OYeGHwanjack9lQqFQj3VJTU1VRkZGl5cTghdXuWUMCwAA3rE8rbmkpEQLFizQlClTNG3aNK1evVqNjY0qKiqSJM2fP185OTkqKyuTJN1xxx0qLy/XzTffrPz8fH3wwQdatmyZ7rjjDjO43HHHHfr+97+va665RjfccIMOHjyo8vJyfe1rX7PxVqNjDrqlhQUAAM9YDixz587VmTNntHz5ctXU1GjSpEmqqKgwB+KeOHGiS2tJaWmpfD6fSktLVV1drWHDhpkBJWzNmjVatmyZvvWtb+n06dPKzs7WN7/5TS1fvtyGW4xNuEsoQGABAMAzPiMelpO1QX19vQKBgILBoK3dQw9sekuv/qVWZV+aqPumXWPbdQEAQOTf3+wl1IdgeFozs4QAAPAMgaUP5rRmuoQAAPAMgaUP5rRmZgkBAOAZy4NuLzcPfGaMzn7cohEBv9dVAQDgskVg6cM3PzfO6yoAAHDZo0sIAADEPQILAACIewQWAAAQ9wgsAAAg7hFYAABA3COwAACAuEdgAQAAcY/AAgAA4h6BBQAAxD0CCwAAiHsEFgAAEPcILAAAIO4RWAAAQNwbMLs1G4YhSaqvr/e4JgAAIFLh7+3w93hPBkxgaWhokCTl5uZ6XBMAAGBVQ0ODAoFAj7/3GX1Fmn4iFArpww8/VHp6unw+n23Xra+vV25urk6ePKmMjAzbrhuPLqd7lS6v++VeB67L6X6514HJMAw1NDQoOztbCQk9j1QZMC0sCQkJGjlypGPXz8jIGPD/aMIup3uVLq/75V4HrsvpfrnXgae3lpUwBt0CAIC4R2ABAABxj8DSh9TUVK1YsUKpqaleV8Vxl9O9SpfX/XKvA9fldL/c6+VtwAy6BQAAAxctLAAAIO4RWAAAQNwjsAAAgLhHYAEAAHGPwCJp7dq1Gj16tPx+v/Lz87V///5ey//Xf/2XJkyYIL/fr4kTJ+o3v/mNSzWNTVlZmaZOnar09HQNHz5cd955pw4fPtzrOc8++6x8Pl+Xl9/vd6nG0Vu5cuUl9Z4wYUKv5/TX5zp69OhL7tXn86m4uLjb8v3tmf7+97/XHXfcoezsbPl8Pu3YsaPL7w3D0PLly3X11VcrLS1NBQUFOnLkSJ/Xtfq5d0Nv99rW1qbHHntMEydO1ODBg5Wdna358+frww8/7PWa0XwW3NDXc73//vsvqfett97a53Xj8blKfd9vd59hn8+nH/3oRz1eM16frVMu+8CydetWlZSUaMWKFaqqqlJeXp4KCwt1+vTpbsu/8cYbuu+++/T1r39dBw8e1J133qk777xT7777rss1t2737t0qLi7Wm2++qZ07d6qtrU2zZs1SY2Njr+dlZGTo1KlT5uv48eMu1Tg2N9xwQ5d679mzp8ey/fm5/vGPf+xynzt37pQkffnLX+7xnP70TBsbG5WXl6e1a9d2+/t///d/109/+lOtX79e+/bt0+DBg1VYWKjm5uYer2n1c++W3u61qalJVVVVWrZsmaqqqrR9+3YdPnxYX/ziF/u8rpXPglv6eq6SdOutt3ap969+9aterxmvz1Xq+34/eZ+nTp3Sxo0b5fP5dPfdd/d63Xh8to4xLnPTpk0ziouLzZ87OjqM7Oxso6ysrNvy99xzj3H77bd3OZafn29885vfdLSeTjh9+rQhydi9e3ePZZ555hkjEAi4VymbrFixwsjLy4u4/EB6rt/+9reNcePGGaFQqNvf99dnahiGIcl48cUXzZ9DoZAxYsQI40c/+pF5rK6uzkhNTTV+9atf9Xgdq597L/z9vXZn//79hiTj+PHjPZax+lnwQnf3umDBAmPOnDmWrtMfnqthRPZs58yZY3zhC1/otUx/eLZ2uqxbWFpbW3XgwAEVFBSYxxISElRQUKC9e/d2e87evXu7lJekwsLCHsvHs2AwKEm68sorey338ccfa9SoUcrNzdWcOXP05z//2Y3qxezIkSPKzs7W2LFjNW/ePJ04caLHsgPluba2tmrLli362te+1usmoP31mf69Y8eOqaampsuzCwQCys/P7/HZRfO5j1fBYFA+n0+ZmZm9lrPyWYgnu3bt0vDhw3XdddfpwQcf1EcffdRj2YH0XGtra/Xyyy/r61//ep9l++uzjcZlHVjOnj2rjo4OZWVldTmelZWlmpqabs+pqamxVD5ehUIhPfLII5o5c6ZuvPHGHstdd9112rhxo1566SVt2bJFoVBIM2bM0N/+9jcXa2tdfn6+nn32WVVUVGjdunU6duyY/uEf/kENDQ3dlh8oz3XHjh2qq6vT/fff32OZ/vpMuxN+PlaeXTSf+3jU3Nysxx57TPfdd1+vm+NZ/SzEi1tvvVW/+MUvVFlZqR/+8IfavXu3brvtNnV0dHRbfqA8V0natGmT0tPT9aUvfanXcv312UZrwOzWDGuKi4v17rvv9tnfOX36dE2fPt38ecaMGfrUpz6lDRs26IknnnC6mlG77bbbzP++6aablJ+fr1GjRumFF16I6P9a+quf//znuu2225Sdnd1jmf76TNGpra1N99xzjwzD0Lp163ot218/C/fee6/53xMnTtRNN92kcePGadeuXbrllls8rJnzNm7cqHnz5vU5GL6/PttoXdYtLEOHDlViYqJqa2u7HK+trdWIESO6PWfEiBGWysejxYsX69e//rVee+01jRw50tK5ycnJuvnmm/XBBx84VDtnZGZm6tprr+2x3gPhuR4/flyvvvqqHnjgAUvn9ddnKsl8PlaeXTSf+3gSDivHjx/Xzp07e21d6U5fn4V4NXbsWA0dOrTHevf35xr2hz/8QYcPH7b8OZb677ON1GUdWFJSUjR58mRVVlaax0KhkCorK7v8H+gnTZ8+vUt5Sdq5c2eP5eOJYRhavHixXnzxRf3ud7/TmDFjLF+jo6ND77zzjq6++moHauicjz/+WH/96197rHd/fq5hzzzzjIYPH67bb7/d0nn99ZlK0pgxYzRixIguz66+vl779u3r8dlF87mPF+GwcuTIEb366qu66qqrLF+jr89CvPrb3/6mjz76qMd69+fn+kk///nPNXnyZOXl5Vk+t78+24h5PerXa88//7yRmppqPPvss8ahQ4eMb3zjG0ZmZqZRU1NjGIZhfPWrXzWWLFliln/99deNpKQk48c//rHxl7/8xVixYoWRnJxsvPPOO17dQsQefPBBIxAIGLt27TJOnTplvpqamswyf3+///Zv/2a88sorxl//+lfjwIEDxr333mv4/X7jz3/+sxe3ELF/+Zd/MXbt2mUcO3bMeP31142CggJj6NChxunTpw3DGFjP1TAuzIa45pprjMcee+yS3/X3Z9rQ0GAcPHjQOHjwoCHJKC8vNw4ePGjOjPnBD35gZGZmGi+99JLxpz/9yZgzZ44xZswY4/z58+Y1vvCFLxhr1qwxf+7rc++V3u61tbXV+OIXv2iMHDnSePvtt7t8hltaWsxr/P299vVZ8Epv99rQ0GD867/+q7F3717j2LFjxquvvmp8+tOfNsaPH280Nzeb1+gvz9Uw+v53bBiGEQwGjUGDBhnr1q3r9hr95dk65bIPLIZhGGvWrDGuueYaIyUlxZg2bZrx5ptvmr/73Oc+ZyxYsKBL+RdeeMG49tprjZSUFOOGG24wXn75ZZdrHB1J3b6eeeYZs8zf3+8jjzxi/m2ysrKM2bNnG1VVVe5X3qK5c+caV199tZGSkmLk5OQYc+fONT744APz9wPpuRqGYbzyyiuGJOPw4cOX/K6/P9PXXnut23+34XsKhULGsmXLjKysLCM1NdW45ZZbLvk7jBo1ylixYkWXY7197r3S270eO3asx8/wa6+9Zl7j7++1r8+CV3q716amJmPWrFnGsGHDjOTkZGPUqFHGwoULLwke/eW5Gkbf/44NwzA2bNhgpKWlGXV1dd1eo788W6f4DMMwHG3CAQAAiNFlPYYFAAD0DwQWAAAQ9wgsAAAg7hFYAABA3COwAACAuEdgAQAAcY/AAgAA4h6BBQAAxD0CCwAAiHsEFgAAEPcILAAAIO4RWAAAQNz7//oN1/lZ5nr6AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.plot(history.history['loss'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "XUP4vgySVanp",
        "outputId": "62b03746-3154-4161-92ae-30bf4b8db59d"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fd5dc2afa00>]"
            ]
          },
          "metadata": {},
          "execution_count": 43
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.evaluate(x_test,y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f_yvzVmRz7Lh",
        "outputId": "70c2d797-a0db-40e3-80e6-58f0ebfd4fe8"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 27ms/step - loss: 0.2084 - accuracy: 1.0000\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.20837464928627014, 1.0]"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab.patches import cv2_imshow\n",
        "import cv2\n",
        "\n",
        "cap=cv2.VideoCapture(0)\n",
        "\n",
        "while True:\n",
        "  ret,frame=cap.read()\n",
        "\n",
        "#calling detect\n",
        "\n",
        "\n",
        "\n",
        "  cv2_imshow('window',frame)\n",
        "  if cv2.waitkey(1) & 0xff == ord('5'):\n",
        "   break\n",
        "\n",
        "cv.destroyAllWindows()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 245
        },
        "id": "UjVlVcPkySAn",
        "outputId": "060b368d-5203-48a6-be24-3ac8ef25f6f8"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-56-9a6d7741e5e4>\u001b[0m in \u001b[0;36m<cell line: 6>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m   \u001b[0mret\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcap\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m   \u001b[0mcv2_imshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'window'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m   \u001b[0;32mif\u001b[0m \u001b[0mcv2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwaitkey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;36m0xff\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mord\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'5'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m    \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: cv2_imshow() takes 1 positional argument but 2 were given"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def detect_mask"
      ],
      "metadata": {
        "id": "UBqyox453OCi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import load_model\n",
        "import numpy as np\n",
        "model = load_model('/content/model-019.model')\n"
      ],
      "metadata": {
        "id": "rmHhI3IXFBhq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "face_clsfr=cv2.CascadeClassifier('haarcascade_frontalface_default.xml')\n",
        "\n",
        "cap=cv2.VideoCapture(0)\n",
        "\n",
        "labels_dict={0:'MASK',1:'NO MASK'}\n",
        "color_dict={0:(0,255,0),1:(0,0,255)}\n",
        "\n",
        "while(True):\n",
        "\n",
        "    ret,img=cap.read()\n",
        "\n",
        "    faces=face_clsfr.detectMultiScale(img,1.3,5)\n",
        "\n",
        "    for x,y,w,h in faces:\n",
        "\n",
        "        face_img=gray[y:y+w,x:x+w]\n",
        "        resized=cv2.resize(face_img,(100,100))\n",
        "        normalized=resized/255.0\n",
        "        reshaped=np.reshape(normalized,(1,100,100,1))\n",
        "        result=model.predict(reshaped)\n",
        "\n",
        "        label=np.argmax(result,axis=1)[0]\n",
        "\n",
        "        cv2.rectangle(img,(x,y),(x+w,y+h),color_dict[label],2)\n",
        "        cv2.rectangle(img,(x,y-40),(x+w,y),color_dict[label],-1)\n",
        "        cv2.putText(img, labels_dict[label], (x, y-10),cv2.FONT_HERSHEY_SIMPLEX,0.8,(255,255,255),2)\n",
        "\n",
        "\n",
        "    cv2.imshow('LIVE',img)\n",
        "    key=cv2.waitKey(1)\n",
        "\n",
        "    if(key==27):\n",
        "        break\n",
        "\n",
        "cv2.destroyAllWindows()\n",
        "cap.release()"
      ],
      "metadata": {
        "id": "ewy9oBzGUvxj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "QcUQMFudXhSI"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}