segformer-hf.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from datasets import Dataset, Image\n",
    "from transformers import SegformerImageProcessor, SegformerForSemanticSegmentation\n",
    "\n",
    "import evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(102, 102)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image_dir = \"data/images\"\n",
    "image_files = sorted(glob(f\"{image_dir}/*.jpg\"))\n",
    "image_files = sorted(list(filter(lambda x : not x.endswith('(1).jpg'), image_files)))\n",
    "\n",
    "mask_dir = \"data/masks\"\n",
    "mask_files = sorted(glob(f\"{mask_dir}/*.tiff\"))\n",
    "mask_files = sorted(list(filter(lambda x : not x.endswith('(1).tiff'), mask_files)))\n",
    "\n",
    "len(image_files), len(mask_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset({\n",
       "    features: ['pixel_values', 'labels'],\n",
       "    num_rows: 102\n",
       "})"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "original_ds = Dataset.from_dict({\"pixel_values\": image_files, \"labels\": mask_files})\n",
    "original_ds = original_ds.cast_column(\"pixel_values\", Image())\n",
    "original_ds = original_ds.cast_column(\"labels\", Image())\n",
    "original_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Id2label: {0: 'background', 1: 'sandstone', 2: 'mudstone'}\n"
     ]
    }
   ],
   "source": [
    "id2label = {0: \"background\", 1: \"sandstone\", 2: \"mudstone\"}\n",
    "label2id = {v: k for k, v in id2label.items()}\n",
    "\n",
    "num_labels = len(id2label)\n",
    "print(\"Id2label:\", id2label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "processor = SegformerImageProcessor(size={\"width\": 256, \"height\": 256})\n",
    "\n",
    "def transforms(example_batch):\n",
    "    images = [x for x in example_batch['pixel_values']]\n",
    "    labels = [x for x in example_batch['label']]\n",
    "    inputs = processor(images, labels, return_tensors=\"pt\")\n",
    "    return inputs\n",
    "\n",
    "original_ds.set_transform(transforms)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "743db7cfa4b1484c84b43d0bb665aa05",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading builder script:   0%|          | 0.00/13.1k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "metric = evaluate.load(\"mean_iou\")\n",
    "\n",
    "@torch.no_grad()\n",
    "def compute_metrics(eval_pred):\n",
    "  logits, labels = eval_pred\n",
    "  logits_tensor = torch.from_numpy(logits)\n",
    "  # scale the logits to the size of the label\n",
    "  logits_tensor = F.interpolate(\n",
    "      logits_tensor,\n",
    "      size=labels.shape[-2:],\n",
    "      mode=\"bilinear\",\n",
    "      align_corners=False,\n",
    "  ).argmax(dim=1)\n",
    "\n",
    "  pred_labels = logits_tensor.detach().cpu().numpy()\n",
    "  metrics = metric._compute(\n",
    "          predictions=pred_labels,\n",
    "          references=labels,\n",
    "          num_labels=len(id2label),\n",
    "          ignore_index=-1,\n",
    "          reduce_labels=False,\n",
    "      )\n",
    "  # add per category metrics as individual key-value pairs\n",
    "  per_category_accuracy = metrics.pop(\"per_category_accuracy\").tolist()\n",
    "  per_category_iou = metrics.pop(\"per_category_iou\").tolist()\n",
    "\n",
    "  metrics.update({f\"accuracy_{id2label[i]}\": v for i, v in enumerate(per_category_accuracy)})\n",
    "  metrics.update({f\"iou_{id2label[i]}\": v for i, v in enumerate(per_category_iou)})\n",
    "\n",
    "  return metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path = r\"assets\\b2\"\n",
    "\n",
    "model = SegformerForSemanticSegmentation.from_pretrained(\n",
    "    model_path,\n",
    "    id2label=id2label,\n",
    "    label2id=label2id\n",
    ").eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inference Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = original_ds[5]['pixel_values']\n",
    "gt_seg = original_ds[5]['labels']\n",
    "image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 5999.5, 3999.5, -0.5)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "inputs = processor(images=image, return_tensors=\"pt\")\n",
    "outputs = model(**inputs)\n",
    "logits = outputs.logits  # shape (batch_size, num_labels, height/4, width/4)\n",
    "\n",
    "# First, rescale logits to original image size\n",
    "upsampled_logits = F.interpolate(\n",
    "    logits,\n",
    "    size=image.size[::-1], # (height, width)\n",
    "    mode='bilinear',\n",
    "    align_corners=False\n",
    ")\n",
    "\n",
    "# Second, apply argmax on the class dimension\n",
    "pred_seg = upsampled_logits.argmax(dim=1)[0]\n",
    "plt.imshow(pred_seg, cmap=\"gray\")\n",
    "plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, ..., 2, 2, 2],\n",
       "       [1, 1, 1, ..., 2, 2, 2],\n",
       "       [1, 1, 1, ..., 2, 2, 2],\n",
       "       ...,\n",
       "       [1, 1, 1, ..., 1, 1, 1],\n",
       "       [1, 1, 1, ..., 1, 1, 1],\n",
       "       [1, 1, 1, ..., 1, 1, 1]], dtype=int64)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_seg.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rocks",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}