diff --git a/AI-Model and API b/AI-Model and API
new file mode 160000
index 00000000..883e1e97
--- /dev/null
+++ b/AI-Model and API	
@@ -0,0 +1 @@
+Subproject commit 883e1e97844dd3c63c5a87bd286023f360d59006
diff --git a/Crowdsource-Android-App b/Crowdsource-Android-App
new file mode 160000
index 00000000..a4e8fd8b
--- /dev/null
+++ b/Crowdsource-Android-App
@@ -0,0 +1 @@
+Subproject commit a4e8fd8bb0bdf3bd4f2f3706ee94e79aa4c17d01
diff --git a/Facial Time Machine.ipynb b/Facial Time Machine.ipynb
new file mode 100644
index 00000000..1c43e505
--- /dev/null
+++ b/Facial Time Machine.ipynb	
@@ -0,0 +1,535 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "OD8CMI2MXVeX"
+      },
+      "source": [
+        "import os\n",
+        "CODE_DIR = 'SAM'"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NaQHnk5UXZNH",
+        "outputId": "0095c167-4bb1-4e79-b8b9-aec289b771f1"
+      },
+      "source": [
+        "!git clone https://github.com/yuval-alaluf/SAM.git $CODE_DIR"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cloning into 'SAM'...\n",
+            "remote: Enumerating objects: 228, done.\u001b[K\n",
+            "remote: Counting objects: 100% (36/36), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (23/23), done.\u001b[K\n",
+            "remote: Total 228 (delta 22), reused 13 (delta 13), pack-reused 192\u001b[K\n",
+            "Receiving objects: 100% (228/228), 24.63 MiB | 26.49 MiB/s, done.\n",
+            "Resolving deltas: 100% (75/75), done.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Srity6sPXbup",
+        "outputId": "6281b843-d86d-4ada-8c3d-a9249c93ad65"
+      },
+      "source": [
+        "!wget https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip\n",
+        "!sudo unzip ninja-linux.zip -d /usr/local/bin/\n",
+        "!sudo update-alternatives --install /usr/bin/ninja ninja /usr/local/bin/ninja 1 --force"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "--2023-02-05 03:21:09--  https://github.com/ninja-build/ninja/releases/download/v1.8.2/ninja-linux.zip\n",
+            "Resolving github.com (github.com)... 140.82.121.3\n",
+            "Connecting to github.com (github.com)|140.82.121.3|:443... connected.\n",
+            "HTTP request sent, awaiting response... 302 Found\n",
+            "Location: https://objects.githubusercontent.com/github-production-release-asset-2e65be/1335132/d2f252e2-9801-11e7-9fbf-bc7b4e4b5c83?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20230205%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20230205T032109Z&X-Amz-Expires=300&X-Amz-Signature=a944970563a3020bc55b9f45761d9d366b389c8c194e645d897a322199030577&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=1335132&response-content-disposition=attachment%3B%20filename%3Dninja-linux.zip&response-content-type=application%2Foctet-stream [following]\n",
+            "--2023-02-05 03:21:09--  https://objects.githubusercontent.com/github-production-release-asset-2e65be/1335132/d2f252e2-9801-11e7-9fbf-bc7b4e4b5c83?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20230205%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20230205T032109Z&X-Amz-Expires=300&X-Amz-Signature=a944970563a3020bc55b9f45761d9d366b389c8c194e645d897a322199030577&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=1335132&response-content-disposition=attachment%3B%20filename%3Dninja-linux.zip&response-content-type=application%2Foctet-stream\n",
+            "Resolving objects.githubusercontent.com (objects.githubusercontent.com)... 185.199.111.133, 185.199.108.133, 185.199.110.133, ...\n",
+            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.111.133|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 77854 (76K) [application/octet-stream]\n",
+            "Saving to: ‘ninja-linux.zip’\n",
+            "\n",
+            "ninja-linux.zip     100%[===================>]  76.03K  --.-KB/s    in 0.004s  \n",
+            "\n",
+            "2023-02-05 03:21:10 (17.7 MB/s) - ‘ninja-linux.zip’ saved [77854/77854]\n",
+            "\n",
+            "Archive:  ninja-linux.zip\n",
+            "replace /usr/local/bin/ninja? [y]es, [n]o, [A]ll, [N]one, [r]ename: y\n",
+            "  inflating: /usr/local/bin/ninja    \n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "a7kydgdNXeSj"
+      },
+      "source": [
+        "os.chdir(f'./{CODE_DIR}')"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Mcdhx4deXjgu"
+      },
+      "source": [
+        "from argparse import Namespace\n",
+        "import os\n",
+        "import sys\n",
+        "import pprint\n",
+        "import numpy as np\n",
+        "from PIL import Image\n",
+        "import torch\n",
+        "import torchvision.transforms as transforms\n",
+        "\n",
+        "sys.path.append(\".\")\n",
+        "sys.path.append(\"..\")\n",
+        "\n",
+        "from datasets.augmentations import AgeTransformer\n",
+        "from utils.common import tensor2im\n",
+        "from models.psp import pSp"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ZLBabswEXmjx"
+      },
+      "source": [
+        "EXPERIMENT_TYPE = 'ffhq_aging'"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "PUUxbSlqYXWa"
+      },
+      "source": [
+        "def get_download_model_command(file_id, file_name):\n",
+        "    \"\"\" Get wget download command for downloading the desired model and save to directory ../pretrained_models. \"\"\"\n",
+        "    current_directory = os.getcwd()\n",
+        "    save_path = os.path.join(os.path.dirname(current_directory), \"pretrained_models\")\n",
+        "    if not os.path.exists(save_path):\n",
+        "        os.makedirs(save_path)\n",
+        "    url = r\"\"\"wget --load-cookies /tmp/cookies.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={FILE_ID}' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\\1\\n/p')&id={FILE_ID}\" -O {SAVE_PATH}/{FILE_NAME} && rm -rf /tmp/cookies.txt\"\"\".format(FILE_ID=file_id, FILE_NAME=file_name, SAVE_PATH=save_path)\n",
+        "    return url\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "rn98m9iwYaIN"
+      },
+      "source": [
+        "MODEL_PATHS = {\n",
+        "    \"ffhq_aging\": {\"id\": \"1XyumF6_fdAxFmxpFcmPf-q84LU_22EMC\", \"name\": \"sam_ffhq_aging.pt\"}\n",
+        "}\n",
+        "\n",
+        "path = MODEL_PATHS[EXPERIMENT_TYPE]\n",
+        "download_command = get_download_model_command(file_id=path[\"id\"], file_name=path[\"name\"])\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "asa6eedQYccO",
+        "outputId": "8bb43356-642a-4dfa-d97d-eac66e17b7e1"
+      },
+      "source": [
+        "!wget {download_command}"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "--2023-02-05 03:27:47--  http://wget/\n",
+            "Resolving wget (wget)... failed: Name or service not known.\n",
+            "wget: unable to resolve host address ‘wget’\n",
+            "--2023-02-05 03:27:47--  https://docs.google.com/uc?export=download&confirm=t&id=1XyumF6_fdAxFmxpFcmPf-q84LU_22EMC\n",
+            "Resolving docs.google.com (docs.google.com)... 172.217.218.102, 172.217.218.100, 172.217.218.138, ...\n",
+            "Connecting to docs.google.com (docs.google.com)|172.217.218.102|:443... connected.\n",
+            "HTTP request sent, awaiting response... 303 See Other\n",
+            "Location: https://doc-00-8g-docs.googleusercontent.com/docs/securesc/ha0ro937gcuc7l7deffksulhg5h7mbp1/nmhsufr9asnkt6t4e43tb186e240vbj0/1675567650000/05457687429326987275/*/1XyumF6_fdAxFmxpFcmPf-q84LU_22EMC?e=download&uuid=fe418e49-1b95-4b7f-ae3e-6a9fca5ec7b4 [following]\n",
+            "Warning: wildcards not supported in HTTP.\n",
+            "--2023-02-05 03:27:47--  https://doc-00-8g-docs.googleusercontent.com/docs/securesc/ha0ro937gcuc7l7deffksulhg5h7mbp1/nmhsufr9asnkt6t4e43tb186e240vbj0/1675567650000/05457687429326987275/*/1XyumF6_fdAxFmxpFcmPf-q84LU_22EMC?e=download&uuid=fe418e49-1b95-4b7f-ae3e-6a9fca5ec7b4\n",
+            "Resolving doc-00-8g-docs.googleusercontent.com (doc-00-8g-docs.googleusercontent.com)... 108.177.119.132, 2a00:1450:4013:c00::84\n",
+            "Connecting to doc-00-8g-docs.googleusercontent.com (doc-00-8g-docs.googleusercontent.com)|108.177.119.132|:443... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 2270547237 (2.1G) [application/x-zip]\n",
+            "Saving to: ‘/content/SAM/pretrained_models/sam_ffhq_aging.pt’\n",
+            "\n",
+            "/content/SAM/pretra 100%[===================>]   2.11G   235MB/s    in 9.0s    \n",
+            "\n",
+            "2023-02-05 03:27:56 (241 MB/s) - ‘/content/SAM/pretrained_models/sam_ffhq_aging.pt’ saved [2270547237/2270547237]\n",
+            "\n",
+            "FINISHED --2023-02-05 03:27:56--\n",
+            "Total wall clock time: 9.4s\n",
+            "Downloaded: 1 files, 2.1G in 9.0s (241 MB/s)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "7dRtoTDlYgEi",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 235
+        },
+        "outputId": "86b54d91-5a5d-4bd7-84e3-b169f0ac7b87"
+      },
+      "source": [
+        "EXPERIMENT_DATA_ARGS = {\n",
+        "    \"ffhq_aging\": {\n",
+        "        \"model_path\": \"../pretrained_models/sam_ffhq_aging.pt\",\n",
+        "        \"image_path\": \"/content/2bab40b8-a4f9-11ed-b16a-e8ebb8d73a51.jpg\",\n",
+        "        \"transform\": transforms.Compose([\n",
+        "            transforms.Resize((256, 256)),\n",
+        "            transforms.ToTensor(),\n",
+        "            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])])\n",
+        "    }\n",
+        "}"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "NameError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-21-15efa9eb5786>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0;34m\"model_path\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"../pretrained_models/sam_ffhq_aging.pt\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0;34m\"image_path\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m\"/content/2bab40b8-a4f9-11ed-b16a-e8ebb8d73a51.jpg\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \"transform\": transforms.Compose([\n\u001b[0m\u001b[1;32m      6\u001b[0m             \u001b[0mtransforms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mResize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m256\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m256\u001b[0m\u001b[0;34m)\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      7\u001b[0m             \u001b[0mtransforms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mToTensor\u001b[0m\u001b[0;34m(\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;31mNameError\u001b[0m: name 'transforms' is not defined"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "AIsKgGGuYppr"
+      },
+      "source": [
+        "EXPERIMENT_ARGS = EXPERIMENT_DATA_ARGS[EXPERIMENT_TYPE]"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "90UnEATNYsa4"
+      },
+      "source": [
+        "model_path = EXPERIMENT_ARGS['model_path']\n",
+        "ckpt = torch.load(model_path, map_location='cpu')"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "paYMdO6hYvF7"
+      },
+      "source": [
+        "opts = ckpt['opts']\n",
+        "pprint.pprint(opts)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ZrF9FrIsYyjz"
+      },
+      "source": [
+        "# update the training options\n",
+        "opts['checkpoint_path'] = model_path\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "oP8EV9OGY4fD"
+      },
+      "source": [
+        "opts = Namespace(**opts)\n",
+        "net = pSp(opts)\n",
+        "net.eval()\n",
+        "net.cuda()\n",
+        "print('Model successfully loaded!')\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "7jAJwxVgY6zO"
+      },
+      "source": [
+        "image_path = EXPERIMENT_DATA_ARGS[EXPERIMENT_TYPE][\"image_path\"]\n",
+        "#image_path = \"\"\n",
+        "original_image = Image.open(image_path).convert(\"RGB\")\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "9Kzk9Np4ZAGK",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 165
+        },
+        "outputId": "42d2663a-dcd1-4ef9-fa1b-d5ba65aa3342"
+      },
+      "source": [
+        "original_image.resize((256, 256))"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "NameError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-10-a6a0236c054a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0moriginal_image\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m256\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m256\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[0m",
+            "\u001b[0;31mNameError\u001b[0m: name 'original_image' is not defined"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "8iEj-Bp6ZDP3"
+      },
+      "source": [
+        "!wget http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2\n",
+        "!bzip2 -dk shape_predictor_68_face_landmarks.dat.bz2"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "8Y4ELBUCZGbk"
+      },
+      "source": [
+        "def run_alignment(image_path):\n",
+        "    import dlib\n",
+        "    from scripts.align_all_parallel import align_face\n",
+        "    predictor = dlib.shape_predictor(\"shape_predictor_68_face_landmarks.dat\")\n",
+        "    aligned_image = align_face(filepath=image_path, predictor=predictor) \n",
+        "    print(\"Aligned image has shape: {}\".format(aligned_image.size))\n",
+        "    return aligned_image\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "EtImx8F8ZMso"
+      },
+      "source": [
+        "aligned_image = run_alignment(image_path)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "ulCi4pCMZQEe"
+      },
+      "source": [
+        "aligned_image.resize((256, 256))"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "HEHEvbH_ZS1O"
+      },
+      "source": [
+        "img_transforms = EXPERIMENT_ARGS['transform']\n",
+        "input_image = img_transforms(aligned_image)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "H_TomdkEZXhl"
+      },
+      "source": [
+        "# we'll run the image on multiple target ages \n",
+        "target_ages = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
+        "age_transformers = [AgeTransformer(target_age=age) for age in target_ages]\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Hv6vefunZaea"
+      },
+      "source": [
+        "def run_on_batch(inputs, net):\n",
+        "    result_batch = net(inputs.to(\"cuda\").float(), randomize_noise=False, resize=False)\n",
+        "    return result_batch"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KvKcNQgBZdWG",
+        "outputId": "2e75548e-efea-4bd6-f179-cd12f3726722"
+      },
+      "source": [
+        "# for each age transformed age, we'll concatenate the results to display them side-by-side\n",
+        "results = np.array(aligned_image.resize((1024, 1024)))\n",
+        "for age_transformer in age_transformers:\n",
+        "    print(f\"Running on target age: {age_transformer.target_age}\")\n",
+        "    with torch.no_grad():\n",
+        "        input_image_age = [age_transformer(input_image.cpu()).to('cuda')]\n",
+        "        input_image_age = torch.stack(input_image_age)\n",
+        "        result_tensor = run_on_batch(input_image_age, net)[0]\n",
+        "        result_image = tensor2im(result_tensor)\n",
+        "        results = np.concatenate([results, result_image], axis=1)\n"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Running on target age: 0\n",
+            "Running on target age: 10\n",
+            "Running on target age: 20\n",
+            "Running on target age: 30\n",
+            "Running on target age: 40\n",
+            "Running on target age: 50\n",
+            "Running on target age: 60\n",
+            "Running on target age: 70\n",
+            "Running on target age: 80\n",
+            "Running on target age: 90\n",
+            "Running on target age: 100\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 182
+        },
+        "id": "c9x4JI9jZg1x",
+        "outputId": "34368be1-5d0f-4990-f7e5-19793fede3f5"
+      },
+      "source": [
+        "results = Image.fromarray(results)\n",
+        "results   # this is a very large image (11*1024 x 1024) so it may take some time to display!\n"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "NameError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-17-ae1892a1aa76>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfromarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresults\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      2\u001b[0m \u001b[0mresults\u001b[0m   \u001b[0;31m# this is a very large image (11*1024 x 1024) so it may take some time to display!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mNameError\u001b[0m: name 'results' is not defined"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "XV6UgM5tZkl6"
+      },
+      "source": [],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Facial Verification with a Siamese Network - Final.ipynb b/Facial Verification with a Siamese Network - Final.ipynb
new file mode 100644
index 00000000..96eaaeed
--- /dev/null
+++ b/Facial Verification with a Siamese Network - Final.ipynb	
@@ -0,0 +1,2298 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.1 Install Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: opencv-python in c:\\users\\sourav\\anaconda3\\lib\\site-packages (4.7.0.68)\n",
+      "Requirement already satisfied: matplotlib in c:\\users\\sourav\\anaconda3\\lib\\site-packages (3.4.3)\n",
+      "Requirement already satisfied: numpy>=1.17.0 in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from opencv-python) (1.20.3)\n",
+      "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from matplotlib) (2.8.2)\n",
+      "Requirement already satisfied: pyparsing>=2.2.1 in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from matplotlib) (3.0.4)\n",
+      "Requirement already satisfied: pillow>=6.2.0 in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from matplotlib) (8.4.0)\n",
+      "Requirement already satisfied: cycler>=0.10 in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from matplotlib) (0.10.0)\n",
+      "Requirement already satisfied: kiwisolver>=1.0.1 in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from matplotlib) (1.3.1)\n",
+      "Requirement already satisfied: six in c:\\users\\sourav\\anaconda3\\lib\\site-packages (from cycler>=0.10->matplotlib) (1.16.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install opencv-python matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install tensorflow"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.2 Import Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import standard dependencies\n",
+    "import cv2\n",
+    "import os\n",
+    "import random\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from tensorflow.keras.metrics import Precision, Recall"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import tensorflow dependencies - Functional API\n",
+    "import tensorflow as tf\n",
+    "from tensorflow.keras.models import Model\n",
+    "from tensorflow.keras.layers import Layer, Conv2D, Dense, MaxPooling2D, Input, Flatten"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.3 Set GPU Growth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Avoid OOM errors by setting GPU Memory Consumption Growth\n",
+    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
+    "for gpu in gpus: \n",
+    "    tf.config.experimental.set_memory_growth(gpu, True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.4 Create Folder Structures"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup paths\n",
+    "POS_PATH = os.path.join('data', 'positive')\n",
+    "NEG_PATH = os.path.join('data', 'negative')\n",
+    "ANC_PATH = os.path.join('data', 'anchor')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Make the directories\n",
+    "# os.makedirs(POS_PATH)\n",
+    "# os.makedirs(NEG_PATH)\n",
+    "# os.makedirs(ANC_PATH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2. Collect Positives and Anchors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.1 Untar Labelled Faces in the Wild Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# http://vis-www.cs.umass.edu/lfw/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uncompress Tar GZ Labelled Faces in the Wild Dataset\n",
+    "# !tar -xf lfw.tgz"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Move LFW Images to the following repository data/negative\n",
+    "# for directory in os.listdir('lfw'):\n",
+    "#     for file in os.listdir(os.path.join('lfw', directory)):\n",
+    "#         EX_PATH = os.path.join('lfw', directory, file)\n",
+    "#         NEW_PATH = os.path.join(NEG_PATH, file)\n",
+    "#         os.replace(EX_PATH, NEW_PATH)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2.2 Collect Positive and Anchor Classes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import uuid library to generate unique image names\n",
+    "import uuid"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'data\\\\anchor\\\\aca898df-a4fe-11ed-aa94-e612441dc9c1.jpg'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.path.join(ANC_PATH, '{}.jpg'.format(uuid.uuid1()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Establish a connection to the webcam\n",
+    "verf = './application_data/verification_images/'\n",
+    "cap = cv2.VideoCapture(0)\n",
+    "while cap.isOpened(): \n",
+    "    ret, frame = cap.read()\n",
+    "   \n",
+    "    # Cut down frame to 250x250px\n",
+    "    frame = frame[120:120+250,200:200+250, :]\n",
+    "    \n",
+    "    # Collect anchors \n",
+    "    if cv2.waitKey(1) & 0XFF == ord('a'):\n",
+    "        # Create the unique file path \n",
+    "        imgname = os.path.join(ANC_PATH, '{}.jpg'.format(uuid.uuid1()))\n",
+    "        # Write out anchor image\n",
+    "        cv2.imwrite(imgname, frame)\n",
+    "    \n",
+    "    # Collect positives\n",
+    "    if cv2.waitKey(1) & 0XFF == ord('p'):\n",
+    "        # Create the unique file path \n",
+    "        imgname = os.path.join(POS_PATH, '{}.jpg'.format(uuid.uuid1()))\n",
+    "        # Write out positive image\n",
+    "        cv2.imwrite(imgname, frame)\n",
+    "    \n",
+    "    # Show image back to screen\n",
+    "    cv2.imshow('Image Collection', frame)\n",
+    "    \n",
+    "    # Breaking gracefully\n",
+    "    if cv2.waitKey(1) & 0XFF == ord('q'):\n",
+    "        break\n",
+    "        \n",
+    "# Release the webcam\n",
+    "cap.release()\n",
+    "# Close the image show frame\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2.x NEW - Data Augmentation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def data_aug(img):\n",
+    "    data = []\n",
+    "    for i in range(9):\n",
+    "        img = tf.image.stateless_random_brightness(img, max_delta=0.02, seed=(1,2))\n",
+    "        img = tf.image.stateless_random_contrast(img, lower=0.6, upper=1, seed=(1,3))\n",
+    "        # img = tf.image.stateless_random_crop(img, size=(20,20,3), seed=(1,2))\n",
+    "        img = tf.image.stateless_random_flip_left_right(img, seed=(np.random.randint(100),np.random.randint(100)))\n",
+    "        img = tf.image.stateless_random_jpeg_quality(img, min_jpeg_quality=90, max_jpeg_quality=100, seed=(np.random.randint(100),np.random.randint(100)))\n",
+    "        img = tf.image.stateless_random_saturation(img, lower=0.9,upper=1, seed=(np.random.randint(100),np.random.randint(100)))\n",
+    "            \n",
+    "        data.append(img)\n",
+    "    \n",
+    "    return data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import uuid"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_path = os.path.join(ANC_PATH, '1a58fcac-a479-11ed-b957-e8ebb8d73a51.jpg')\n",
+    "img = cv2.imread(img_path)\n",
+    "augmented_images = data_aug(img)\n",
+    "\n",
+    "for image in augmented_images:\n",
+    "    cv2.imwrite(os.path.join(ANC_PATH, '{}.jpg'.format(uuid.uuid1())), image.numpy())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "Attempt to convert a value (None) with an unsupported type (<class 'NoneType'>) to a Tensor.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn [29], line 4\u001b[0m\n\u001b[0;32m      2\u001b[0m img_path \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mjoin(POS_PATH, file_name)\n\u001b[0;32m      3\u001b[0m img \u001b[39m=\u001b[39m cv2\u001b[39m.\u001b[39mimread(img_path)\n\u001b[1;32m----> 4\u001b[0m augmented_images \u001b[39m=\u001b[39m data_aug(img) \n\u001b[0;32m      6\u001b[0m \u001b[39mfor\u001b[39;00m image \u001b[39min\u001b[39;00m augmented_images:\n\u001b[0;32m      7\u001b[0m     cv2\u001b[39m.\u001b[39mimwrite(os\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mjoin(POS_PATH, \u001b[39m'\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m.jpg\u001b[39m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(uuid\u001b[39m.\u001b[39muuid1())), image\u001b[39m.\u001b[39mnumpy())\n",
+      "Cell \u001b[1;32mIn [27], line 4\u001b[0m, in \u001b[0;36mdata_aug\u001b[1;34m(img)\u001b[0m\n\u001b[0;32m      2\u001b[0m data \u001b[39m=\u001b[39m []\n\u001b[0;32m      3\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m9\u001b[39m):\n\u001b[1;32m----> 4\u001b[0m     img \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39;49mimage\u001b[39m.\u001b[39;49mstateless_random_brightness(img, max_delta\u001b[39m=\u001b[39;49m\u001b[39m0.02\u001b[39;49m, seed\u001b[39m=\u001b[39;49m(\u001b[39m1\u001b[39;49m,\u001b[39m2\u001b[39;49m))\n\u001b[0;32m      5\u001b[0m     img \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mimage\u001b[39m.\u001b[39mstateless_random_contrast(img, lower\u001b[39m=\u001b[39m\u001b[39m0.6\u001b[39m, upper\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m, seed\u001b[39m=\u001b[39m(\u001b[39m1\u001b[39m,\u001b[39m3\u001b[39m))\n\u001b[0;32m      6\u001b[0m     \u001b[39m# img = tf.image.stateless_random_crop(img, size=(20,20,3), seed=(1,2))\u001b[39;00m\n",
+      "File \u001b[1;32mc:\\Users\\Sourav\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\tensorflow\\python\\util\\traceback_utils.py:153\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    151\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[0;32m    152\u001b[0m   filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[1;32m--> 153\u001b[0m   \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[0;32m    154\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[0;32m    155\u001b[0m   \u001b[39mdel\u001b[39;00m filtered_tb\n",
+      "File \u001b[1;32mc:\\Users\\Sourav\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\tensorflow\\python\\framework\\constant_op.py:102\u001b[0m, in \u001b[0;36mconvert_to_eager_tensor\u001b[1;34m(value, ctx, dtype)\u001b[0m\n\u001b[0;32m    100\u001b[0m     dtype \u001b[39m=\u001b[39m dtypes\u001b[39m.\u001b[39mas_dtype(dtype)\u001b[39m.\u001b[39mas_datatype_enum\n\u001b[0;32m    101\u001b[0m ctx\u001b[39m.\u001b[39mensure_initialized()\n\u001b[1;32m--> 102\u001b[0m \u001b[39mreturn\u001b[39;00m ops\u001b[39m.\u001b[39;49mEagerTensor(value, ctx\u001b[39m.\u001b[39;49mdevice_name, dtype)\n",
+      "\u001b[1;31mValueError\u001b[0m: Attempt to convert a value (None) with an unsupported type (<class 'NoneType'>) to a Tensor."
+     ]
+    }
+   ],
+   "source": [
+    "for file_name in os.listdir(os.path.join(POS_PATH)):\n",
+    "    img_path = os.path.join(POS_PATH, file_name)\n",
+    "    img = cv2.imread(img_path)\n",
+    "    augmented_images = data_aug(img) \n",
+    "    \n",
+    "    for image in augmented_images:\n",
+    "        cv2.imwrite(os.path.join(POS_PATH, '{}.jpg'.format(uuid.uuid1())), image.numpy())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 3. Load and Preprocess Images"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.1 Get Image Directories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "anchor = tf.data.Dataset.list_files(ANC_PATH+'\\*.jpg').take(3000)\n",
+    "positive = tf.data.Dataset.list_files(POS_PATH+'\\*.jpg').take(3000)\n",
+    "negative = tf.data.Dataset.list_files(NEG_PATH+'\\*.jpg').take(3000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dir_test = anchor.as_numpy_iterator()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "b'data\\\\anchor\\\\8dad0b99-a48d-11ed-8c3e-e8ebb8d73a51.jpg'\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(dir_test.next())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.2 Preprocessing - Scale and Resize"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocess(file_path):\n",
+    "    \n",
+    "    # Read in image from file path\n",
+    "    byte_img = tf.io.read_file(file_path)\n",
+    "    # Load in the image \n",
+    "    img = tf.io.decode_jpeg(byte_img)\n",
+    "    \n",
+    "    # Preprocessing steps - resizing the image to be 100x100x3\n",
+    "    img = tf.image.resize(img, (100,100))\n",
+    "    # Scale image to be between 0 and 1 \n",
+    "    img = img / 255.0\n",
+    "\n",
+    "    # Return image\n",
+    "    return img"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "img = preprocess('data\\\\anchor\\\\2ca573e3-a479-11ed-8255-e8ebb8d73a51.jpg')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.7134804"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "img.numpy().max() "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dataset.map(preprocess)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.3 Create Labelled Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# (anchor, positive) => 1,1,1,1,1\n",
+    "# (anchor, negative) => 0,0,0,0,0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "positives = tf.data.Dataset.zip((anchor, positive, tf.data.Dataset.from_tensor_slices(tf.ones(len(anchor)))))\n",
+    "negatives = tf.data.Dataset.zip((anchor, negative, tf.data.Dataset.from_tensor_slices(tf.zeros(len(anchor)))))\n",
+    "data = positives.concatenate(negatives)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "samples = data.as_numpy_iterator()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exampple = samples.next()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(b'data\\\\anchor\\\\8dad0b99-a48d-11ed-8c3e-e8ebb8d73a51.jpg',\n",
+       " b'data\\\\positive\\\\34e2cb61-a4f9-11ed-bdd8-e8ebb8d73a51.jpg',\n",
+       " 1.0)"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "exampple"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3.4 Build Train and Test Partition"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def preprocess_twin(input_img, validation_img, label):\n",
+    "    return(preprocess(input_img), preprocess(validation_img), label)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = preprocess_twin(*exampple)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x1ff97a7a310>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(res[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.0"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res[2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Build dataloader pipeline\n",
+    "data = data.map(preprocess_twin)\n",
+    "data = data.cache()\n",
+    "data = data.shuffle(buffer_size=10000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Training partition\n",
+    "train_data = data.take(round(len(data)*.7))\n",
+    "train_data = train_data.batch(16)\n",
+    "train_data = train_data.prefetch(8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Testing partition\n",
+    "test_data = data.skip(round(len(data)*.7))\n",
+    "test_data = test_data.take(round(len(data)*.3))\n",
+    "test_data = test_data.batch(16)\n",
+    "test_data = test_data.prefetch(8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 4. Model Engineering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.1 Build Embedding Layer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inp = Input(shape=(100,100,3), name='input_image')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c1 = Conv2D(64, (10,10), activation='relu')(inp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m1 = MaxPooling2D(64, (2,2), padding='same')(c1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c2 = Conv2D(128, (7,7), activation='relu')(m1)\n",
+    "m2 = MaxPooling2D(64, (2,2), padding='same')(c2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c3 = Conv2D(128, (4,4), activation='relu')(m2)\n",
+    "m3 = MaxPooling2D(64, (2,2), padding='same')(c3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "c4 = Conv2D(256, (4,4), activation='relu')(m3)\n",
+    "f1 = Flatten()(c4)\n",
+    "d1 = Dense(4096, activation='sigmoid')(f1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mod = Model(inputs=[inp], outputs=[d1], name='embedding')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"embedding\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " input_image (InputLayer)    [(None, 100, 100, 3)]     0         \n",
+      "                                                                 \n",
+      " conv2d (Conv2D)             (None, 91, 91, 64)        19264     \n",
+      "                                                                 \n",
+      " max_pooling2d (MaxPooling2D  (None, 46, 46, 64)       0         \n",
+      " )                                                               \n",
+      "                                                                 \n",
+      " conv2d_1 (Conv2D)           (None, 40, 40, 128)       401536    \n",
+      "                                                                 \n",
+      " max_pooling2d_1 (MaxPooling  (None, 20, 20, 128)      0         \n",
+      " 2D)                                                             \n",
+      "                                                                 \n",
+      " conv2d_2 (Conv2D)           (None, 17, 17, 128)       262272    \n",
+      "                                                                 \n",
+      " max_pooling2d_2 (MaxPooling  (None, 9, 9, 128)        0         \n",
+      " 2D)                                                             \n",
+      "                                                                 \n",
+      " conv2d_3 (Conv2D)           (None, 6, 6, 256)         524544    \n",
+      "                                                                 \n",
+      " flatten (Flatten)           (None, 9216)              0         \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 4096)              37752832  \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 38,960,448\n",
+      "Trainable params: 38,960,448\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "mod.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_embedding(): \n",
+    "    inp = Input(shape=(100,100,3), name='input_image')\n",
+    "    \n",
+    "    # First block\n",
+    "    c1 = Conv2D(64, (10,10), activation='relu')(inp)\n",
+    "    m1 = MaxPooling2D(64, (2,2), padding='same')(c1)\n",
+    "    \n",
+    "    # Second block\n",
+    "    c2 = Conv2D(128, (7,7), activation='relu')(m1)\n",
+    "    m2 = MaxPooling2D(64, (2,2), padding='same')(c2)\n",
+    "    \n",
+    "    # Third block \n",
+    "    c3 = Conv2D(128, (4,4), activation='relu')(m2)\n",
+    "    m3 = MaxPooling2D(64, (2,2), padding='same')(c3)\n",
+    "    \n",
+    "    # Final embedding block\n",
+    "    c4 = Conv2D(256, (4,4), activation='relu')(m3)\n",
+    "    f1 = Flatten()(c4)\n",
+    "    d1 = Dense(4096, activation='sigmoid')(f1)\n",
+    "    \n",
+    "    \n",
+    "    return Model(inputs=[inp], outputs=[d1], name='embedding')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embedding = make_embedding()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"embedding\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " input_image (InputLayer)    [(None, 100, 100, 3)]     0         \n",
+      "                                                                 \n",
+      " conv2d_4 (Conv2D)           (None, 91, 91, 64)        19264     \n",
+      "                                                                 \n",
+      " max_pooling2d_3 (MaxPooling  (None, 46, 46, 64)       0         \n",
+      " 2D)                                                             \n",
+      "                                                                 \n",
+      " conv2d_5 (Conv2D)           (None, 40, 40, 128)       401536    \n",
+      "                                                                 \n",
+      " max_pooling2d_4 (MaxPooling  (None, 20, 20, 128)      0         \n",
+      " 2D)                                                             \n",
+      "                                                                 \n",
+      " conv2d_6 (Conv2D)           (None, 17, 17, 128)       262272    \n",
+      "                                                                 \n",
+      " max_pooling2d_5 (MaxPooling  (None, 9, 9, 128)        0         \n",
+      " 2D)                                                             \n",
+      "                                                                 \n",
+      " conv2d_7 (Conv2D)           (None, 6, 6, 256)         524544    \n",
+      "                                                                 \n",
+      " flatten_1 (Flatten)         (None, 9216)              0         \n",
+      "                                                                 \n",
+      " dense_1 (Dense)             (None, 4096)              37752832  \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 38,960,448\n",
+      "Trainable params: 38,960,448\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "embedding.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.2 Build Distance Layer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Siamese L1 Distance class\n",
+    "class L1Dist(Layer):\n",
+    "    \n",
+    "    # Init method - inheritance\n",
+    "    def __init__(self, **kwargs):\n",
+    "        super().__init__()\n",
+    "       \n",
+    "    # Magic happens here - similarity calculation\n",
+    "    def call(self, input_embedding, validation_embedding):\n",
+    "        return tf.math.abs(input_embedding - validation_embedding)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "l1 = L1Dist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<__main__.L1Dist at 0x1ff97ca3610>"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "l1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.3 Make Siamese Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_image = Input(name='input_img', shape=(100,100,3))\n",
+    "validation_image = Input(name='validation_img', shape=(100,100,3))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inp_embedding = embedding(input_image)\n",
+    "val_embedding = embedding(validation_image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "siamese_layer = L1Dist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "distances = siamese_layer(inp_embedding, val_embedding)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "classifier = Dense(1, activation='sigmoid')(distances)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<KerasTensor: shape=(None, 1) dtype=float32 (created by layer 'dense_2')>"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "siamese_network = Model(inputs=[input_image, validation_image], outputs=classifier, name='SiameseNetwork')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"SiameseNetwork\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
+      "==================================================================================================\n",
+      " input_img (InputLayer)         [(None, 100, 100, 3  0           []                               \n",
+      "                                )]                                                                \n",
+      "                                                                                                  \n",
+      " validation_img (InputLayer)    [(None, 100, 100, 3  0           []                               \n",
+      "                                )]                                                                \n",
+      "                                                                                                  \n",
+      " embedding (Functional)         (None, 4096)         38960448    ['input_img[0][0]',              \n",
+      "                                                                  'validation_img[0][0]']         \n",
+      "                                                                                                  \n",
+      " l1_dist_1 (L1Dist)             (None, 4096)         0           ['embedding[0][0]',              \n",
+      "                                                                  'embedding[1][0]']              \n",
+      "                                                                                                  \n",
+      " dense_2 (Dense)                (None, 1)            4097        ['l1_dist_1[0][0]']              \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 38,964,545\n",
+      "Trainable params: 38,964,545\n",
+      "Non-trainable params: 0\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "siamese_network.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def make_siamese_model(): \n",
+    "    \n",
+    "    # Anchor image input in the network\n",
+    "    input_image = Input(name='input_img', shape=(100,100,3))\n",
+    "    \n",
+    "    # Validation image in the network \n",
+    "    validation_image = Input(name='validation_img', shape=(100,100,3))\n",
+    "    \n",
+    "    # Combine siamese distance components\n",
+    "    siamese_layer = L1Dist()\n",
+    "    siamese_layer._name = 'distance'\n",
+    "    distances = siamese_layer(embedding(input_image), embedding(validation_image))\n",
+    "    \n",
+    "    # Classification layer \n",
+    "    classifier = Dense(1, activation='sigmoid')(distances)\n",
+    "    \n",
+    "    return Model(inputs=[input_image, validation_image], outputs=classifier, name='SiameseNetwork')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "siamese_model = make_siamese_model()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"SiameseNetwork\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
+      "==================================================================================================\n",
+      " input_img (InputLayer)         [(None, 100, 100, 3  0           []                               \n",
+      "                                )]                                                                \n",
+      "                                                                                                  \n",
+      " validation_img (InputLayer)    [(None, 100, 100, 3  0           []                               \n",
+      "                                )]                                                                \n",
+      "                                                                                                  \n",
+      " embedding (Functional)         (None, 4096)         38960448    ['input_img[0][0]',              \n",
+      "                                                                  'validation_img[0][0]']         \n",
+      "                                                                                                  \n",
+      " distance (L1Dist)              (None, 4096)         0           ['embedding[2][0]',              \n",
+      "                                                                  'embedding[3][0]']              \n",
+      "                                                                                                  \n",
+      " dense_3 (Dense)                (None, 1)            4097        ['distance[0][0]']               \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 38,964,545\n",
+      "Trainable params: 38,964,545\n",
+      "Non-trainable params: 0\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "siamese_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 5. Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5.1 Setup Loss and Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "binary_cross_loss = tf.losses.BinaryCrossentropy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "opt = tf.keras.optimizers.Adam(1e-4) # 0.0001"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5.2 Establish Checkpoints"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "checkpoint_dir = './training_checkpoints'\n",
+    "checkpoint_prefix = os.path.join(checkpoint_dir, 'ckpt')\n",
+    "checkpoint = tf.train.Checkpoint(opt=opt, siamese_model=siamese_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5.3 Build Train Step Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_batch = train_data.as_numpy_iterator()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_1 = test_batch.next()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = batch_1[:2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y = batch_1[2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 0., 1., 1., 1., 0., 0., 1., 0., 0., 0., 1., 1., 1., 0., 1.],\n",
+       "      dtype=float32)"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": true
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "tf.losses.BinaryCrossentropy??"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "@tf.function\n",
+    "def train_step(batch):\n",
+    "    \n",
+    "    # Record all of our operations \n",
+    "    with tf.GradientTape() as tape:     \n",
+    "        # Get anchor and positive/negative image\n",
+    "        X = batch[:2]\n",
+    "        # Get label\n",
+    "        y = batch[2]\n",
+    "        \n",
+    "        # Forward pass\n",
+    "        yhat = siamese_model(X, training=True)\n",
+    "        # Calculate loss\n",
+    "        loss = binary_cross_loss(y, yhat)\n",
+    "    print(loss)\n",
+    "        \n",
+    "    # Calculate gradients\n",
+    "    grad = tape.gradient(loss, siamese_model.trainable_variables)\n",
+    "    \n",
+    "    # Calculate updated weights and apply to siamese model\n",
+    "    opt.apply_gradients(zip(grad, siamese_model.trainable_variables))\n",
+    "        \n",
+    "    # Return loss\n",
+    "    return loss"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5.4 Build Training Loop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(data, EPOCHS):\n",
+    "    # Loop through epochs\n",
+    "    for epoch in range(1, EPOCHS+1):\n",
+    "        print('\\n Epoch {}/{}'.format(epoch, EPOCHS))\n",
+    "        progbar = tf.keras.utils.Progbar(len(data))\n",
+    "        \n",
+    "        # Creating a metric object \n",
+    "        r = Recall()\n",
+    "        p = Precision()\n",
+    "        \n",
+    "        # Loop through each batch\n",
+    "        for idx, batch in enumerate(data):\n",
+    "            # Run train step here\n",
+    "            loss = train_step(batch)\n",
+    "            yhat = siamese_model.predict(batch[:2])\n",
+    "            r.update_state(batch[2], yhat)\n",
+    "            p.update_state(batch[2], yhat) \n",
+    "            progbar.update(idx+1)\n",
+    "        print(loss.numpy(), r.result().numpy(), p.result().numpy())\n",
+    "        \n",
+    "        # Save checkpoints\n",
+    "        if epoch % 10 == 0: \n",
+    "            checkpoint.save(file_prefix=checkpoint_prefix)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5.5 Train the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "EPOCHS = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " Epoch 1/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 84s 21s/step\n",
+      "0.39036787 0.96428573 0.96428573\n",
+      "\n",
+      " Epoch 2/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 86s 21s/step\n",
+      "0.040561855 0.96428573 1.0\n",
+      "\n",
+      " Epoch 3/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 86s 21s/step\n",
+      "0.038797487 0.9677419 1.0\n",
+      "\n",
+      " Epoch 4/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 85s 20s/step\n",
+      "0.02457576 1.0 1.0\n",
+      "\n",
+      " Epoch 5/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 82s 20s/step\n",
+      "0.030483223 1.0 1.0\n",
+      "\n",
+      " Epoch 6/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 82s 20s/step\n",
+      "0.10010759 1.0 1.0\n",
+      "\n",
+      " Epoch 7/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 82s 20s/step\n",
+      "0.016131582 1.0 1.0\n",
+      "\n",
+      " Epoch 8/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 82s 20s/step\n",
+      "0.010235732 1.0 1.0\n",
+      "\n",
+      " Epoch 9/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "4/4 [==============================] - 82s 20s/step\n",
+      "0.06497081 1.0 1.0\n",
+      "\n",
+      " Epoch 10/10\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 1s 1s/step\n",
+      "4/4 [==============================] - 82s 20s/step\n",
+      "0.069501184 1.0 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "train(train_data, EPOCHS)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# 6. Evaluate Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6.1 Import Metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import metric calculations\n",
+    "from tensorflow.keras.metrics import Precision, Recall"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6.2 Make Predictions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get a batch of test data\n",
+    "test_input, test_val, y_true = test_data.as_numpy_iterator().next()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 2s 2s/step\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([[4.5400078e-04],\n",
+       "       [9.9768066e-01],\n",
+       "       [1.7855719e-02],\n",
+       "       [9.9999011e-01],\n",
+       "       [2.9639576e-03],\n",
+       "       [9.6954983e-01],\n",
+       "       [9.9904484e-01],\n",
+       "       [2.3532983e-04],\n",
+       "       [9.9708384e-01],\n",
+       "       [2.1792704e-03],\n",
+       "       [1.5288240e-02],\n",
+       "       [9.8961878e-01],\n",
+       "       [7.5721699e-01],\n",
+       "       [9.9840242e-01],\n",
+       "       [1.0814576e-03],\n",
+       "       [7.4720006e-03]], dtype=float32)"
+      ]
+     },
+     "execution_count": 69,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_hat = siamese_model.predict([test_input, test_val])\n",
+    "y_hat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0]"
+      ]
+     },
+     "execution_count": 70,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Post processing the results \n",
+    "[1 if prediction > 0.5 else 0 for prediction in y_hat ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0., 1., 0., 1., 0., 1., 1., 0., 1., 0., 0., 1., 1., 1., 0., 0.],\n",
+       "      dtype=float32)"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_true"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6.3 Calculate Metrics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.0"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Creating a metric object \n",
+    "m = Recall()\n",
+    "\n",
+    "# Calculating the recall value \n",
+    "m.update_state(y_true, y_hat)\n",
+    "\n",
+    "# Return Recall Result\n",
+    "m.result().numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.0"
+      ]
+     },
+     "execution_count": 73,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Creating a metric object \n",
+    "m = Precision()\n",
+    "\n",
+    "# Calculating the recall value \n",
+    "m.update_state(y_true, y_hat)\n",
+    "\n",
+    "# Return Recall Result\n",
+    "m.result().numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 2s 2s/step\n",
+      "1/1 [==============================] - 1s 1s/step\n",
+      "1.0 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "r = Recall()\n",
+    "p = Precision()\n",
+    "\n",
+    "for test_input, test_val, y_true in test_data.as_numpy_iterator():\n",
+    "    yhat = siamese_model.predict([test_input, test_val])\n",
+    "    r.update_state(y_true, yhat)\n",
+    "    p.update_state(y_true,yhat) \n",
+    "\n",
+    "print(r.result().numpy(), p.result().numpy())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6.4 Viz Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 576x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Set plot size \n",
+    "plt.figure(figsize=(8,8))\n",
+    "\n",
+    "# Set first subplot\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.imshow(test_input[0])\n",
+    "\n",
+    "# Set second subplot\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.imshow(test_val[0])\n",
+    "\n",
+    "# Renders cleanly\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 7. Save Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Save weights\n",
+    "siamese_model.save('siamesemodelv2.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "__main__.L1Dist"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "L1Dist"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Reload model \n",
+    "siamese_model = tf.keras.models.load_model('siamesemodelv2.h5', \n",
+    "                                   custom_objects={'L1Dist':L1Dist, 'BinaryCrossentropy':tf.losses.BinaryCrossentropy})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 1s 1s/step\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([[3.9459034e-03],\n",
+       "       [9.8961878e-01],\n",
+       "       [9.3292128e-03],\n",
+       "       [4.6054916e-03],\n",
+       "       [2.2639409e-03],\n",
+       "       [9.5317107e-01],\n",
+       "       [1.7855719e-02],\n",
+       "       [9.2743731e-01],\n",
+       "       [7.8594714e-04],\n",
+       "       [9.9768066e-01]], dtype=float32)"
+      ]
+     },
+     "execution_count": 79,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Make predictions with reloaded model\n",
+    "siamese_model.predict([test_input, test_val])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"SiameseNetwork\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
+      "==================================================================================================\n",
+      " input_img (InputLayer)         [(None, 100, 100, 3  0           []                               \n",
+      "                                )]                                                                \n",
+      "                                                                                                  \n",
+      " validation_img (InputLayer)    [(None, 100, 100, 3  0           []                               \n",
+      "                                )]                                                                \n",
+      "                                                                                                  \n",
+      " embedding (Functional)         (None, 4096)         38960448    ['input_img[0][0]',              \n",
+      "                                                                  'validation_img[0][0]']         \n",
+      "                                                                                                  \n",
+      " l1_dist_3 (L1Dist)             (None, 4096)         0           ['embedding[0][0]',              \n",
+      "                                                                  'embedding[1][0]']              \n",
+      "                                                                                                  \n",
+      " dense_3 (Dense)                (None, 1)            4097        ['l1_dist_3[0][0]']              \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 38,964,545\n",
+      "Trainable params: 38,964,545\n",
+      "Non-trainable params: 0\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "# View model summary\n",
+    "siamese_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 8. Real Time Test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8.1 Verification Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# application_data\\verification_images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 233,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['8fe09035-a48d-11ed-b032-e8ebb8d73a51.jpg',\n",
+       " '8fe17a94-a48d-11ed-8e17-e8ebb8d73a51.jpg',\n",
+       " '8fe8591f-a48d-11ed-8328-e8ebb8d73a51.jpg',\n",
+       " '8fe91c70-a48d-11ed-94f9-e8ebb8d73a51.jpg',\n",
+       " '94a28d3a-a48d-11ed-9eb9-e8ebb8d73a51.jpg',\n",
+       " '94a37735-a48d-11ed-a6c4-e8ebb8d73a51.jpg',\n",
+       " '94a599fe-a48d-11ed-b545-e8ebb8d73a51.jpg',\n",
+       " '94a65d5b-a48d-11ed-881a-e8ebb8d73a51.jpg',\n",
+       " '94a76ee0-a48d-11ed-ab16-e8ebb8d73a51.jpg',\n",
+       " '94a80b0d-a48d-11ed-8a8c-e8ebb8d73a51.jpg',\n",
+       " '94d12daf-a48d-11ed-ad9a-e8ebb8d73a51.jpg',\n",
+       " '94d217f4-a48d-11ed-aff8-e8ebb8d73a51.jpg',\n",
+       " '94d30239-a48d-11ed-aac8-e8ebb8d73a51.jpg',\n",
+       " '94d39e7a-a48d-11ed-9188-e8ebb8d73a51.jpg',\n",
+       " '94d43ae7-a48d-11ed-8587-e8ebb8d73a51.jpg',\n",
+       " '94d57351-a48d-11ed-a29a-e8ebb8d73a51.jpg',\n",
+       " '94d60f8e-a48d-11ed-89af-e8ebb8d73a51.jpg',\n",
+       " '94d6d330-a48d-11ed-84e8-e8ebb8d73a51.jpg',\n",
+       " '94d7bd4a-a48d-11ed-b2b5-e8ebb8d73a51.jpg',\n",
+       " '94fa1512-a48d-11ed-b1eb-e8ebb8d73a51.jpg',\n",
+       " '94fb4d92-a48d-11ed-b7f8-e8ebb8d73a51.jpg',\n",
+       " '94fbfdd4-a48d-11ed-a94d-e8ebb8d73a51.jpg',\n",
+       " '94fd0f74-a48d-11ed-9d22-e8ebb8d73a51.jpg',\n",
+       " '94fdf9ae-a48d-11ed-848a-e8ebb8d73a51.jpg',\n",
+       " '94fe95ef-a48d-11ed-a8ba-e8ebb8d73a51.jpg',\n",
+       " '94ff323e-a48d-11ed-9c48-e8ebb8d73a51.jpg',\n",
+       " '95a37f1e-a48d-11ed-a32d-e8ebb8d73a51.jpg',\n",
+       " '95a45776-a48d-11ed-9dd3-e8ebb8d73a51.jpg',\n",
+       " '95a4f3ae-a48d-11ed-8c9e-e8ebb8d73a51.jpg',\n",
+       " '95a5b709-a48d-11ed-b17d-e8ebb8d73a51.jpg',\n",
+       " '95a67a35-a48d-11ed-a18b-e8ebb8d73a51.jpg',\n",
+       " '95a764d9-a48d-11ed-b477-e8ebb8d73a51.jpg',\n",
+       " '95a8010a-a48d-11ed-a32c-e8ebb8d73a51.jpg',\n",
+       " '95a91274-a48d-11ed-8ebb-e8ebb8d73a51.jpg',\n",
+       " '95a9fcfb-a48d-11ed-b693-e8ebb8d73a51.jpg',\n",
+       " '95dbf615-a48d-11ed-b03f-e8ebb8d73a51.jpg',\n",
+       " '95dcb965-a48d-11ed-a076-e8ebb8d73a51.jpg',\n",
+       " '9a25ee75-a48d-11ed-8ec1-e8ebb8d73a51.jpg',\n",
+       " '9a26d8cd-a48d-11ed-bc66-e8ebb8d73a51.jpg',\n",
+       " '9a55f44f-a48d-11ed-858f-e8ebb8d73a51.jpg',\n",
+       " '9a57c98c-a48d-11ed-a49e-e8ebb8d73a51.jpg',\n",
+       " '9a824c4a-a48d-11ed-a579-e8ebb8d73a51.jpg',\n",
+       " '9a846f28-a48d-11ed-a715-e8ebb8d73a51.jpg',\n",
+       " '9a887ad0-a48d-11ed-a19f-e8ebb8d73a51.jpg']"
+      ]
+     },
+     "execution_count": 233,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.listdir(os.path.join('application_data', 'verification_images'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 234,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'application_data\\\\input_image\\\\input_image.jpg'"
+      ]
+     },
+     "execution_count": 234,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.path.join('application_data', 'input_image', 'input_image.jpg')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 235,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "application_data\\verification_images\\8fe09035-a48d-11ed-b032-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\8fe17a94-a48d-11ed-8e17-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\8fe8591f-a48d-11ed-8328-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\8fe91c70-a48d-11ed-94f9-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94a28d3a-a48d-11ed-9eb9-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94a37735-a48d-11ed-a6c4-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94a599fe-a48d-11ed-b545-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94a65d5b-a48d-11ed-881a-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94a76ee0-a48d-11ed-ab16-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94a80b0d-a48d-11ed-8a8c-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d12daf-a48d-11ed-ad9a-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d217f4-a48d-11ed-aff8-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d30239-a48d-11ed-aac8-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d39e7a-a48d-11ed-9188-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d43ae7-a48d-11ed-8587-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d57351-a48d-11ed-a29a-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d60f8e-a48d-11ed-89af-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d6d330-a48d-11ed-84e8-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94d7bd4a-a48d-11ed-b2b5-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94fa1512-a48d-11ed-b1eb-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94fb4d92-a48d-11ed-b7f8-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94fbfdd4-a48d-11ed-a94d-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94fd0f74-a48d-11ed-9d22-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94fdf9ae-a48d-11ed-848a-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94fe95ef-a48d-11ed-a8ba-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\94ff323e-a48d-11ed-9c48-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a37f1e-a48d-11ed-a32d-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a45776-a48d-11ed-9dd3-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a4f3ae-a48d-11ed-8c9e-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a5b709-a48d-11ed-b17d-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a67a35-a48d-11ed-a18b-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a764d9-a48d-11ed-b477-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a8010a-a48d-11ed-a32c-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a91274-a48d-11ed-8ebb-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95a9fcfb-a48d-11ed-b693-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95dbf615-a48d-11ed-b03f-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\95dcb965-a48d-11ed-a076-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a25ee75-a48d-11ed-8ec1-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a26d8cd-a48d-11ed-bc66-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a55f44f-a48d-11ed-858f-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a57c98c-a48d-11ed-a49e-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a824c4a-a48d-11ed-a579-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a846f28-a48d-11ed-a715-e8ebb8d73a51.jpg\n",
+      "application_data\\verification_images\\9a887ad0-a48d-11ed-a19f-e8ebb8d73a51.jpg\n"
+     ]
+    }
+   ],
+   "source": [
+    "for image in os.listdir(os.path.join('application_data', 'verification_images')):\n",
+    "    validation_img = os.path.join('application_data', 'verification_images', image)\n",
+    "    print(validation_img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 236,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def verify(model, detection_threshold, verification_threshold):\n",
+    "    # Build results array\n",
+    "    results = []\n",
+    "    for image in os.listdir(os.path.join('application_data', 'verification_images')):\n",
+    "        input_img = preprocess(os.path.join('application_data', 'input_image', 'input_image.jpg'))\n",
+    "        validation_img = preprocess(os.path.join('application_data', 'verification_images', image))\n",
+    "        \n",
+    "        # Make Predictions \n",
+    "        result = model.predict(list(np.expand_dims([input_img, validation_img], axis=1)))\n",
+    "        results.append(result)\n",
+    "    \n",
+    "    # Detection Threshold: Metric above which a prediciton is considered positive \n",
+    "    detection = np.sum(np.array(results) > detection_threshold)\n",
+    "    \n",
+    "    # Verification Threshold: Proportion of positive predictions / total positive samples \n",
+    "    verification = detection / len(os.listdir(os.path.join('application_data', 'verification_images'))) \n",
+    "    verified = verification > verification_threshold\n",
+    "    \n",
+    "    return results, verified"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8.2 OpenCV Real Time Verification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 241,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1/1 [==============================] - 0s 236ms/step\n",
+      "1/1 [==============================] - 0s 274ms/step\n",
+      "1/1 [==============================] - 0s 240ms/step\n",
+      "1/1 [==============================] - 0s 254ms/step\n",
+      "1/1 [==============================] - 0s 260ms/step\n",
+      "1/1 [==============================] - 0s 286ms/step\n",
+      "1/1 [==============================] - 0s 295ms/step\n",
+      "1/1 [==============================] - 0s 288ms/step\n",
+      "1/1 [==============================] - 0s 284ms/step\n",
+      "1/1 [==============================] - 0s 307ms/step\n",
+      "1/1 [==============================] - 0s 246ms/step\n",
+      "1/1 [==============================] - 0s 285ms/step\n",
+      "1/1 [==============================] - 0s 244ms/step\n",
+      "1/1 [==============================] - 0s 248ms/step\n",
+      "1/1 [==============================] - 0s 316ms/step\n",
+      "1/1 [==============================] - 0s 263ms/step\n",
+      "True\n",
+      "1/1 [==============================] - 0s 283ms/step\n",
+      "1/1 [==============================] - 0s 291ms/step\n",
+      "1/1 [==============================] - 0s 254ms/step\n",
+      "1/1 [==============================] - 0s 353ms/step\n",
+      "1/1 [==============================] - 0s 321ms/step\n",
+      "1/1 [==============================] - 0s 311ms/step\n",
+      "1/1 [==============================] - 0s 348ms/step\n",
+      "1/1 [==============================] - 0s 318ms/step\n",
+      "1/1 [==============================] - 0s 250ms/step\n",
+      "1/1 [==============================] - 0s 382ms/step\n",
+      "1/1 [==============================] - 0s 250ms/step\n",
+      "1/1 [==============================] - 0s 356ms/step\n",
+      "1/1 [==============================] - 0s 313ms/step\n",
+      "1/1 [==============================] - 0s 380ms/step\n",
+      "1/1 [==============================] - 0s 384ms/step\n",
+      "1/1 [==============================] - 0s 346ms/step\n",
+      "True\n",
+      "1/1 [==============================] - 0s 263ms/step\n",
+      "1/1 [==============================] - 0s 363ms/step\n",
+      "1/1 [==============================] - 0s 277ms/step\n",
+      "1/1 [==============================] - 0s 375ms/step\n",
+      "1/1 [==============================] - 0s 320ms/step\n",
+      "1/1 [==============================] - 0s 361ms/step\n",
+      "1/1 [==============================] - 0s 337ms/step\n",
+      "1/1 [==============================] - 0s 377ms/step\n",
+      "1/1 [==============================] - 0s 295ms/step\n",
+      "1/1 [==============================] - 0s 249ms/step\n",
+      "1/1 [==============================] - 0s 331ms/step\n",
+      "1/1 [==============================] - 0s 255ms/step\n",
+      "1/1 [==============================] - 0s 326ms/step\n",
+      "1/1 [==============================] - 0s 319ms/step\n",
+      "1/1 [==============================] - 0s 335ms/step\n",
+      "1/1 [==============================] - 0s 332ms/step\n",
+      "False\n",
+      "1/1 [==============================] - 0s 343ms/step\n",
+      "1/1 [==============================] - 0s 349ms/step\n",
+      "1/1 [==============================] - 0s 228ms/step\n",
+      "1/1 [==============================] - 0s 366ms/step\n",
+      "1/1 [==============================] - 0s 271ms/step\n",
+      "1/1 [==============================] - 0s 359ms/step\n",
+      "1/1 [==============================] - 0s 364ms/step\n",
+      "1/1 [==============================] - 0s 279ms/step\n",
+      "1/1 [==============================] - 0s 363ms/step\n",
+      "1/1 [==============================] - 0s 285ms/step\n",
+      "1/1 [==============================] - 0s 271ms/step\n",
+      "1/1 [==============================] - 0s 305ms/step\n",
+      "1/1 [==============================] - 0s 354ms/step\n",
+      "1/1 [==============================] - 0s 406ms/step\n",
+      "1/1 [==============================] - 0s 280ms/step\n",
+      "1/1 [==============================] - 0s 261ms/step\n",
+      "False\n",
+      "1/1 [==============================] - 0s 340ms/step\n",
+      "1/1 [==============================] - 0s 374ms/step\n",
+      "1/1 [==============================] - 0s 325ms/step\n",
+      "1/1 [==============================] - 0s 297ms/step\n",
+      "1/1 [==============================] - 0s 282ms/step\n",
+      "1/1 [==============================] - 0s 350ms/step\n",
+      "1/1 [==============================] - 0s 346ms/step\n",
+      "1/1 [==============================] - 0s 370ms/step\n",
+      "1/1 [==============================] - 0s 342ms/step\n",
+      "1/1 [==============================] - 0s 294ms/step\n",
+      "1/1 [==============================] - 0s 368ms/step\n",
+      "1/1 [==============================] - 0s 385ms/step\n",
+      "1/1 [==============================] - 0s 315ms/step\n",
+      "1/1 [==============================] - 0s 296ms/step\n",
+      "1/1 [==============================] - 0s 305ms/step\n",
+      "1/1 [==============================] - 0s 334ms/step\n",
+      "True\n",
+      "1/1 [==============================] - 0s 325ms/step\n",
+      "1/1 [==============================] - 0s 366ms/step\n",
+      "1/1 [==============================] - 0s 379ms/step\n",
+      "1/1 [==============================] - 0s 290ms/step\n",
+      "1/1 [==============================] - 0s 331ms/step\n",
+      "1/1 [==============================] - 0s 284ms/step\n",
+      "1/1 [==============================] - 0s 284ms/step\n",
+      "1/1 [==============================] - 0s 321ms/step\n",
+      "1/1 [==============================] - 0s 302ms/step\n",
+      "1/1 [==============================] - 0s 317ms/step\n",
+      "1/1 [==============================] - 0s 401ms/step\n",
+      "1/1 [==============================] - 0s 371ms/step\n",
+      "1/1 [==============================] - 0s 401ms/step\n",
+      "1/1 [==============================] - 0s 327ms/step\n",
+      "1/1 [==============================] - 0s 336ms/step\n",
+      "1/1 [==============================] - 0s 335ms/step\n",
+      "True\n",
+      "1/1 [==============================] - 0s 310ms/step\n",
+      "1/1 [==============================] - 0s 331ms/step\n",
+      "1/1 [==============================] - 0s 321ms/step\n",
+      "1/1 [==============================] - 0s 267ms/step\n",
+      "1/1 [==============================] - 0s 259ms/step\n",
+      "1/1 [==============================] - 0s 272ms/step\n",
+      "1/1 [==============================] - 0s 323ms/step\n",
+      "1/1 [==============================] - 0s 312ms/step\n",
+      "1/1 [==============================] - 0s 239ms/step\n",
+      "1/1 [==============================] - 0s 233ms/step\n",
+      "1/1 [==============================] - 0s 309ms/step\n",
+      "1/1 [==============================] - 0s 286ms/step\n",
+      "1/1 [==============================] - 0s 227ms/step\n",
+      "1/1 [==============================] - 0s 255ms/step\n",
+      "1/1 [==============================] - 0s 285ms/step\n",
+      "1/1 [==============================] - 0s 255ms/step\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "cap = cv2.VideoCapture(0)\n",
+    "while cap.isOpened():\n",
+    "    ret, frame = cap.read()\n",
+    "    frame = frame[120:120+250,200:200+250, :]\n",
+    "    \n",
+    "    cv2.imshow('Verification', frame)\n",
+    "    \n",
+    "    # Verification trigger\n",
+    "    if cv2.waitKey(10) & 0xFF == ord('v'):\n",
+    "        # Save input image to application_data/input_image folder \n",
+    "#         hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\n",
+    "#         h, s, v = cv2.split(hsv)\n",
+    "\n",
+    "#         lim = 255 - 10\n",
+    "#         v[v > lim] = 255\n",
+    "#         v[v <= lim] -= 10\n",
+    "        \n",
+    "#         final_hsv = cv2.merge((h, s, v))\n",
+    "#         img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)\n",
+    "\n",
+    "        cv2.imwrite(os.path.join('application_data', 'input_image', 'input_image.jpg'), frame)\n",
+    "        # Run verification\n",
+    "        results, verified = verify(siamese_model, 0.5, 0.5)\n",
+    "        print(verified)\n",
+    "    \n",
+    "    if cv2.waitKey(10) & 0xFF == ord('q'):\n",
+    "        break\n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 242,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 242,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sum(np.squeeze(results) > 0.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 243,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[array([[0.05363867]], dtype=float32),\n",
+       " array([[0.0300306]], dtype=float32),\n",
+       " array([[0.07447619]], dtype=float32),\n",
+       " array([[0.18518698]], dtype=float32),\n",
+       " array([[0.04685856]], dtype=float32),\n",
+       " array([[0.08473037]], dtype=float32),\n",
+       " array([[0.1722404]], dtype=float32),\n",
+       " array([[0.21567103]], dtype=float32),\n",
+       " array([[0.61339676]], dtype=float32),\n",
+       " array([[0.65027547]], dtype=float32),\n",
+       " array([[0.6625212]], dtype=float32),\n",
+       " array([[0.6401033]], dtype=float32),\n",
+       " array([[0.8263678]], dtype=float32),\n",
+       " array([[0.11735232]], dtype=float32),\n",
+       " array([[0.5586323]], dtype=float32),\n",
+       " array([[0.2668081]], dtype=float32)]"
+      ]
+     },
+     "execution_count": 243,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "c2a09587cd5b6598c407c605d2b868b874f551d4d0a16387c3f63825f72d2833"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Police-Web-Portal b/Police-Web-Portal
new file mode 160000
index 00000000..53af8122
--- /dev/null
+++ b/Police-Web-Portal
@@ -0,0 +1 @@
+Subproject commit 53af81221ab63ed0b48b37afde583fc31af9e55b
diff --git a/README.md b/README.md
index 578bb9cc..589538eb 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,34 @@
-# ksp-submission
+# ksp-submission- The Codebusters
 This repository is created for Karnataka State Police Hackathon 2023 - submission collection. 
 ## Team Information
-### Team Name -
-### Problem Statement -
+### Team Name - The Codebusters
+### Problem Statement - AI-Face Detection
+
+#### Description: Karnataka State Police is looking for a solution where a facial recognition algorithm and API (Application Programming Interface) will integrate with live databases and Social Media Platforms to detect the face of the missing person by scanning through the police databases as well as internet/social media platforms, (minimum 3) to identify and match the missing person image provided by the department.
+
+## Team Members:
+
+- [Khushi Ruparel - @khushi-14](https://github.com/khushi-14)
+- [Girish Rajani - @girishrajani](https://github.com/girishrajani)
+- [Sourav Macwan - @SouraVMacwaN](https://github.com/SouraVMacwaN)
+
+# Features
+
+## Highly Reliable and Accurate AI Model
+Siamese Networks used to train and analyze the model. Various techniques like augmentation and scalling techniques to improve the existing dataset. Facial Time Machine made to predict person's face throught his/her lifetime.  
+
+## All Rounder, Reliable and Scalable API
+A good, fast, reliable, and scalable API that provides quick and accurate responses to requests made by clients, is available at all times, can handle increasing amounts of traffic, and can be easily integrated with other pre-existing systems. Connects and Communicates with all the end points throughout the project.
+
+## Web Portal for the Police
+Easy to use and user-friendly UI to help navigate easily.
+<img src="./README/home.jpg">
+
+## Crowdsourcing Android App
+Android App designed in Flutter to help people anonymously report missing or wanted suspects. 
+<img src="./README/phone.jpg">
+
+## Web Profiler
+a tool used to gather and analyze data about a person's online presence on various social media platforms. The tool typically collects information such as the user's profile information, activity history, friends, followers, and engagement with posts. This data is then used to create a comprehensive profile of the user's social media behavior.
+
+<img src="./README/output.jpg">
\ No newline at end of file
diff --git a/README/finding.jpg b/README/finding.jpg
new file mode 100644
index 00000000..e6511688
Binary files /dev/null and b/README/finding.jpg differ
diff --git a/README/home.jpg b/README/home.jpg
new file mode 100644
index 00000000..af2ad5f5
Binary files /dev/null and b/README/home.jpg differ
diff --git a/README/output.jpg b/README/output.jpg
new file mode 100644
index 00000000..2c1211d4
Binary files /dev/null and b/README/output.jpg differ
diff --git a/README/phone.jpg b/README/phone.jpg
new file mode 100644
index 00000000..70bec8d3
Binary files /dev/null and b/README/phone.jpg differ
diff --git a/WebProfiler b/WebProfiler
new file mode 160000
index 00000000..c949da79
--- /dev/null
+++ b/WebProfiler
@@ -0,0 +1 @@
+Subproject commit c949da7921184d7c689815e5bb76621b1e64aae7