anchor_sizes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# !wget -q https://github.com/PacktPublishing/Hands-On-Computer-Vision-with-Detectron2/raw/main/datasets/braintumors_coco.zip\n",
    "# !unzip -q braintumors_coco.zip"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Register datasets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from detectron2.utils.logger import setup_logger \n",
    "logger = setup_logger()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from detectron2.data.datasets import register_coco_instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Some configurations \n",
    "name_ds = \"braintumors_coco\"\n",
    "name_ds_train = name_ds + \"_train\"\n",
    "image_root_train = name_ds +\"/train\"\n",
    "af = \"_annotations.coco.json\"\n",
    "json_file_train = name_ds + \"/train/\" + af "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Register the dataset \n",
    "### Train dataset \n",
    "register_coco_instances(\n",
    "    name = name_ds_train,\n",
    "    metadata={},\n",
    "    json_file = json_file_train,\n",
    "    image_root = image_root_train\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training configuration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "from detectron2.config import get_cfg\n",
    "from detectron2 import model_zoo\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_dir = \"output/object_detector_hook\"\n",
    "os.makedirs(output_dir,exist_ok=True)\n",
    "output_cfg_path = os.path.join(output_dir,\"cfg.pickle\")\n",
    "nc = 2\n",
    "device = \"cuda\"\n",
    "### Select a model \n",
    "config_file_url = \"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\"\n",
    "checkpoint_url = \"COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a configuration file \n",
    "cfg = get_cfg()\n",
    "config_file = model_zoo.get_config_file(config_file_url)\n",
    "cfg.merge_from_file(config_file)\n",
    "cfg.MODEL.WEIGHTS  = model_zoo.get_checkpoint_url(checkpoint_url)\n",
    "# Set datasets\n",
    "cfg.DATASETS.TRAIN  = (name_ds_train)\n",
    "cfg.DATALOADER.NUM_WORKERS = nc\n",
    "cfg.SOLVER.IMS_PER_BATCH = 6\n",
    "cfg.SOLVER.BASE_LR = 0.00025 \n",
    "cfg.SOLVER.MAX_ITER = 5000 \n",
    "cfg.SOLVER.CHECKPOINT_PERIOD = 500 \n",
    "cfg.TEST.EVAL_PERIOD  = cfg.SOLVER.CHECKPOINT_PERIOD \n",
    "\n",
    "cfg.MODEL.ROI_HEADS.NUM_CLASSES = nc \n",
    "cfg.MODEL.DEVICE  = device \n",
    "cfg.OUTPUT_DIR = output_dir   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m[04/26 00:32:52 d2.engine.defaults]: \u001b[0mModel:\n",
      "GeneralizedRCNN(\n",
      "  (backbone): FPN(\n",
      "    (fpn_lateral2): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
      "    (fpn_output2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (fpn_lateral3): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n",
      "    (fpn_output3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (fpn_lateral4): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
      "    (fpn_output4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (fpn_lateral5): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))\n",
      "    (fpn_output5): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
      "    (top_block): LastLevelMaxPool()\n",
      "    (bottom_up): ResNet(\n",
      "      (stem): BasicStem(\n",
      "        (conv1): Conv2d(\n",
      "          3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False\n",
      "          (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05)\n",
      "        )\n",
      "      )\n",
      "      (res2): Sequential(\n",
      "        (0): BottleneckBlock(\n",
      "          (shortcut): Conv2d(\n",
      "            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv1): Conv2d(\n",
      "            64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (1): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (2): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "      (res3): Sequential(\n",
      "        (0): BottleneckBlock(\n",
      "          (shortcut): Conv2d(\n",
      "            256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv1): Conv2d(\n",
      "            256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (1): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (2): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (3): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "      (res4): Sequential(\n",
      "        (0): BottleneckBlock(\n",
      "          (shortcut): Conv2d(\n",
      "            512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv1): Conv2d(\n",
      "            512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (1): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (2): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (3): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (4): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (5): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (6): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (7): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (8): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (9): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (10): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (11): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (12): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (13): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (14): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (15): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (16): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (17): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (18): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (19): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (20): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (21): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (22): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=1024, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "      (res5): Sequential(\n",
      "        (0): BottleneckBlock(\n",
      "          (shortcut): Conv2d(\n",
      "            1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv1): Conv2d(\n",
      "            1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            2048, 2048, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (1): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "        (2): BottleneckBlock(\n",
      "          (conv1): Conv2d(\n",
      "            2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv2): Conv2d(\n",
      "            2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=32, bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "          (conv3): Conv2d(\n",
      "            2048, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False\n",
      "            (norm): FrozenBatchNorm2d(num_features=2048, eps=1e-05)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "  )\n",
      "  (proposal_generator): RPN(\n",
      "    (rpn_head): StandardRPNHead(\n",
      "      (conv): Conv2d(\n",
      "        256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)\n",
      "        (activation): ReLU()\n",
      "      )\n",
      "      (objectness_logits): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (anchor_deltas): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))\n",
      "    )\n",
      "    (anchor_generator): DefaultAnchorGenerator(\n",
      "      (cell_anchors): BufferList()\n",
      "    )\n",
      "  )\n",
      "  (roi_heads): StandardROIHeads(\n",
      "    (box_pooler): ROIPooler(\n",
      "      (level_poolers): ModuleList(\n",
      "        (0): ROIAlign(output_size=(7, 7), spatial_scale=0.25, sampling_ratio=0, aligned=True)\n",
      "        (1): ROIAlign(output_size=(7, 7), spatial_scale=0.125, sampling_ratio=0, aligned=True)\n",
      "        (2): ROIAlign(output_size=(7, 7), spatial_scale=0.0625, sampling_ratio=0, aligned=True)\n",
      "        (3): ROIAlign(output_size=(7, 7), spatial_scale=0.03125, sampling_ratio=0, aligned=True)\n",
      "      )\n",
      "    )\n",
      "    (box_head): FastRCNNConvFCHead(\n",
      "      (flatten): Flatten(start_dim=1, end_dim=-1)\n",
      "      (fc1): Linear(in_features=12544, out_features=1024, bias=True)\n",
      "      (fc_relu1): ReLU()\n",
      "      (fc2): Linear(in_features=1024, out_features=1024, bias=True)\n",
      "      (fc_relu2): ReLU()\n",
      "    )\n",
      "    (box_predictor): FastRCNNOutputLayers(\n",
      "      (cls_score): Linear(in_features=1024, out_features=3, bias=True)\n",
      "      (bbox_pred): Linear(in_features=1024, out_features=8, bias=True)\n",
      "    )\n",
      "  )\n",
      ")\n",
      "\u001b[32m[04/26 00:32:52 d2.data.datasets.coco]: \u001b[0mLoaded 878 images in COCO format from braintumors_coco/train/_annotations.coco.json\n",
      "\u001b[32m[04/26 00:32:52 d2.data.build]: \u001b[0mRemoved 0 images with no usable annotations. 878 images left.\n",
      "\u001b[32m[04/26 00:32:52 d2.data.dataset_mapper]: \u001b[0m[DatasetMapper] Augmentations used in training: [ResizeShortestEdge(short_edge_length=(640, 672, 704, 736, 768, 800), max_size=1333, sample_style='choice'), RandomFlip()]\n",
      "\u001b[32m[04/26 00:32:52 d2.data.build]: \u001b[0mUsing training sampler TrainingSampler\n",
      "\u001b[32m[04/26 00:32:52 d2.data.common]: \u001b[0mSerializing the dataset using: <class 'detectron2.data.common._TorchSerializedList'>\n",
      "\u001b[32m[04/26 00:32:52 d2.data.common]: \u001b[0mSerializing 878 elements to byte tensors and concatenating them all ...\n",
      "\u001b[32m[04/26 00:32:52 d2.data.common]: \u001b[0mSerialized dataset takes 0.22 MiB\n",
      "\u001b[5m\u001b[31mWARNING\u001b[0m \u001b[32m[04/26 00:32:52 d2.solver.build]: \u001b[0mSOLVER.STEPS contains values larger than SOLVER.MAX_ITER. These values will be ignored.\n"
     ]
    }
   ],
   "source": [
    "from detectron2.engine import DefaultTrainer\n",
    "trainer = DefaultTrainer(cfg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing Input images "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MIN_SIZE_TRAIN (640, 672, 704, 736, 768, 800)\n",
      "MAX_SIZE_TRAIN 1333\n"
     ]
    }
   ],
   "source": [
    "print(\"MIN_SIZE_TRAIN\",cfg.INPUT.MIN_SIZE_TRAIN)\n",
    "print(\"MAX_SIZE_TRAIN\",cfg.INPUT.MAX_SIZE_TRAIN)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The ResizeShortestEdge method uses these hyperparameters to resize input images.Precisley, it resizes shorter edges to one random value selected from MIN_SIZE_TRAIN as long as the longer edges are smaller than MAX_SIZE_TRAIN. \n",
    "- otherwise,it continues to resize the longer edges to MAX_SIZE_TEAIN\n",
    "- while resizing, the image aspect ratio remains the same,The following code samples for one training batch and displays the sizes of the sampled/transformed images "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 800, 800])\n",
      "torch.Size([3, 800, 800])\n",
      "torch.Size([3, 1024, 768])\n",
      "torch.Size([3, 768, 768])\n",
      "torch.Size([3, 736, 736])\n",
      "torch.Size([3, 704, 704])\n"
     ]
    }
   ],
   "source": [
    "trainer._data_loader_iter = iter(trainer.data_loader)\n",
    "data = next(trainer._data_loader_iter)\n",
    "for i in data:\n",
    "    print(i[\"image\"].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([6, 3, 1024, 800])\n"
     ]
    }
   ],
   "source": [
    "# all these scaled images still have different sizes. Detectron2 performs some more preprocessing \n",
    "images = trainer.model.preprocess_image(data)\n",
    "print(images.tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x640 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x640 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x640 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "from detectron2.utils.visualizer import Visualizer\n",
    "\n",
    "for i,item in enumerate(images.tensor[:3]):\n",
    "    img = np.moveaxis(item.to(\"cpu\").numpy(),0,-1)\n",
    "    pixel_mean= cfg.MODEL.PIXEL_MEAN\n",
    "    pixel_std = cfg.MODEL.PIXEL_STD\n",
    "    img = (img*pixel_std) + pixel_mean\n",
    "    v = Visualizer(img,metadata={},scale=0.5)\n",
    "    v = v.overlay_instances(boxes=data[i][\"instances\"].get(\"gt_boxes\"))\n",
    "    dpi = 80\n",
    "    im_data = v.get_image()[:,:,::-1]\n",
    "    height,width,depth = im_data.shape\n",
    "    figsize = width/float(dpi),height/float(dpi)\n",
    "    fig = plt.figure(figsize=figsize)\n",
    "    plt.imshow(im_data)\n",
    "    plt.imshow(im_data)\n",
    "    plt.axis(\"off\")\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Examples of preprocessed images and labels before feeding to the backbone \n",
    "- smaller images in a batch are padded to have the maximum size, and all images have the same size.\n",
    "- Bouding boxes are also scaled accordingly \n",
    "## Sample images\n",
    "After understanding how Detectron2 preprocesses input images and ground-truth boxes,we can now sample for several iterations,get the ground-truth bounding boxes from this set,and analyze them to get the right sizes and ratios for training "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1000/1000 [01:25<00:00, 11.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "torch.Size([6319, 4])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import torch\n",
    "def get_gt_boxes_bacth(data):\n",
    "    gt_boxes =[item['instances'].get('gt_boxes').tensor for item in data ]\n",
    "    return torch.concat(gt_boxes)\n",
    "def get_gt_boxes(trainer,iterations):\n",
    "    trainer._data_loader_iter = iter(trainer.data_loader)\n",
    "    gt_boxes = [get_gt_boxes_bacth(next(trainer._data_loader_iter)) for _ in tqdm(range(iterations))]\n",
    "    return torch.concatenate(gt_boxes)\n",
    "gt_boxes = get_gt_boxes(trainer,1000)\n",
    "print()\n",
    "print(gt_boxes.shape)\n",
    "    \n",
    "    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This code snippet should give us a tensor of bounding boxes. Each bounding box is in the format (x1,y1,x2,y2) for the top-left and lower-right corners of the bounding box while analyzing the anchors and the bounding boxes,we use width and height information rather than minimum and maximum coordinates. \n",
    "- The following code snippet converts the coordinates into width and height coorespondingly and quickly looks at their minimum and maximum edge sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(22.3098) tensor(299.3030)\n"
     ]
    }
   ],
   "source": [
    "def boxes2wh(boxes):\n",
    "    x1y1 = boxes[:,:2]\n",
    "    x2y2 = boxes[:,2:]\n",
    "    \n",
    "    return x2y2 - x1y1\n",
    "gt_wh = boxes2wh(gt_boxes)\n",
    "print(gt_wh.min(),gt_wh.max()) #! minimum and maximum edge sizes of all the ground-truth boxes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sizes [[32], [64], [128], [256], [512]]\n",
      "ratio [[0.5, 1.0, 2.0]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Sizes\",cfg.MODEL.ANCHOR_GENERATOR.SIZES)\n",
    "print(\"ratio\",cfg.MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We use a Feature Pyramid Network (FPN) as the backbone,so the anchor sizes are for different layers.\n",
    "That explains the second dimension for the array of anchor sizes. if we don't use FPN, the size should look like [32,64,128,256,512] instead. \n",
    "- The following code snippets uses Detectron2's Default anchor generator to generate a set of anchors from the previous set of sizes and ratios and converts them into widths and heights correspondingly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "generate_anchors = trainer.model.proposal_generator.anchor_generator.generate_cell_anchors\n",
    "anchors = generate_anchors()\n",
    "ac_wh = boxes2wh(anchors)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "after having the ground-truth boxes and methods to generate anchors,we are ready to analyze the training bounding boxes and propose a set of initial sizes and ratios that better fit the training data \n",
    "# Generating sizes and ratios hyperparameters \n",
    "The ground-truth boxes and anchors are currently in the width and height format, while we need to\n",
    "analyze them in sizes and ratios. Therefore, the following code snippet creates two methods and uses\n",
    "them to convert ground-truth widths and heights into sizes and ratios:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wh2size(wh):\n",
    "    return torch.sqrt(gt_wh[:,0]*gt_wh[:,1])\n",
    "def wh2ratio(wh):\n",
    "    return wh[:,1]/wh[:,0]\n",
    "gt_sizes = wh2size(gt_wh)\n",
    "gt_ratios = wh2ratio(gt_wh)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generally, the algorithm to get the best set of sizes and ratios for training has the following steps:\n",
    "1.Quantify how well each ground-truth box matches a set of anchors (compute best ratios).\n",
    "\n",
    "2.Quantify the fitness between the set of ground-truth boxes, as a whole, and the set of anchors (compute a fitness score).\n",
    "\n",
    "3.Perform clustering algorithms on the ground-truth sizes and ratios and get the initializations for these two sets of parameters.\n",
    "\n",
    "4.Use a genetic algorithm to randomly evolve and get a good set of sizes and ratios for the training process."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute the best ratios \n",
    "For each ground-truth bounding box, there must be a method to quantify how well it can fit with\n",
    "the set of given anchors. We divide the width and height of the ground-truth box by each anchor’s\n",
    "width and height and take the inversion. Taking the inversion is necessary because these two boxes’\n",
    "differences are symmetric (two-way). For each anchor, we take the worst ratio to indicate fitness (i.e.,if there are suitable matches and bad matches, we will take the worst match as the measure of fitness).\n",
    "\n",
    "On the other hand, for each ground-truth box, we do not need all the anchors to match well, and it is\n",
    "enough to have at least one anchor that fits well with it. Therefore, we take the maximum ratio among\n",
    "the ratios generated for all anchors as a fitness ratio. This ratio is the indicator of the fitness of this\n",
    "one ground-truth box with the set of anchors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_ratio(ac_wh,gt_wh):\n",
    "    \"\"\"\n",
    "    the function calculates all possible aspect ratios by dividing each ground truth height by each predicted width.\n",
    "    The [:,None] and [None] synatx is used to broadcast the dimensions of the two arrays so that they can be divided element-wise. \n",
    "    The result is a 2D array of shape(num_gt,num_ac)\n",
    "    \"\"\"\n",
    "    all_ratios = gt_wh[:,None]/ac_wh[None]\n",
    "    inverse_ratios = 1/all_ratios\n",
    "    # takes the element-wise minimuma and maximum -1 specifies that min/max should be taken along the last dimension(predicted boxes)\n",
    "    ratios = torch.min(all_ratios,inverse_ratios)\n",
    "    worst = ratios.min(-1).values\n",
    "    best = worst.max(-1).values\n",
    "    \n",
    "    return best"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function helps quantify the fitness of individual ground-truth boxes with a set of anchors and returns  a list of fitness ratios. \n",
    "## Quantify the fitness\n",
    "One approach is to take the average of all the fitness score for all the ground-truth boxes as one fitness score between a set of ground-truth boxes as  a whole,given a set of anchors. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitness(ac_wh,gt_wh,EDGE_RATIO_THRESHOLD=0.25):\n",
    "    \"\"\"\n",
    "    the default threshold value is 0.25, which means that if the ratio of any side of two boxes differs by more than four times,they are considered bad matches \n",
    "    \"\"\"\n",
    "    ratio = best_ratio(ac_wh,gt_wh)\n",
    "    ret = (ratio*(ratio>EDGE_RATIO_THRESHOLD).float()).mean()    \n",
    "    return ret\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_recall(ac_wh,gt_wh,EDGE_RATIO_THRESHOLD=0.25):\n",
    "    ratio = best_ratio(ac_wh,gt_wh)\n",
    "    best = (ratio>EDGE_RATIO_THRESHOLD).float().mean()\n",
    "    return best "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a ground truth box with edges that don't exceed four times or are not smaller than four times the size of at least one anchor is then recallable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recall tensor(1.)\n",
      "fitness tensor(0.7831)\n"
     ]
    }
   ],
   "source": [
    "print(\"recall\",best_recall(ac_wh,gt_wh))\n",
    "print(\"fitness\",fitness(ac_wh,gt_wh))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results indicate that this default set of hyperparameters is relatively good for this case,However it's possible to use a genetic algorithm to improve fitness. \n",
    "### Using clustering algorithms "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "from scipy.cluster.vq import kmeans\n",
    "def estimate_clusters(values,num_clusters,iter=100):\n",
    "    std = values.std(0).item()\n",
    "    k,_ = kmeans(values/std,num_clusters,iter=iter)\n",
    "    k *=std\n",
    "    return k\n",
    "def visualize_clusters(values,centers):\n",
    "    plt.hist(values,histtype=\"step\")\n",
    "    plt.scatter(centers,[0]*len(centers),c=\"red\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sizes = estimate_clusters(gt_sizes,5)\n",
    "visualize_clusters(gt_sizes,sizes)\n",
    "ratios = estimate_clusters(gt_ratios,3)\n",
    "visualize_clusters(gt_ratios,ratios)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most sizes are 100 pixels, and the ratios are more toward 1.0 because most boxes are square. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.8784, dtype=torch.float64)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fitness(boxes2wh(generate_anchors(sizes,ratios)),gt_wh)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This score is a much better fit than the default anchor set we can improve it with genetic algorithm\n",
    "## Evlovle the results using the genetic algorithm \n",
    "1. start with the initial sizes and ratios generated by the clustering algorithms \n",
    "2. sample some items to evolve based on a given probability (eg. 0.9 have an item evolve 90% of the time)\n",
    "3. sample some random evolving amounts from a normal distribution  with a given mean and standard deviation \n",
    "4. Change the sizes and ratios using the generated random amounts\n",
    "5. compute a fitness score using the new sets of sizes and ratios \n",
    "6. If the fitness improves, set the initial set of sizes and ratios to these current sets and loop back to step 1 otherwise,proceed to step 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evolve(sizes,ratios,gt_wh,iterations=10000,probability=0.9,muy=1,sigma=0.05,fit_fn=fitness,verbose=False):\n",
    "    anchors = generate_anchors(tuple(sizes),tuple(ratios))\n",
    "    ac_wh = boxes2wh(anchors)\n",
    "    best_fit = fit_fn(ac_wh,gt_wh)\n",
    "    anchor_shape = len(sizes) + len(ratios)\n",
    "    \n",
    "    pbar = tqdm(range(iterations),desc=f\"Evolving ratios and sizes:\")\n",
    "    for i, _ in enumerate(pbar):\n",
    "        #to mutate and how much \n",
    "        mutation = np.ones(anchor_shape)\n",
    "        mutate = np.random.random(anchor_shape)<probability\n",
    "        mutation = np.random.normal(muy,sigma,anchor_shape)*mutate \n",
    "        mutation = mutation.clip(0.3,3.0)\n",
    "        #mutated \n",
    "        mutated_sizes = sizes.copy()*mutation[:len(sizes)]\n",
    "        mutated_ratios = ratios.copy()*mutation[-len(ratios):]\n",
    "        mutated_anchors = generate_anchors(\n",
    "            tuple(mutated_sizes),\n",
    "            tuple(mutated_ratios)\n",
    "        )\n",
    "        mutated_ac_wh = boxes2wh(mutated_anchors)\n",
    "        mutated_fit = fit_fn(mutated_ac_wh,gt_wh)\n",
    "        \n",
    "        if mutated_fit>best_fit:\n",
    "            sizes = mutated_sizes.copy()\n",
    "            ratios = mutated_ratios.copy()\n",
    "            best_fit = mutated_fit\n",
    "            pbar.desc=(f\"Evolving ratios and sizes, Fitness = {best_fit:.4f}\")\n",
    "    return sizes,ratios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Evolving ratios and sizes, Fitness = 0.8845: 100%|██████████| 10000/10000 [00:24<00:00, 400.47it/s]\n"
     ]
    }
   ],
   "source": [
    "e_sizes, e_ratios = evolve(sizes, ratios, gt_wh, verbose=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sizes [ 86.74344385 111.15039289 144.6967493   64.91778448  43.43608345]\n",
      "ratios [0.99055315 0.78273349 1.24811079]\n"
     ]
    }
   ],
   "source": [
    "print(\"sizes\",e_sizes)\n",
    "print(\"ratios\",e_ratios)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Therefore the trainign configuration should use the following hyperparameters for sizes and ratios \n",
    "cfg.MODEL.ANCHOR_GENERATOR.SIZES = [e_sizes[0],e_sizes[1],e_sizes[2],e_sizes[3]]\n",
    "cfg.MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS = [ e_ratios[0],e_ratios[1],e_ratios[2]]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settnig pixel means and standard deviations \n",
    "Input image pixel's and standard deviations are crucial in traingin Detectron2 Models,\n",
    "he uses these valeus to normalize the input images,\n",
    "The common values for these two hyperparameters generated from the ImageNet dataset are [103.53,116.28,123.675] and\n",
    "[57.375,57.120,58.395]. \n",
    "These values are appropariate for  most of the color images. However,this specific case has grayscale images with different values for pixel mean and standard deviations.\n",
    "Therefore, producing these two sets of values from the training\n",
    "dataset would be beneficial. This task has two main stages: (1) preparing a data loader to load images and (2) creating a class to calculate running means and standard deviations.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Preparing a data loader \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "import torch \n",
    "from torch.utils.data import Dataset,DataLoader\n",
    "import os \n",
    "import cv2\n",
    "name_ds = \"braintumors_coco\"\n",
    "af = \"_annotations.coco.json\"\n",
    "img_dir = name_ds + \"/train/\"\n",
    "json_file_train = name_ds + \"/train/\" + af \n",
    "batch_size = 64\n",
    "num_workers= 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TumorDataset(Dataset):\n",
    "    def __init__(self,data,img_dir=\"\",transform=None):\n",
    "        self.data = data \n",
    "        self.img_dir = img_dir \n",
    "        self.transform = transform\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    def __getitem__(self,idx):\n",
    "        file_name = os.path.join(self.img_dir,self.data[idx][\"file_name\"])\n",
    "        image = cv2.imread(file_name)\n",
    "        if self.transform is not None:\n",
    "            image = self.transform(image=image)[\"image\"]\n",
    "        return image "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import albumentations as A \n",
    "from albumentations.pytorch import ToTensorV2\n",
    "\n",
    "image_size  =640\n",
    "augs = A.Compose([\n",
    "    A.Resize(height=image_size,width=image_size),\n",
    "    ToTensorV2()\n",
    "])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json \n",
    "with open(json_file_train) as f:\n",
    "    ds = json.load(f)['images']\n",
    "tds = TumorDataset(ds,img_dir = img_dir,transform=augs)\n",
    "image_loader = DataLoader(tds,\n",
    "                          batch_size=batch_size,\n",
    "                          shuffle=False,\n",
    "                          num_workers=num_workers,\n",
    "                          pin_memory=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate running means and standard deviations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def broad_cast(x,image_size,channel):\n",
    "    y = torch.broadcast_to(x,(image_size**2,channel))\n",
    "    z = y.reshape(image_size,image_size,3)\n",
    "    return torch.moveaxis(z,2,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class RunningStats:\n",
    "  def __init__(self):\n",
    "    self.n = 0\n",
    "    self.mean = 0\n",
    "    self.ssd = 0 \n",
    "    \n",
    "  def push(self, x):\n",
    "    # start\n",
    "    dims = [0, 2, 3]\n",
    "    count = 1\n",
    "    for dim in dims:\n",
    "      count *= x.shape[dim]\n",
    "    image_size = x.shape[-1]\n",
    "    channel = x.shape[1]\n",
    "    if self.n == 0:\n",
    "      # start\n",
    "      new_mean = x.sum(axis=dims)/count\n",
    "      new_ssd = ((\n",
    "          x - broad_cast(\n",
    "                new_mean, \n",
    "                image_size, \n",
    "                channel\n",
    "                ))**2).sum(axis=dims)\n",
    "      new_count = count\n",
    "    else:\n",
    "      # old\n",
    "      old_count = self.n\n",
    "      old_mean = self.mean\n",
    "      old_ssd = self.ssd\n",
    "      old_sum = old_mean * old_count      \n",
    "      # new\n",
    "      new_count = self.n + count\n",
    "      new_sum = old_sum + x.sum(axis=dims)\n",
    "      new_mean = new_sum/(self.n + count)\n",
    "      \n",
    "      old_ssd_new_mean = (\n",
    "          old_ssd  \n",
    "          + 2*old_mean*old_sum\n",
    "          - old_count*(old_mean)**2\n",
    "          - 2*new_mean*old_sum\n",
    "          + old_count*(new_mean)**2\n",
    "          )\n",
    "      \n",
    "      new_ssd = (\n",
    "          old_ssd_new_mean + \n",
    "          (\n",
    "              (x - broad_cast(new_mean, \n",
    "                           image_size, \n",
    "                           channel))**2\n",
    "           ).sum(axis=dims))\n",
    "    # release results\n",
    "    self.mean = new_mean\n",
    "    self.ssd = new_ssd\n",
    "    self.n = new_count\n",
    "    self.std = torch.sqrt(new_ssd/(new_count-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 14/14 [00:10<00:00,  1.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([20.1962, 20.1962, 20.1962])\n",
      "tensor([39.5985, 39.5985, 39.5985])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "rs = RunningStats()\n",
    "for inputs in tqdm(image_loader):\n",
    "    rs.push(inputs)\n",
    "print(rs.mean)\n",
    "print(rs.std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}