tests/notebook_real_face_detector.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHS28By1w2mr"
      },
      "source": [
        "# 1. Setup: Download and Install the Project's Package + Calculate the Metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j54djPLL4PTP"
      },
      "source": [
        "## Download and Install the Project's GitHub Package + Test Data + Trained Models"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mR76oqWB5dxe"
      },
      "outputs": [],
      "source": [
        "!rm -rf sample_data\n",
        "!rm -rf facenet-main\n",
        "!rm -rf main.zip\n",
        "!rm -rf data.zip\n",
        "!rm -rf models.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "suGFAwOa080G",
        "outputId": "96fa3bf7-ba28-420d-a571-1e369804bb4f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "main.zip            100%[===================>]  10.92M  67.3MB/s    in 0.2s    \n"
          ]
        }
      ],
      "source": [
        "# download the package\n",
        "!wget -q --show-progress --load-cookies /tmp/cookies1.txt \"https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies1.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1wq_muYxtcFBywUKelyetsQrIrXmPycro' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\\1\\n/p')&id=1wq_muYxtcFBywUKelyetsQrIrXmPycro\" -O main.zip && rm -rf /tmp/cookies1.txt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TaoVUNSt08rD",
        "outputId": "87be017a-bbdb-46c5-a8ef-3c7fe83b844d"
      },
      "outputs": [],
      "source": [
        "# extract\n",
        "!unzip -o main.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ao22C4VN1aPD",
        "outputId": "981be5d1-fe26-4834-c764-453d1b1744f6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Processing ./facenet-main\n",
            "\u001b[33m  DEPRECATION: A future pip version will change local packages to be built in-place without first copying to a temporary directory. We recommend you use --use-feature=in-tree-build to test your packages with this new behavior before it becomes the default.\n",
            "   pip 21.3 will remove support for this functionality. You can find discussion regarding this at https://github.com/pypa/pip/issues/7555.\u001b[0m\n",
            "Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (3.6.4)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (1.21.5)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (7.1.2)\n",
            "Requirement already satisfied: torch in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (1.10.0+cu111)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (0.11.1+cu111)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (1.0.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (1.3.5)\n",
            "Requirement already satisfied: seaborn in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (0.11.2)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from facenet==1.0.0) (3.2.2)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->facenet==1.0.0) (3.0.7)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->facenet==1.0.0) (0.11.0)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->facenet==1.0.0) (2.8.2)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->facenet==1.0.0) (1.3.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->facenet==1.0.0) (1.15.0)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->facenet==1.0.0) (2018.9)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from pytest->facenet==1.0.0) (57.4.0)\n",
            "Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->facenet==1.0.0) (1.4.0)\n",
            "Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->facenet==1.0.0) (0.7.1)\n",
            "Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->facenet==1.0.0) (8.12.0)\n",
            "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from pytest->facenet==1.0.0) (21.4.0)\n",
            "Requirement already satisfied: py>=1.5.0 in /usr/local/lib/python3.7/dist-packages (from pytest->facenet==1.0.0) (1.11.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->facenet==1.0.0) (3.1.0)\n",
            "Requirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->facenet==1.0.0) (1.4.1)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->facenet==1.0.0) (1.1.0)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch->facenet==1.0.0) (3.10.0.2)\n",
            "Building wheels for collected packages: facenet\n",
            "  Building wheel for facenet (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for facenet: filename=facenet-1.0.0-py3-none-any.whl size=8137 sha256=79cdc8066686dd08bda481c211140b74031ec23d898253b206400450ad0b8806\n",
            "  Stored in directory: /root/.cache/pip/wheels/3d/56/7b/04537096d8c561f483eb09d0f5821d8250cc82f53b663f24ad\n",
            "Successfully built facenet\n",
            "Installing collected packages: facenet\n",
            "Successfully installed facenet-1.0.0\n"
          ]
        }
      ],
      "source": [
        "# install our package (facenet)\n",
        "!pip install facenet-main/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VxGR1na_6Wub",
        "outputId": "9f767efd-1bb9-43d0-94ae-51db3073bfc3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "models.zip          100%[===================>] 878.27M   131MB/s    in 5.9s    \n"
          ]
        }
      ],
      "source": [
        "# download the pre-trained models.\n",
        "!wget -q --show-progress --load-cookies /tmp/cookies2.txt \"https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies2.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1JNBOUqPkDMlaU7CclATGqh-aklagkuJa' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\\1\\n/p')&id=1JNBOUqPkDMlaU7CclATGqh-aklagkuJa\" -O models.zip && rm -rf /tmp/cookies2.txt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uJieHkPG6fb5",
        "outputId": "5ba59adf-9d54-477d-df23-a34df62736c0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Archive:  models.zip\n",
            "  inflating: facenet-main/trained/FaceCNN.pt  \n",
            "  inflating: facenet-main/trained/MLP.pt  \n",
            "  inflating: facenet-main/trained/SC.pt  \n"
          ]
        }
      ],
      "source": [
        "# extract\n",
        "!unzip -o models.zip -d facenet-main/trained"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W-T74Y9JxZjO",
        "outputId": "90624d23-c196-4b6b-d49e-53507591f9c7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "data.zip            100%[===================>] 175.00M   125MB/s    in 1.4s    \n"
          ]
        }
      ],
      "source": [
        "# download data\n",
        "!wget -q --show-progress --load-cookies /tmp/cookies3.txt \"https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1v9TuWO5Yjz1d5hSTUsPSnZkgRBCJxF37' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\\1\\n/p')&id=1v9TuWO5Yjz1d5hSTUsPSnZkgRBCJxF37\" -O data.zip && rm -rf /tmp/cookies3.txt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "za6i0lZ104Qa",
        "outputId": "e6ab183d-49b7-4d51-c4e4-b6706551c6a2"
      },
      "outputs": [],
      "source": [
        "# extract\n",
        "!unzip data.zip -d facenet-main/data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r2LMUUX84Xwq"
      },
      "source": [
        "## Calculating the Metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vdxmpfhHw2m0"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import copy\n",
        "\n",
        "from facenet.core import Config\n",
        "from facenet.nnet.mlp import MLP\n",
        "from facenet.nnet.cnn import FaceCNN\n",
        "from facenet.dataio.dataset import FaceDataset\n",
        "from facenet.nnet.linear_classifier import SoftmaxClassifier\n",
        "\n",
        "import torch\n",
        "import random\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sn\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
        "from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Vg3_F7lw2m1",
        "outputId": "d316b286-d7d4-477f-d4ba-3fb15880675b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<torch._C.Generator at 0x7ff41be33a10>"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "random.seed(Config.random_seed)\n",
        "np.random.seed(Config.random_seed)\n",
        "torch.manual_seed(Config.random_seed)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hjgVkV9Vw2m1",
        "outputId": "59aed009-36c4-4abb-bd8d-315559269568"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "cuda:0\n"
          ]
        }
      ],
      "source": [
        "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
        "print(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k5Po8wMKw2m2"
      },
      "outputs": [],
      "source": [
        "test_dataset = FaceDataset(root_dir='facenet-main/data/test', img_dim=Config.img_dim)\n",
        "test_loader = test_dataset.get_data_loader(1, False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0VdHJgBkw2m2",
        "outputId": "e629e561-94f4-4c16-fc66-b86bb381b905"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "SoftmaxClassifier(\n",
              "  (classifier): Sequential(\n",
              "    (0): Flatten(start_dim=1, end_dim=-1)\n",
              "    (1): Linear(in_features=196608, out_features=2, bias=True)\n",
              "  )\n",
              ")"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# loading FaceCNN model\n",
        "face_model = FaceCNN(label_count=FaceDataset.label_count, img_dim=Config.img_dim, base_filter=Config.base_filter)\n",
        "face_model = face_model.to(device)\n",
        "face_model.load_state_dict(torch.load('facenet-main/trained/FaceCNN.pt'))\n",
        "face_model.eval()\n",
        "\n",
        "# loading MLP model\n",
        "mlp_model = MLP(label_count=FaceDataset.label_count, hl_size=1000,\n",
        "            img_dim=Config.img_dim, img_channels=Config.img_channels)\n",
        "mlp_model = mlp_model.to(device)\n",
        "mlp_model.load_state_dict(torch.load('facenet-main/trained/MLP.pt'))\n",
        "mlp_model.eval()\n",
        "\n",
        "# loading SoftmaxClassifier model\n",
        "sc_model = SoftmaxClassifier(label_count=FaceDataset.label_count,\n",
        "                          img_dim=Config.img_dim, img_channels=Config.img_channels)\n",
        "sc_model = sc_model.to(device)\n",
        "sc_model.load_state_dict(torch.load('facenet-main/trained/SC.pt'))\n",
        "sc_model.eval()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tdsRtEidw2m2"
      },
      "outputs": [],
      "source": [
        "sources = ['face2face', 'glow', 'pggan', 'stargan', 'stylegan', 'celeba', 'celebaHQ', 'youtube']\n",
        "\n",
        "class Metrics:\n",
        "    \"\"\"Tracks predictions over each source of image.\n",
        "    \"\"\"\n",
        "    def __init__(self):\n",
        "        self.y_pred = []\n",
        "        self.y_true = []\n",
        "\n",
        "        self.total = {\n",
        "            'face2face': 0,\n",
        "            'glow': 0,\n",
        "            'pggan': 0,\n",
        "            'stargan': 0,\n",
        "            'stylegan': 0,\n",
        "            'celeba': 0,\n",
        "            'celebaHQ': 0,\n",
        "            'youtube': 0,\n",
        "        }\n",
        "\n",
        "        self.correct = {\n",
        "            'face2face': 0,\n",
        "            'glow': 0,\n",
        "            'pggan': 0,\n",
        "            'stargan': 0,\n",
        "            'stylegan': 0,\n",
        "            'celeba': 0,\n",
        "            'celebaHQ': 0,\n",
        "            'youtube': 0,\n",
        "        }\n",
        "    \n",
        "    def plot_confusion_matrix(self):\n",
        "        cf_matrix = confusion_matrix(self.y_true, self.y_pred)\n",
        "\n",
        "        df_cm = pd.DataFrame(cf_matrix / np.sum(cf_matrix) * FaceDataset.label_count, index=[i for i in FaceDataset.labels], columns=[i for i in FaceDataset.labels])\n",
        "        plt.figure(figsize=(13, 8))\n",
        "        sn.heatmap(df_cm, annot=True)\n",
        "\n",
        "        # raw values with sklearn\n",
        "        disp = ConfusionMatrixDisplay(confusion_matrix=cf_matrix, display_labels=FaceDataset.labels)\n",
        "        disp.plot()\n",
        "        plt.show()\n",
        "    \n",
        "    def plot_per_source(self):\n",
        "        total_per_class = np.array(list(self.total.values()))\n",
        "        correct_per_class = np.array(list(self.correct.values()))\n",
        "        acc_per_class = np.around(100 * correct_per_class / total_per_class, 2)\n",
        "        acc_total = [100] * len(sources)\n",
        "\n",
        "        plt.figure(figsize=(13, 8))\n",
        "        plt.bar(sources, acc_total, color='orange')\n",
        "        plt.bar(sources, acc_per_class)\n",
        "        plt.show()\n",
        "\n",
        "\n",
        "    def print_metrics(self):\n",
        "        print(f'accuracy: {accuracy_score(self.y_true, self.y_pred):.3f}')\n",
        "        print(f'recall: {recall_score(self.y_true, self.y_pred, average=\"weighted\"):.3f}')\n",
        "        print(f'precision: {precision_score(self.y_true, self.y_pred, average=\"weighted\"):.3f}')\n",
        "        print(f'f1: {f1_score(self.y_true, self.y_pred, average=\"weighted\"):.3f}')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pu3OQg2Cw2m3"
      },
      "outputs": [],
      "source": [
        "face_metrics = Metrics()\n",
        "mlp_metrics = Metrics()\n",
        "sc_metrics = Metrics()\n",
        "\n",
        "models = [face_model, mlp_model, sc_model]\n",
        "metrics = [face_metrics, mlp_metrics, sc_metrics]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mEi8UTlkw2m3"
      },
      "outputs": [],
      "source": [
        "with torch.no_grad():\n",
        "    for data in test_loader:\n",
        "        images, labels, src = data[0].to(device), data[1].to(device), data[2][0]\n",
        "\n",
        "        for model, metric in zip(models, metrics):\n",
        "            out_labels = model(images)\n",
        "            preds = torch.argmax(out_labels.data, dim=1)\n",
        "\n",
        "            metric.y_pred.extend(preds.data.cpu().numpy())\n",
        "            metric.y_true.extend(labels.data.cpu().numpy())\n",
        "            metric.total[src] += labels.shape[0]\n",
        "            metric.correct[src] += (preds == labels).sum().item()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cz7zBkTFw2m4"
      },
      "source": [
        "# 2. Comparing the Models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qsh1c_dKw2m4"
      },
      "source": [
        "## FaceCNN"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T1zryDkCw2m4"
      },
      "source": [
        "### Metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xWK5U3a5w2m5",
        "outputId": "e3179371-0647-4501-ac04-d57c8bb1b6d0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "accuracy: 0.938\n",
            "recall: 0.938\n",
            "precision: 0.941\n",
            "f1: 0.938\n"
          ]
        }
      ],
      "source": [
        "face_metrics.print_metrics()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RqM0ow8Ww2m5"
      },
      "source": [
        "### Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "id": "hToTwulpw2m5",
        "outputId": "66d64b4a-5236-4d7b-dad0-12620be24679"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUcAAAEGCAYAAAD2TVeiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAa/klEQVR4nO3de5wcVZn/8c+XyQ1yDwkhJsEECCCiXDZCgBW5BCSiIqugLCooLiIuiOhKQBSRVVlFAcUbgkoU+SmKgKJAxCCwS4CEAELCJQRCbhByIVfIZeb5/VFnSKenZ9KTTFdP93zfr1e9pupUddXTM+HhnDp1TikiMDOzzW1X7QDMzDojJ0czsxKcHM3MSnByNDMrwcnRzKyEbtUOoCMMGNQQw0bUxVfpMhY+NaDaIVg7rdyweElEDNmWc7z7iN6xdFljWcdOf3zdnRFx7LZcb1vURUYZNqIbk/60c7XDsHb46jtPqHYI1k53zLtq7raeY+myRh66c5eyjm0Y9uzgbb3etqiL5GhmtSGAJpqqHUZZnBzNLDdBsCHKa1ZXm5OjmeXKNUczsyJB0FgjQ5adHM0sV004OZqZbSaARidHM7OWXHM0MysSwAbfczQz21wQblabmbUQ0FgbudHJ0czyk42QqQ1OjmaWI9GIqh1EWZwczSw3WYeMk6OZ2Way5xydHM3MWmhyzdHMbHOuOZqZlRCIxhp5O4uTo5nlys1qM7MigVgfDdUOoyxOjmaWm+whcDerzcxacIeMmVmRCNEYrjmambXQ5Jqjmdnmsg6Z2kg7tRGlmdUFd8iYmbWi0c85mpltziNkzMxa0eTeajOzzWUTTzg5mpltJhAbPHzQzGxzEfghcDOzluSHwM3MigWuOZqZleQOGTOzIoFqZrLb2kjhZlYXslezditrKYekBkkzJP05bY+W9KCk2ZJ+K6lHKu+Ztmen/aO2dG4nRzPLkWgscynT54BZBdv/A1wREbsDy4HTU/npwPJUfkU6rk1OjmaWmyAbIVPOsiWSRgDHAdembQFHAr9Ph1wPfCCtH5+2SfuPSse3yvcczSxXHTgT+JXAl4C+aXtH4NWI2Ji25wPD0/pwYB5ARGyUtCIdv6S1k7vmaGa5iVB7ao6DJU0rWM5oPo+k9wKLI2J6pWJ1zdHMcpN1yJQ9fHBJRIxtZd+hwPslvQfoBfQDrgIGSOqWao8jgAXp+AXASGC+pG5Af2BpWxd3zdHMcpS9Q6acpS0RcUFEjIiIUcBHgL9HxCnAFOBD6bBTgVvT+m1pm7T/7xERbV3DydHMcpN1yKisZSudD5wnaTbZPcXrUvl1wI6p/Dxg4pZO5Ga1meWqo0fIRMQ9wD1pfQ5wYIljXgdObM95nRzNLDe1NELGydHMcuUXbJmZFYmADU1OjmZmm8ma1U6OZmYtdOAImYpycuwEmhrhh+9/K/123sCp1z3D7784mucf7EevvtkoqA9e/jxv2nstEfDnS3bh6XsG0KNXEx+8fA7D91lb5ei7tp/fMoXX1jbQ1CQaG8W5p/4rffqtZ+I3ZrDTsNdYvGh7LrvwAFav6l7tUDuF5kd5akGnT46SXgDGRkSrYyBr3f/9YmeG7P4661ZvGjlw7AUv8rb3LN/suGfu6c/SF3rxhSmPM+/R3tx60SjOumVm3uFakQs+M46VK3q8sX3iqXN47OHB3DRpN078+HOceOpz/OLqvaoYYWdSO83qXKNUpjZ+MzlZsag7T03pzzs+vHiLx86cPJD9/20JEuyy/xpeX9nAysWukXQ24w57mb/dns138LfbhzPuXS9XOaLOpSm9R2ZLS7VVPFFJGiXpaUmTgCeAr0h6WNLjki4pOO4WSdMlPVk4wLze/fnrb2bCxHkU/y9j8uUj+P6x+3D7pbuwcV32D2Xlyz3oP2z9G8f0G7aelS/1wKongEt/8BBXXX8/x37gRQAGDFrH8qW9AFi+tCcDBq2rYoSdS9Zb3VDWUm15NavHkI1r7Ec2rvFAQMBtkg6LiHuBT0bEMknbAw9L+kNEtDowPCXQMwB2Hl79X+TWeOruAfQZvIHhb1vLnKl93yg/5kvz6TtkA43rxR8vHM0/fjqMo85ZWMVIrTVf+o+DWfpKL/oPXMd/X/0Q8+b2KTpCWQY1wA+BlzI3IqZKuhw4BpiRyvuQJc57gXMknZDKR6byVpNjRFwDXAPwlrf3rMl/fnOn92HW3wby9JQBbFwn1q1u4Hfn7spJV84BoFvP4F9OfIX7fjYMgH5D17Ni0aaa4spFPei38/qS57Z8LH0lqyGuWN6TB+4Zyp57v8qry3oycMfXWb60FwN3fJ1Xl/escpSdS2doMpcjr/t/a9JPAd+KiP3SsntEXCfpcGA8cHBE7EuWPHvlFFvVvPtL85n4wKN86f7H+MgPnmPXQ1Zx0pVz3riPGAEz7xrI0D2yHum3jF/OjJsHEwEvzuhNr76N9NtpQzW/QpfWs9dGtt9h4xvrBxy0hLnP9eXBe3di/HHZTFnjj1vA1HuHVjPMTiWHiSc6TN691XcCl0q6ISJWSxoObCCbW215RKyVtBcwLue4OpXfnbsba5Z1IwLe9Ja1HP+NFwDY84gVPD1lAN89/O10376JD377+eoG2sUNHLSeL38nm2u1oSH4x51vYvrUITwzqz8TvzmDo98/j1de2p5vXbh/lSPtXGqltzrX5BgRd0l6C/BAen3DauCjwB3AmZJmAU8DU/OMqzPYddwqdh23CoBP/eapksdIcPylc/MMy9rw0sIdOPuUd7YoX7WiB1/+7EFViKjzixAbnRwzEfECsE/B9lVkM/YWm9DK50dVJDAzq4rO0GQuR6d/CNzM6odHyJiZtcLJ0cysiJ9zNDNrRa085+jkaGa5iYCNnuzWzKwlN6vNzIr4nqOZWSvCydHMrCV3yJiZFYnwPUczsxJEo3urzcxa8j1HM7MiHlttZlZKZPcda4GTo5nlyr3VZmZFwh0yZmaluVltZlaCe6vNzIpEODmamZXkR3nMzErwPUczsyKBaKqR3uraiNLM6kaUubRFUi9JD0l6TNKTki5J5aMlPShptqTfSuqRynum7dlp/6gtxenkaGb5SR0y5SxbsA44MiL2BfYDjpU0Dvgf4IqI2B1YDpyejj8dWJ7Kr0jHtcnJ0czy1QFVx8isTpvd0xLAkcDvU/n1wAfS+vFpm7T/KEltZmAnRzPLVTtqjoMlTStYzig8j6QGSY8Ci4HJwHPAqxGxMR0yHxie1ocD87Lrx0ZgBbBjW3G22iEj6Qe0kb8j4py2TmxmViyApqayH+VZEhFjWz1XRCOwn6QBwB+BvbY9wk3a6q2e1pEXMjPLmswd+5xjRLwqaQpwMDBAUrdUOxwBLEiHLQBGAvMldQP6A0vbOm+ryTEiri/clrRDRKzdhu9gZtYhzzlKGgJsSIlxe+Bosk6WKcCHgP8HnArcmj5yW9p+IO3/e0TbkWzxnqOkgyXNBJ5K2/tK+tHWfSUz6/I64lkeGAZMkfQ48DAwOSL+DJwPnCdpNtk9xevS8dcBO6by84CJW7pAOQ+BXwm8myzzEhGPSTqsjM+ZmRUp6zGdLYqIx4H9S5TPAQ4sUf46cGJ7rlHWCJmImFfU693YnouYmb2hjoYPzpN0CBCSugOfA2ZVNiwzq0sBUX5vdVWV85zjmcBnyZ4TWkj2NPpnKxmUmdUzlblU1xZrjhGxBDglh1jMrCuokWZ1Ob3Vu0r6k6RXJC2WdKukXfMIzszqUMf0VldcOc3q3wC/I+s6fxNwE3BjJYMyszrV/BB4OUuVlZMcd4iIX0XExrT8GuhV6cDMrD5FlLdUW1tjqwel1b9Kmkj2xHkAHwb+kkNsZlaPaqS3uq0OmelkybD5m3y6YF8AF1QqKDOrX+oEtcJytDW2enSegZhZF9BJOlvKUdYIGUn7AHtTcK8xIiZVKigzq1edo7OlHFtMjpIuBg4nS45/ASYA9wNOjmbWfjVScyynt/pDwFHASxHxCWBfsrnQzMzar6nMpcrKaVa/FhFNkjZK6kc2JfnICsdlZvWoApPdVko5yXFamob8Z2Q92KvJJow0M2u3mu+tbhYRZ6XVn0i6A+iX5lIzM2u/Wk+Okg5oa19EPFKZkMzMqq+tmuN329jX/H7YTmHBP3tz4egWk/9aJ3bnwturHYK1U8OwjjlPzTerI+KIPAMxsy4gqIvhg2ZmHa/Wa45mZpVQ881qM7OKqJHkWM5M4JL0UUlfTdu7SHLvh5ltnTqaCfxHwMHAyWl7FfDDikVkZnVLUf5SbeU0qw+KiAMkzQCIiOWSelQ4LjOrV3XUW71BUgOpoitpCJ1iWLiZ1aLOUCssRznN6u8DfwR2kvQNsunKvlnRqMysftXIPcdyxlbfIGk62bRlAj4QEbMqHpmZ1Z9Ocj+xHOVMdrsLsBb4U2FZRLxYycDMrE7VS3IEbmfTi7Z6AaOBp4G3VjAuM6tTqpEei3Ka1W8r3E6z9ZzVyuFmZnWh3SNkIuIRSQdVIhgz6wLqpVkt6byCze2AA4CFFYvIzOpXPXXIAH0L1jeS3YP8Q2XCMbO6Vw/JMT383TcivphTPGZW72o9OUrqFhEbJR2aZ0BmVr9EffRWP0R2f/FRSbcBNwFrmndGxM0Vjs3M6k0N3XMsZ/hgL2Ap2Ttj3gu8L/00M2u/Dhg+KGmkpCmSZkp6UtLnUvkgSZMlPZt+DkzlkvR9SbMlPd7WCwSbtVVz3Cn1VD/BpofAC7+emVn7dUz22Ah8IT1a2BeYLmkycBpwd0RcJmkiMBE4H5gAjEnLQcCP089WtZUcG4A+bJ4Umzk5mtlW6YhmdUQsAhal9VWSZgHDgeOBw9Nh1wP3kCXH44FJERHAVEkDJA1L5ympreS4KCK+vs3fwsysUPnJcbCkaQXb10TENcUHSRoF7A88CAwtSHgvAUPT+nBgXsHH5qeyrUqOtTEjpZnVjmhXb/WSiBjb1gGS+pA9d31uRKyUNqWtiAhp6+upbXXIHLW1JzUza1UHzecoqTtZYryh4OmZlyUNS/uHAYtT+QJgZMHHR6SyVrWaHCNi2ZbDMzNrn454h4yyKuJ1wKyI+F7BrtuAU9P6qcCtBeUfT73W44AVbd1vBL+a1czy1jHduYcCHwP+KenRVHYhcBnwO0mnA3OBk9K+vwDvAWaTzU/7iS1dwMnRzPLTQa9AiIj7ab1fpMUtwdRL/dn2XMPJ0cxyI2pnhIyTo5nlysnRzKwUJ0czsxKcHM3MitTQrDxOjmaWLydHM7OW6mGyWzOzDudmtZlZsQ56CDwPTo5mli8nRzOzzXmEjJlZK9RUG9nRydHM8uN7jmZmpblZbWZWipOjmVlLrjmamZXi5GhmVqR9bx+sKidHM8uNn3M0M2tN1EZ2dHI0s1y55mjtdt73XuSg8at4dUk3Pn3kngB86isLGXf0SjasF4vm9uC7n9+FNSsbqhypNTbC2cfuwY7DNnDppOeZcV8frr30TTQ1ie17N/KFK19k+Oj1LJ7fne+cuwtrVjTQ1CQ+eeFCDjxqVbXDr54aegh8u0qdWNI5kmZJuqGV/adJurpS169Fd/12EF8+ZfRmZY/c25czjtiTz4zfkwVzevKRs1+uUnRW6JZrhzByzLo3tn9wwQjO/+Fcfvy3pznihOXceNXOAPzmqqEc9r5X+dHkZ7jgxy9w9QUjqxVyp6Gm8pZqq1hyBM4Cjo6IUyp4jbryxIN9WLV888r8I//oS1Nj9nreWdN7M3jYhmqEZgVeWdidh+7ux4R/X/pGmYC1q7Ia/ZpVDQwamv2dpILylZvKu7JaSY4VaVZL+gmwK/BXSb8GPgD0Al4DPhERTxcdfxxwEfA+4ADgEqAn8Fw6fnUl4qw17z55Gf+4dUC1w+jyfnLxcD510ULWrt50e+Pc787joo/tSs9eTezQp4kr//wMAB/9wktcePJu3PaLwby+djsu++1z1Qq7cwhqpkOmIjXHiDgTWAgcAfwYeGdE7A98Ffhm4bGSTgAmAu9JRRcB4yPiAGAacF6pa0g6Q9I0SdM2sK7UIXXl5HNepnEj/P1mJ8dqmjq5HwMGb2TM21/brPyP1wzhv381hxumz+SYDy/lmq8NB+CeWwZy9EnLuGH6TC791Ry+ffabaeoEtaJqUpS3VFseHTL9gesljSH7/0b3gn1HAmOBYyJipaT3AnsD/ysJoAfwQKmTRsQ1wDUA/TSoE/wqK+fok5Zx4PiVTPzwbmQNOKuWmQ/3Zupd/Xj47r1Zv06sXdXAVz42mnmze7HXAWsBeNf7X+XLp+wGwB03DuIbN8wBYO+xa1m/Tqxc1o0BgzdW7TtUXY3811rJe47NLgWmRMQ+ZM3mXgX7ngP6AnukbQGTI2K/tOwdEafnEGOnNfbwlZx41mK+dtpo1r2Wx5/L2vLJCxdxw/SZTHpoJhf8eC77/usqvvaL51mzsoH5z/UEsk60kWNeB2Cn4Rt49P6+ALz4bE/Wr9uO/jt23cTY/BC4a46Z/sCCtH5a0b65wH8BN0s6EZgK/FDS7hExW1JvYHhEPJNDnFU38UdzefvBq+k/aCO/njaTX313KB/5z8V07xl8K92remp6b74/cUSVI7VCDd3g3Mvncel/jELbQd/+jZz3vRcBOOPiBVz5xZHc/LMhCPjiFS+irlz5j/BktwW+Tdasvgi4vXhnRDwl6RTgJrKa5WnAjZJ6pkMuArpEcrzsrDe3KLvzxh2rEImVY99DVrPvIVlf4aETVnDohBUtjnnzHuu44rbZeYfWudVGbqxccoyIUWl1CZuazZAlOyLil8Av0/oMsnuNkDW131GpuMysujpDk7kcHiFjZvkJwM1qM7MSaiM3OjmaWb7crDYzK8G91WZmxTwrj5lZS9lD4FHWssVzST+XtFjSEwVlgyRNlvRs+jkwlUvS9yXNlvS4pAO2dH4nRzPLV1OZy5b9Eji2qGwicHdEjAHuTtsAE4AxaTmDbM6HNjk5mlmuOqrmGBH3AsuKio8Hrk/r15PNCNZcPikyU4EBkoa1dX4nRzPLT7Rj2TpDI2JRWn8JGJrWhwPzCo6bn8pa5Q4ZM8tRu8ZWD5Y0rWD7mjQbV3lXighp6x8ccnI0s3yVP9ntkogY286zvyxpWEQsSs3mxal8AVD4jooRbJoQpyQ3q80sP1Hx1yTcBpya1k8Fbi0o/3jqtR4HrChofpfkmqOZ5auDXpMg6UbgcLLm93zgYuAy4HeSTiebEvGkdPhfyN42MBtYC3xiS+d3cjSzfHXQQ+ARcXIru44qcWwAn23P+Z0czSxXqpGX6Dg5mll+gnIf8K46J0czy40o7wHvzsDJ0czy5eRoZlaCk6OZWRHfczQzK8291WZmLYSb1WZmLQROjmZmJdVGq9rJ0czy5ecczcxKcXI0MysSAY210a52cjSzfLnmaGZWgpOjmVmRAMp/h0xVOTmaWY4Cwvcczcw2F7hDxsysJN9zNDMrwcnRzKyYJ54wM2spAE9ZZmZWgmuOZmbFPHzQzKylgPBzjmZmJXiEjJlZCb7naGZWJMK91WZmJbnmaGZWLIjGxmoHURYnRzPLj6csMzNrhR/lMTPbXADhmqOZWZHwZLdmZiXVSoeMoka61dsi6RVgbrXjqJDBwJJqB2HtUq9/szdHxJBtOYGkO8h+P+VYEhHHbsv1tkVdJMd6JmlaRIytdhxWPv/N6sN21Q7AzKwzcnI0MyvBybHzu6baAVi7+W9WB3zP0cysBNcczcxKcHI0MyvBybGGSXpBUrnPjNk2knSOpFmSbmhl/2mSrs47LqsMj5DpJCSJ7B5wbYyt6prOAsZHxPxqB2KV55pjFUkaJelpSZOAJ4CvSHpY0uOSLik47hZJ0yU9KemM6kXcdUn6CbAr8FdJ50t6QNIMSf8nac8Sxx+Xjhks6Zi0/oikmyT1yf8bWHu5t7qKJI0C5gCHAP2ADwGfBgTcBnw7Iu6VNCgilknaHngYeFdELJX0AjA2IupxqFqn0/z7BtYDayNio6TxwGci4oOSTkv77wbOA94PNAA3AxMiYo2k84GeEfH1anwHK5+b1dU3NyKmSrocOAaYkcr7AGOAe4FzJJ2Qykem8qW5R2rN+gPXSxpDNgtX94J9R5IlyGMiYqWk9wJ7A/+b3TmhB/BAzvHaVnByrL416aeAb0XETwt3SjocGA8cHBFrJd0D9Mo1Qit2KTAlIk5Itf97CvY9R9b83gOYRvZ3nRwRJ+cco20j33PsPO4EPtl8P0rScEk7kdVSlqfEuBcwrppBGpD9TRak9dOK9s0FPghMkvRWYCpwqKTdAST1lrRHXoHa1nNy7CQi4i7gN8ADkv4J/B7oC9wBdJM0C7iM7D82q65vA9+SNIMSra+IeAo4BbiJ7F7yacCNkh4na1LvlV+otrXcIWNmVoJrjmZmJTg5mpmV4ORoZlaCk6OZWQlOjmZmJTg5dhGSGiU9KumJNL53h2041y8lfSitXytp7zaOPVzSIVtxjZIzDpUzE5Gk1e281tckfbG9MVp9c3LsOl6LiP0iYh+yscFnFu6UtFWjpSLiUxExs41DDicbO25WU5wcu6b7gN1Tre4+SbcBMyU1SPpOwcxAn4ZsOjVJV6cZhP4G7NR8Ikn3SBqb1o9NM888JunuNLTuTODzqdb6TklDJP0hXeNhSYemz+4o6a4089C1ZMPu2tTWbEWSrkjld0saksp2k3RH+sx9acSRWUkeW93FpBriBLKRNwAHAPtExPMpwayIiHdI6kk2WcJdwP7AnmQTKAwFZgI/LzrvEOBnwGHpXM0zCf0EWB0Rl6fjfgNcERH3S9qFbNjkW4CLgfsj4uuSjgNOL+PrfLJwtiJJf4iIpUBvYFpEfF7SV9O5/5PsxVdnRsSzkg4CfkQ2UYRZC06OXcf2kh5N6/cB15E1dx+KiOdT+THA25vvJ5KNIR4DHAbcGBGNwEJJfy9x/nHAvc3niohlrcQxHtg7zVAD0C+NJz8M+Lf02dslLS/jO7U2W1ET8NtU/mvg5nSNQ4CbCq7ds4xrWBfl5Nh1vBYR+xUWpCSxprAIODsi7iw67j0dGMd2wLiIeL1ELGVr52xFka77avHvwKw1vudohe4EPiOpO4CkPST1JptT8sPpnuQw4IgSn50KHCZpdPrsoFS+imwCjWZ3AWc3b0hqTlb3Av+eyiYAA7cQa1uzFW1HNnEw6Zz3R8RK4HlJJ6ZrSNK+W7iGdWFOjlboWrL7iY9IegL4KVnr4o/As2nfJEpM1hoRrwBnkDVhH2NTs/ZPwAnNHTLAOcDY1OEzk0295peQJdcnyZrXL24h1rZmK1oDHJi+w5FA86zbpwCnp/ieBI4v43diXZRn5TEzK8E1RzOzEpwczcxKcHI0MyvBydHMrAQnRzOzEpwczcxKcHI0Myvh/wM9ryPnL5kWnAAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "face_metrics.plot_confusion_matrix()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NLxXa2eKw2m5"
      },
      "source": [
        "### Per Source Performance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        },
        "id": "VoP8hQBiw2m6",
        "outputId": "fa24723b-cc05-4788-d1ca-bbba5aa4c71a"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "face_metrics.plot_per_source()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rf__d6j-w2m6"
      },
      "source": [
        "## MLP"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6Zu_Rqdw2m6"
      },
      "source": [
        "### Metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hwZCs6M8w2m6",
        "outputId": "045c86e9-f4ac-4082-83d6-89230c9e8c05"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "accuracy: 0.561\n",
            "recall: 0.561\n",
            "precision: 0.602\n",
            "f1: 0.512\n"
          ]
        }
      ],
      "source": [
        "mlp_metrics.print_metrics()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GMJrCCz1w2m6"
      },
      "source": [
        "### Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "id": "-9i63wjEw2m6",
        "outputId": "d47413c0-b9ee-4f6e-df15-3f3f95a16aaa"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "mlp_metrics.plot_confusion_matrix()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NKxGK63w2m6"
      },
      "source": [
        "### Per Source Performance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        },
        "id": "CYCJH1qiw2m6",
        "outputId": "2febb493-91e2-49b6-ec8e-d2d3267f8d6b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "mlp_metrics.plot_per_source()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g4d3eoEcw2m7"
      },
      "source": [
        "## SoftmaxClassifier"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LFpspS3ow2m7"
      },
      "source": [
        "### Metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9jTvnlmUw2m7",
        "outputId": "40add641-2a4b-461e-8190-d19d812d13cb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "accuracy: 0.518\n",
            "recall: 0.518\n",
            "precision: 0.582\n",
            "f1: 0.401\n"
          ]
        }
      ],
      "source": [
        "sc_metrics.print_metrics()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E9NM6YFBw2m7"
      },
      "source": [
        "### Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "id": "ezuRGmuQw2m7",
        "outputId": "04ae39d7-9d4c-4b71-d119-3a19404c4936"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "sc_metrics.plot_confusion_matrix()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "POz5zzkzw2m7"
      },
      "source": [
        "### Per Source Performance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        },
        "id": "Bz4YKwUow2m7",
        "outputId": "14712ca9-d9bd-42a2-b8c7-72fa32aeea56"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "sc_metrics.plot_per_source()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YIg-A5Q_H21X"
      },
      "source": [
        "## FaceCNN vs MLP vs SoftmaxClassifier"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        },
        "id": "vyQ51pGiH9qQ",
        "outputId": "63f4e528-56ed-4e4f-fa7c-a52938dc012f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "model_names = ['FaceCNN', 'MLP', 'SoftmaxClassifier']\n",
        "model_acc_total = [100] * len(model_names)\n",
        "model_accs = [0, 0, 0]\n",
        "\n",
        "model_accs[0] = accuracy_score(face_metrics.y_true, face_metrics.y_pred) * 100\n",
        "model_accs[1] = accuracy_score(mlp_metrics.y_true, mlp_metrics.y_pred) * 100\n",
        "model_accs[2] = accuracy_score(sc_metrics.y_true, sc_metrics.y_pred) * 100\n",
        "\n",
        "plt.figure(figsize=(13, 8))\n",
        "plt.bar(model_names, model_acc_total, color='orange')\n",
        "plt.bar(model_names, model_accs)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "up2xct2zw2m7"
      },
      "source": [
        "# 3. Plotting the FaceCNN Learning History"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 427
        },
        "id": "3XglF0d1w2m7",
        "outputId": "b1cfab72-07c5-481a-851c-cde301ebabad"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "loss_hist = np.loadtxt('facenet-main/trained/history/FaceCNN_loss.csv', delimiter=',')[:4960]\n",
        "vloss_hist = np.loadtxt('facenet-main/trained/history/FaceCNN_vloss.csv', delimiter=',')\n",
        "\n",
        "# calc mean of losses over each epoch + some data cleanups/processings\n",
        "loss_hist = np.mean(loss_hist.reshape(-1, 620), axis=1).reshape(-1, 1)\n",
        "vloss_hist = np.mean(vloss_hist.reshape(-1, 19000), axis=1).reshape(-1, 1)\n",
        "epochs = range(0, len(loss_hist))\n",
        "\n",
        "\n",
        "# training and validation values histories\n",
        "plt.figure(figsize=(8, 6), dpi=80)\n",
        "plt.plot(epochs, loss_hist, '#1f77b4', epochs, vloss_hist, '#ff8010', lw=1.5)\n",
        "\n",
        "# minimum validation loss point\n",
        "plt.plot([3, 3], [0, 0.4], 'r--', lw=2)\n",
        "\n",
        "# draw the figure + miscs\n",
        "plt.xlabel('epoch')\n",
        "plt.ylabel('loss')\n",
        "plt.legend(['loss', 'val_loss', 'optimal vloss'])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBdM5g7Ww2m7"
      },
      "source": [
        "# 4. Examples of FaceCNN Classification"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "2-BB-Vf0w2m8",
        "outputId": "150ba386-d6db-4d18-8420-0fb70a048aed"
      },
      "outputs": [],
      "source": [
        "showcase_dataset = FaceDataset(root_dir='facenet-main/data/samples', img_dim=Config.img_dim)\n",
        "showcase_loader = showcase_dataset.get_data_loader(batch_size=5, use_shuffle=True)\n",
        "\n",
        "with torch.no_grad():\n",
        "    images, labels, _ = next(iter(showcase_loader))\n",
        "    images, labels = images.to(device), labels.to(device)\n",
        "    out_labels = face_model(images)\n",
        "    preds = torch.argmax(out_labels.data, dim=1)\n",
        "\n",
        "images, labels = images.cpu(), labels.cpu()\n",
        "for img, label, pred in zip(images, labels, preds):\n",
        "    if pred == label:\n",
        "        plt.title(f'(correct) {FaceDataset.label_to_str[label]}')\n",
        "    else:\n",
        "        plt.title(f'(wrong) {FaceDataset.label_to_str[pred]}', color='red')\n",
        "    plt.imshow(img.permute(1, 2, 0).numpy())\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Y9ivlrgw2m8"
      },
      "source": [
        "# 5. FaceCNN Performance on out of Distribution Images\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "puomM051w2m8"
      },
      "outputs": [],
      "source": [
        "# testing the model with images that have never trained for before. It is from a comepletly different dataset that was not part of any of my training/validation/testing datasets.\n",
        "\n",
        "new_dataset = FaceDataset(root_dir='facenet-main/data/new', img_dim=Config.img_dim)\n",
        "new_loader = new_dataset.get_data_loader(batch_size=1, use_shuffle=False)\n",
        "new_metrics = Metrics()\n",
        "\n",
        "with torch.no_grad():\n",
        "    for data in new_loader:\n",
        "        images, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "        out_labels = face_model(images)\n",
        "        preds = torch.argmax(out_labels.data, dim=1)\n",
        "\n",
        "        new_metrics.y_pred.extend(preds.data.cpu().numpy())\n",
        "        new_metrics.y_true.extend(labels.data.cpu().numpy())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AFxXRfgnw2m8"
      },
      "source": [
        "### Metrics"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lo7gmJ9sw2m8",
        "outputId": "394c5e04-a98e-4643-fe52-24e44827cabf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "accuracy: 0.548\n",
            "recall: 0.548\n",
            "precision: 0.999\n",
            "f1: 0.707\n"
          ]
        }
      ],
      "source": [
        "new_metrics.print_metrics()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "trqgPPTkw2m8"
      },
      "source": [
        "### Confusion Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 745
        },
        "id": "KCLanjI5w2m9",
        "outputId": "fede4845-5115-429c-c9d9-31298b08318f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 936x576 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "new_metrics.plot_confusion_matrix()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SvC-o1IoQzhD"
      },
      "source": [
        "# 6. Visualizing  FaceCNN's Filters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MSk79N9vQ9Ig"
      },
      "outputs": [],
      "source": [
        "# source: COMP6321/lab5-exercises\n",
        "\n",
        "def plot_matrix_grid(V, title, cmap='bwr'):\n",
        "    \"\"\"\n",
        "    Given an array V containing stacked matrices, plots them in a grid layout.\n",
        "    V should have shape (K,M,N) where V[k] is a matrix of shape (M,N).\n",
        "    The default cmap is \"bwr\" (blue-white-red) but can also be \"gray\".\n",
        "    \"\"\"\n",
        "    if isinstance(V, torch.Tensor):\n",
        "        V = V.detach().numpy()\n",
        "    assert V.ndim == 3, \"Expected V to have 3 dimensions, not %d\" % V.ndim\n",
        "    k, m, n = V.shape\n",
        "    ncol = 8                                     # At most 8 columns\n",
        "    nrow = min(4, (k + ncol - 1) // ncol)        # At most 4 rows\n",
        "    V = V[:nrow * ncol]                            # Focus on just the matrices we'll actually plot\n",
        "    figsize = (2 * ncol, max(1, 2 * nrow * (m / n)))     # Guess a good figure shape based on ncol, nrow\n",
        "    fig, axes = plt.subplots(nrow, ncol, sharex=True, sharey=True, figsize=figsize)\n",
        "    fig.suptitle(title)\n",
        "    vmax = np.percentile(np.abs(V), [99.9])      # Show the main range of values, between 0.1%-99.9%\n",
        "    for v, ax in zip(V, axes.flat):\n",
        "        img = ax.matshow(v, vmin=-vmax, vmax=vmax, cmap=plt.get_cmap(cmap))\n",
        "        ax.set_xticks([])\n",
        "        ax.set_yticks([])\n",
        "    for ax in axes.flat[len(V):]:\n",
        "        ax.set_axis_off()\n",
        "    fig.colorbar(img, cax=fig.add_axes([0.92, 0.25, 0.01, .5]))   # Add a colorbar on the right"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "7JBn39SSQ-s3",
        "outputId": "2e1e7ce9-3de0-411d-a0b5-f552e5162b44"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1152x576 with 33 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1152x576 with 33 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1152x576 with 33 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1152x576 with 33 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "filter_indices = [0, 4, 8, 12]\n",
        "filter_size = {0: 5, 4: 5, 8: 3, 12: 3}\n",
        "params = copy.deepcopy(face_model).cpu().parameters()\n",
        "\n",
        "for idx, W in enumerate(params):\n",
        "    if idx in filter_indices:\n",
        "        title = f'filter={idx//4}, size=({filter_size[idx]}, {filter_size[idx]})'\n",
        "        plot_matrix_grid(W.reshape(-1, filter_size[idx], filter_size[idx]), title)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "DHS28By1w2mr",
        "j54djPLL4PTP",
        "r2LMUUX84Xwq",
        "Cz7zBkTFw2m4",
        "qsh1c_dKw2m4",
        "Rf__d6j-w2m6",
        "g4d3eoEcw2m7",
        "YIg-A5Q_H21X",
        "up2xct2zw2m7",
        "oBdM5g7Ww2m7",
        "-Y9ivlrgw2m8",
        "SvC-o1IoQzhD"
      ],
      "name": "notebook_real_face_detector.ipynb",
      "provenance": []
    },
    "interpreter": {
      "hash": "678a7f023a315869c539266b01a0b2637ddd14761bfd019fe41760ec4e9d6b8e"
    },
    "kernelspec": {
      "display_name": "Python 3.9.7 64-bit ('base': conda)",
      "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.8.12"
    },
    "orig_nbformat": 4
  },
  "nbformat": 4,
  "nbformat_minor": 0
}