notebooks/data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/jh/code/til/til-23-cv\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "if os.path.basename(os.getcwd()) == \"notebooks\":\n",
    "    os.chdir(\"..\")\n",
    "%cd .\n",
    "# %load_ext autoreload\n",
    "# %autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not on competition platform, exiting...\n"
     ]
    }
   ],
   "source": [
    "%%sh\n",
    "./setup.sh"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Exploration & Wrangling\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install fiftyone imagehash\n",
    "%pip uninstall fiftyone-db -y\n",
    "%pip install fiftyone-db-ubuntu2204 --force-reinstall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from functools import partial\n",
    "\n",
    "import fiftyone as fo\n",
    "import fiftyone.utils.yolo as fouy\n",
    "from fiftyone import ViewField as F\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "import imagehash\n",
    "\n",
    "from til_23_cv import (\n",
    "    ReIDEncoder,\n",
    "    cos_sim,\n",
    "    evaluate_threshold_function,\n",
    "    thres_strategy_A,\n",
    "    thres_strategy_naive,\n",
    "    thres_strategy_softmax,\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"til23plush\"\n",
    "dataset_dir = \"data/til23plush\"\n",
    "splits = \"train\", \"val\", \"test\"\n",
    "\n",
    "# NOTE: Uncomment to recache dataset\n",
    "# fo.delete_dataset(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name:        til23plush\n",
      "Media type:  image\n",
      "Num samples: 8064\n",
      "Persistent:  True\n",
      "Tags:        []\n",
      "Sample fields:\n",
      "    id:           fiftyone.core.fields.ObjectIdField\n",
      "    filepath:     fiftyone.core.fields.StringField\n",
      "    tags:         fiftyone.core.fields.ListField(fiftyone.core.fields.StringField)\n",
      "    metadata:     fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.metadata.ImageMetadata)\n",
      "    ground_truth: fiftyone.core.fields.EmbeddedDocumentField(fiftyone.core.labels.Detections)\n",
      "    phash:        fiftyone.core.fields.StringField\n"
     ]
    }
   ],
   "source": [
    "if name in fo.list_datasets():\n",
    "    ds = fo.load_dataset(name)\n",
    "\n",
    "    # Delete any predictions still attached\n",
    "    ds.delete_sample_field(\"predictions\", 2)\n",
    "    ds.delete_evaluations()\n",
    "else:\n",
    "    ds = fo.Dataset(name=name, persistent=True)\n",
    "    for split in splits:\n",
    "        ds.add_dir(\n",
    "            dataset_dir=dataset_dir,\n",
    "            dataset_type=fo.types.YOLOv5Dataset,\n",
    "            include_all_data=True,\n",
    "            split=split,\n",
    "            tags=split,\n",
    "        )\n",
    "\n",
    "    # Add Perceptual Hashes for Dupe Detection later\n",
    "    # Due to multiple false positives, perceptual hash chosen is closer to cryptographic\n",
    "    for sample in ds.iter_samples(progress=True, autosave=True):\n",
    "        sample[\"phash\"] = str(imagehash.dhash(Image.open(sample.filepath)))\n",
    "\n",
    "print(ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Relabel all detections to plushie\n",
    "view = ds.set_field(\n",
    "    \"ground_truth.detections\", F(\"detections\").map(F().set_field(\"label\", \"plushie\"))\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dupe Detection\n",
    "\n",
    "There were no dupes; The Object Detection this time is just that easy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter view to only show images where `phash` has more than 1 instance\n",
    "counts = filter(lambda i: i[1] > 1, view.count_values(\"phash\").items())\n",
    "counts = [k for k, v in counts]\n",
    "dupes = view.filter_field(\"phash\", F().is_in(counts)).filter_field(\n",
    "    \"tags\", F().contains([\"train\", \"val\"])\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export YOLO Dataset for Ultralytics\n",
    "\n",
    "Converts `til23plush` to `til23plushonly`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# See: https://docs.voxel51.com/api/fiftyone.utils.yolo.html#fiftyone.utils.yolo.YOLOv5DatasetExporter\n",
    "splits = \"train\", \"val\"\n",
    "config = dict(\n",
    "    export_dir=\"data/til23plushonly\",\n",
    "    dataset_type=fo.types.YOLOv5Dataset,\n",
    "    label_field=\"ground_truth\",\n",
    "    export_media=\"symlink\",\n",
    "    include_path=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Directory 'data/til23plushonly' already exists; export will be merged with existing files\n",
      " 100% |███████████████| 5664/5664 [5.1s elapsed, 0s remaining, 1.1K samples/s]       \n",
      "Directory 'data/til23plushonly' already exists; export will be merged with existing files\n",
      " 100% |█████████████████| 800/800 [691.1ms elapsed, 0s remaining, 1.2K samples/s]       \n"
     ]
    }
   ],
   "source": [
    "for split in splits:\n",
    "    v = view.filter_field(\"tags\", F().contains([split]))\n",
    "    v.export(split=split, **config)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eval Object Detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "split = \"val\"\n",
    "label_dir = f\"runs/detect/predict/{split}/labels\"\n",
    "# label_dir = \"runs/til23/yolo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating detections...\n",
      " 100% |█████████████████| 800/800 [2.9s elapsed, 0s remaining, 292.2 samples/s]      \n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "     plushie       1.00      1.00      1.00      1699\n",
      "\n",
      "    accuracy                           1.00      1699\n",
      "   macro avg       1.00      1.00      1.00      1699\n",
      "weighted avg       1.00      1.00      1.00      1699\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sview = view.filter_field(\"tags\", F().contains([split]))\n",
    "fouy.add_yolo_labels(\n",
    "    sample_collection=sview,\n",
    "    label_field=\"predictions\",\n",
    "    labels_path=label_dir,\n",
    "    classes=[\"plushie\"],\n",
    ")\n",
    "results = sview.evaluate_detections(\n",
    "    \"predictions\",\n",
    "    gt_field=\"ground_truth\",\n",
    "    eval_key=\"eval\",\n",
    ")\n",
    "results.print_report()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export Image Classification Dataset for Suspect Recognition\n",
    "\n",
    "Converts `til23plush` to `til23reid`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_field = \"ground_truth\"\n",
    "export_dir = \"data/til23reid\"\n",
    "splits = \"train\", \"val\"\n",
    "padding = 0.5, 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detected an image classification exporter and a label field 'ground_truth' of type <class 'fiftyone.core.labels.Detections'>. Exporting image patches...\n",
      " 100% |█████████████| 12321/12321 [2.1m elapsed, 0s remaining, 95.2 samples/s]       \n",
      "Detected an image classification exporter and a label field 'ground_truth' of type <class 'fiftyone.core.labels.Detections'>. Exporting image patches...\n",
      " 100% |███████████████| 1699/1699 [14.6s elapsed, 0s remaining, 117.3 samples/s]      \n"
     ]
    }
   ],
   "source": [
    "for split, p in zip(splits, padding):\n",
    "    ds.filter_field(\"tags\", F().contains([split])).export(\n",
    "        export_dir=f\"{export_dir}/{split}\",\n",
    "        dataset_type=fo.types.ImageClassificationDirectoryTree,\n",
    "        label_field=label_field,\n",
    "        alpha=p,\n",
    "        image_format=\".png\",\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eval Suspect Recognition\n",
    "\n",
    "Used to find optimal threshold parameters.\n",
    "\n",
    "NOTE: Suspect folder used below was handpicked from the `til23reid` dataset.\n",
    "\n",
    "NOTE: We uses suspect images as the detection pool. But 10 > ~3 detections per test image. This might affect parameter tuning accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dir = \"data/til23reid/val\"\n",
    "sus_dir = \"data/til23plush/val_suspects\"\n",
    "reid_path = \"models/reid.pt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 100% |███████████████| 1699/1699 [543.8ms elapsed, 0s remaining, 3.1K samples/s]      \n"
     ]
    }
   ],
   "source": [
    "imds = fo.Dataset.from_dir(\n",
    "    dataset_dir=val_dir,\n",
    "    dataset_type=fo.types.ImageClassificationDirectoryTree,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load encoder and encode suspects.\n",
    "encoder = ReIDEncoder(reid_path)\n",
    "embeds = {}\n",
    "for pth in Path(sus_dir).glob(\"*.png\"):\n",
    "    lbl = pth.stem\n",
    "    im = np.array(Image.open(pth))\n",
    "    embeds[lbl] = encoder([im])[0]\n",
    "embeds = dict(sorted(embeds.items()))\n",
    "sus_cls = list(embeds.keys())\n",
    "sus_embeds = list(embeds.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 100% |███████████████| 1699/1699 [1.1m elapsed, 0s remaining, 24.5 samples/s]      \n"
     ]
    }
   ],
   "source": [
    "# Encode all images.\n",
    "for sample in imds.iter_samples(progress=True, autosave=True):\n",
    "    im = np.array(Image.open(sample.filepath))\n",
    "    embeds = encoder([im])[0]\n",
    "    sample[\"logits\"] = [cos_sim(v, embeds) for v in sus_embeds]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 100% |███████████████| 1699/1699 [1.3s elapsed, 0s remaining, 1.3K samples/s]         \n"
     ]
    }
   ],
   "source": [
    "imds.delete_sample_field(\"predictions\", 2)\n",
    "for sample in imds.iter_samples(progress=True, autosave=True):\n",
    "    logits = sample[\"logits\"]\n",
    "    sample[\"predictions\"] = fo.Classification(\n",
    "        label=sus_cls[np.argmax(logits)], confidence=np.max(logits), logits=logits\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 248/248 [00:04<00:00, 56.61it/s]\n",
      "100%|██████████| 248/248 [00:12<00:00, 20.47it/s]\n"
     ]
    }
   ],
   "source": [
    "# Compare PR curves for different threshold functions and tune other threshold params.\n",
    "suspect_dropout = 0.2 # Adversarial case where many images have no suspect.\n",
    "x_axis = np.arange(0.01, 1.0, 0.004)\n",
    "\n",
    "evaluate = partial(\n",
    "    evaluate_threshold_function,\n",
    "    ds=imds,\n",
    "    sus_cls=sus_cls,\n",
    "    x_axis=x_axis,\n",
    "    suspect_dropout=suspect_dropout,\n",
    ")\n",
    "\n",
    "naive_thres = lambda x, t: thres_strategy_naive(x, t)\n",
    "# Can also vary `vote_thres` and 10*`sd_thres` instead of `accept_thres`.\n",
    "# a_thres = lambda x, t: thres_strategy_A(x, 1.0, t, 4.4)\n",
    "softmax_thres = lambda x, t: thres_strategy_softmax(x, t, 1.4)\n",
    "\n",
    "# If `fixed` is set, `suspect_dropout` will be varied instead to measure \"resilience\".\n",
    "naive_res: tuple = evaluate(func=naive_thres, fixed=0.3) # type: ignore\n",
    "# a_res: tuple = evaluate(func=a_thres, fixed=0.3) # type: ignore\n",
    "softmax_res: tuple = evaluate(func=softmax_thres, fixed=0.8) # type: ignore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max Naive F1 & Threshold: 0.9806332616046726 0.01\n",
      "Max Softmax F1 & Threshold: 0.955342375124049 0.058\n"
     ]
    }
   ],
   "source": [
    "# %matplotlib widget\n",
    "# Plot comparison.\n",
    "fig, ax = plt.subplots()\n",
    "# ax.plot(x_axis, naive_res[1], label=\"Naive Precision\")\n",
    "# ax.plot(x_axis, naive_res[2], label=\"Naive Recall\")\n",
    "# ax.plot(x_axis, naive_res[0], label=\"Naive Accuracy\")\n",
    "ax.plot(x_axis, naive_res[3], label=\"Naive F1\")\n",
    "# ax.plot(x_axis, a_res[1], label=\"A Precision\")\n",
    "# ax.plot(x_axis, a_res[2], label=\"A Recall\")\n",
    "# ax.plot(x_axis, a_res[0], label=\"A Accuracy\")\n",
    "# ax.plot(x_axis, a_res[3], label=\"A F1\")\n",
    "# ax.plot(x_axis, softmax_res[1], label=\"Softmax Precision\")\n",
    "# ax.plot(x_axis, softmax_res[2], label=\"Softmax Recall\")\n",
    "# ax.plot(x_axis, softmax_res[0], label=\"Softmax Accuracy\")\n",
    "ax.plot(x_axis, softmax_res[3], label=\"Softmax F1\")\n",
    "ax.set_xlabel(\"Threshold\")\n",
    "ax.set_ylabel(\"Score\")\n",
    "ax.set_title(\"Threshold vs Score\")\n",
    "ax.legend()\n",
    "plt.show()\n",
    "print(\"Max Naive F1 & Threshold:\", max(naive_res[3]), x_axis[np.argmax(naive_res[3])])\n",
    "# print(\"Max A F1 & Threshold:\", max(a_res[3]), x_axis[np.argmax(a_res[3])])\n",
    "print(\"Max Softmax F1 & Threshold:\", max(softmax_res[3]), x_axis[np.argmax(softmax_res[3])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "          #0       1.00      1.00      1.00       179\n",
      "          #1       1.00      1.00      1.00       177\n",
      "          #2       1.00      1.00      1.00       169\n",
      "          #3       1.00      0.99      1.00       163\n",
      "          #4       0.98      1.00      0.99       163\n",
      "          #5       0.99      0.98      0.98       163\n",
      "          #6       0.95      0.92      0.93       166\n",
      "          #7       1.00      0.98      0.99       169\n",
      "          #8       0.97      0.99      0.98       173\n",
      "          #9       0.90      0.92      0.91       177\n",
      "\n",
      "    accuracy                           0.98      1699\n",
      "   macro avg       0.98      0.98      0.98      1699\n",
      "weighted avg       0.98      0.98      0.98      1699\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fo.config.requirement_error_level = 1\n",
    "imds.delete_evaluations()\n",
    "results = imds.evaluate_classifications(\n",
    "    \"predictions\",\n",
    "    gt_field=\"ground_truth\",\n",
    "    eval_key=\"eval\",\n",
    ")\n",
    "results.print_report()\n",
    "# display(results.plot_confusion_matrix())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preview\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Put whatever view or dataset below\n",
    "# v = ds\n",
    "v = view\n",
    "# v = dupes\n",
    "# v = sview\n",
    "# v = imds\n",
    "fo.launch_app(dataset=v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "til",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}