docs(notebooks): inject rich markdown text cells to 5 notebooks without touching code

notebooks/Accident_EDA_&_Hotspot_Generator_chatbot_service_data_accidents_3.ipynb

@@ -14,6 +14,47 @@
     }
   },
   "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🗺️ Accident EDA & Blackspot Hotspot Generator\n",
+        "\n",
+        "**Part of:** SafeVisionAI · IIT Madras Road Safety Hackathon 2026  \n",
+        "**Output:** `accidents_summary.json` + `blackspot_seed.csv` → seeded to the backend database\n",
+        "\n",
+        "This notebook processes the **Kaggle India Road Accidents dataset** (1M+ rows)  \n",
+        "to produce two key intelligence artifacts:\n",
+        "\n",
+        "1. **`accidents_summary.json`** — National total + top 10 states by accident count\n",
+        "2. **`blackspot_seed.csv`** — GPS clusters with accident counts for map hotspot visualization\n",
+        "\n",
+        "---\n",
+        "### 📊 Dataset\n",
+        "- **Source:** Kaggle India Road Accidents dataset\n",
+        "- **Size:** ~1,048,575 rows · 30+ columns\n",
+        "- **Acquired via:** `setup_kaggle.ps1` + `scripts/data/seed_blackspots.py`\n",
+        "\n",
+        "### 🔄 Pipeline\n",
+        "```\n",
+        "Raw CSV → Normalize columns → State summary → GPS cluster → blackspot_seed.csv\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📂 Step 0 — Upload Accidents Dataset\n",
+        "\n",
+        "Upload `kaggle_india_accidents.csv` from:  \n",
+        "```\n",
+        "chatbot_service/data/accidents/kaggle_india_accidents.csv\n",
+        "```\n",
+        "\n",
+        "> ⚠️ This file is ~450MB. The Hub stores it via Git LFS."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -246,6 +287,18 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📖 Step 1 — Load & Normalize Dataset\n",
+        "\n",
+        "Reads the CSV and normalizes all column names to lowercase snake_case.  \n",
+        "Result: **1,048,575 rows** of accident records across Indian states.\n",
+        "\n",
+        "> 💡 The mixed-type DtypeWarning is expected for columns with mixed numeric/string data."
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -281,6 +334,20 @@
         "print(f\"Loaded accidents dataset with {len(df)} rows.\")\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📊 Step 2 — Generate National Summary JSON\n",
+        "\n",
+        "Auto-detects the `state` and `accident` columns using flexible column name matching,  \n",
+        "then computes:\n",
+        "- **National total** — sum of all accident counts\n",
+        "- **Top 10 states** — ranked by accident volume\n",
+        "\n",
+        "Exports `accidents_summary.json` — used by the chatbot to answer national stats queries."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -375,6 +442,25 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📍 Step 3 — Generate GPS Blackspot Clusters\n",
+        "\n",
+        "Groups accident records by rounded GPS coordinates (2 decimal places ≈ ~1km²),  \n",
+        "then counts accidents per grid cell.\n",
+        "\n",
+        "Result: **4,134 blackspot clusters** exported as `blackspot_seed.csv`  \n",
+        "→ This CSV is loaded by `backend/scripts/app/seed_emergency.py` to populate the PostGIS accident layer.\n",
+        "\n",
+        "| Column | Description |\n",
+        "|--------|-------------|\n",
+        "| `lat_r` | Rounded latitude (±0.01°) |\n",
+        "| `lon_r` | Rounded longitude (±0.01°) |\n",
+        "| `accident_count` | Number of accidents in this 1km² cell |"
+      ]
+    },
     {
       "cell_type": "code",
       "source": [

notebooks/ChromaDB_RAG_Vectorstore_Build_chatbot_service_data_chroma_db_2.ipynb

@@ -7884,6 +7884,47 @@
     }
   },
   "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🧠 ChromaDB RAG Vectorstore — Legal & Medical PDF Ingestion\n",
+        "\n",
+        "**Part of:** SafeVisionAI · IIT Madras Road Safety Hackathon 2026  \n",
+        "**Output:** `chroma_db/` directory → deployed to `chatbot_service/data/chroma_db/`\n",
+        "\n",
+        "This notebook builds the **Retrieval-Augmented Generation (RAG)** knowledge base for the SafeVisionAI chatbot.  \n",
+        "It ingests Indian legal documents (Motor Vehicles Act, MoRTH circulars) and first-aid medical PDFs,  \n",
+        "chunks them, embeds them using `sentence-transformers`, and stores them in a **ChromaDB** vector store.\n",
+        "\n",
+        "---\n",
+        "### 🗂️ Source Documents\n",
+        "| Category | Files | Source |\n",
+        "|----------|-------|--------|\n",
+        "| Legal | Motor Vehicles Act 2019, MoRTH 2022 | `download_legal_pdfs.py` |\n",
+        "| Medical | First Aid guides, Emergency protocols | `download_legal_pdfs.py` |\n",
+        "\n",
+        "### 🔄 Pipeline\n",
+        "```\n",
+        "PDFs → pdfplumber chunks → sentence-transformer embeddings → ChromaDB index\n",
+        "```\n",
+        "\n",
+        "> 💡 The resulting `chroma_db/` is what the chatbot queries at runtime for grounded answers."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🔧 Step 1 — Install Dependencies\n",
+        "\n",
+        "Installs the full RAG stack:\n",
+        "- `chromadb` — local vector database for semantic search\n",
+        "- `sentence-transformers` — `all-MiniLM-L6-v2` model for text embeddings\n",
+        "- `pdfplumber` — PDF text extraction with page layout awareness\n",
+        "- `langchain` — document chunking utilities"
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -7933,6 +7974,21 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📂 Step 2 — Upload PDF Documents\n",
+        "\n",
+        "Upload all legal and medical PDFs from:  \n",
+        "```\n",
+        "chatbot_service/data/legal/\n",
+        "chatbot_service/data/medical/\n",
+        "```\n",
+        "\n",
+        "> 📄 Expected PDFs: Motor_Vehicles_Act.pdf, MoRTH_2022_Report.pdf, first_aid_guide.pdf, etc."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -7959,6 +8015,19 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## ✂️ Step 3 — Extract & Chunk PDF Text\n",
+        "\n",
+        "Uses `pdfplumber` to extract text from each PDF page,  \n",
+        "then splits into fixed-size chunks (512 tokens) with 50-token overlap.\n",
+        "\n",
+        "Chunking ensures the embedding model sees coherent, context-rich passages  \n",
+        "rather than arbitrarily cut sentences."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -8631,6 +8700,20 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🔢 Step 4 — Generate Embeddings\n",
+        "\n",
+        "Uses the `all-MiniLM-L6-v2` sentence-transformer model to convert each text chunk  \n",
+        "into a 384-dimensional embedding vector.\n",
+        "\n",
+        "| Model | Dimensions | Speed | Quality |\n",
+        "|-------|-----------|-------|---------|\n",
+        "| all-MiniLM-L6-v2 | 384 | Fast | Good for semantic QA |"
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -8668,6 +8751,18 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 💾 Step 5 — Build & Persist ChromaDB Index\n",
+        "\n",
+        "Creates a persistent ChromaDB collection and upserts all embedded chunks.  \n",
+        "The resulting `chroma_db/` folder contains the SQLite + vector index files.\n",
+        "\n",
+        "> 📦 Output size: ~50-100MB depending on number of PDFs ingested."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -8916,6 +9011,18 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📥 Step 6 — Download ChromaDB\n",
+        "\n",
+        "Zips the `chroma_db/` directory and downloads it for deployment.  \n",
+        "Place the extracted folder at: `chatbot_service/data/chroma_db/`\n",
+        "\n",
+        "The chatbot service auto-loads this at startup — no rebuild needed."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [

notebooks/Risk_Model_ONNX_Training_frontend_public_models_5.ipynb

@@ -14,6 +14,48 @@
     }
   },
   "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# ⚡ Road Risk Scoring Model — ONNX Training Pipeline\n",
+        "\n",
+        "**Part of:** SafeVisionAI · IIT Madras Road Safety Hackathon 2026  \n",
+        "**Output:** `risk_model.onnx` (~21KB) → deployed to `frontend/public/models/`\n",
+        "\n",
+        "This notebook trains a **GradientBoosting classifier** to predict real-time road risk  \n",
+        "and exports it as ONNX for **in-browser inference** — no server call needed.\n",
+        "\n",
+        "---\n",
+        "### 🧠 Model Architecture\n",
+        "| Component | Details |\n",
+        "|-----------|--------|\n",
+        "| Algorithm | GradientBoostingClassifier |\n",
+        "| Input features | 5 (road type, hour, rain, speed limit, prev accidents) |\n",
+        "| Output | Binary: `high_risk` (0 or 1) |\n",
+        "| Export | ONNX via `skl2onnx` |\n",
+        "| Size | ~21KB — loads in milliseconds in browser |\n",
+        "\n",
+        "### 🔄 Pipeline\n",
+        "```\n",
+        "Synthetic data generation → GBM training → ONNX conversion → Download\n",
+        "```\n",
+        "\n",
+        "> 💡 The model runs entirely client-side in the SafeVisionAI PWA using `onnxruntime-web`."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🔧 Step 1 — Install ML Toolkit\n",
+        "\n",
+        "Installs the minimum stack needed for training and ONNX export:\n",
+        "- `scikit-learn` — GradientBoostingClassifier\n",
+        "- `skl2onnx` — converts sklearn models to ONNX format\n",
+        "- `pandas` + `numpy` — data generation and manipulation"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -42,6 +84,26 @@
         "print(\"✅ Toolkit installed\")\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🏗️ Step 2 — Build Synthetic Training Data\n",
+        "\n",
+        "Generates 5,000 synthetic road sensor records matching the live app's data structure:\n",
+        "\n",
+        "| Feature | Values | Description |\n",
+        "|---------|--------|-------------|\n",
+        "| `road_type` | 0-3 | NH=0, SH=1, MDR=2, VR=3 |\n",
+        "| `hour` | 0-23 | Hour of day |\n",
+        "| `is_rain` | 0/1 | Weather condition |\n",
+        "| `speed_limit` | 40/60/80/100 | Posted speed (km/h) |\n",
+        "| `prev_accidents` | Poisson(2) | Historical accident count |\n",
+        "\n",
+        "**Label logic:** `high_risk = 1` when: Night hours (10pm–4am) + National/State Highway + Raining  \n",
+        "This reflects real-world patterns from the India accident dataset."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -83,6 +145,18 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🎯 Step 3 — Train GradientBoosting Classifier\n",
+        "\n",
+        "Trains a GBM with 50 estimators and max depth 4:\n",
+        "- **Fast:** <10 seconds on CPU\n",
+        "- **Accurate:** Handles non-linear risk patterns well\n",
+        "- **Tiny:** Converts to 21KB ONNX — ideal for edge/PWA deployment"
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -111,6 +185,26 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📦 Step 4 — Export to ONNX & Download\n",
+        "\n",
+        "Converts the trained sklearn model to ONNX format using `skl2onnx`:\n",
+        "- **Input:** `FloatTensorType([None, 5])` — batch of 5-feature vectors\n",
+        "- **Output:** Risk probability + binary class label\n",
+        "\n",
+        "Download `risk_model.onnx` and place at:  \n",
+        "```\n",
+        "frontend/public/models/risk_model.onnx\n",
+        "```\n",
+        "\n",
+        "The Next.js PWA loads this at startup and runs inference on each map segment click.\n",
+        "\n",
+        "> ✅ Final output: **~21KB** ONNX model — ready for browser deployment"
+      ]
+    },
     {
       "cell_type": "code",
       "source": [

notebooks/Roads_Data_Processing_backend_data_4.ipynb

@@ -14,6 +14,54 @@
     }
   },
   "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🛣️ Roads & Toll Plaza Data Processing\n",
+        "\n",
+        "**Part of:** SafeVisionAI · IIT Madras Road Safety Hackathon 2026  \n",
+        "**Output:** `toll_plazas_lite.json` → deployed to `backend/data/roads/`\n",
+        "\n",
+        "This notebook processes the **NHAI Toll Plaza dataset** to produce a lightweight JSON  \n",
+        "suitable for the SafeVisionAI backend API and offline PWA map layer.\n",
+        "\n",
+        "---\n",
+        "### 📊 Dataset\n",
+        "- **Source:** NHAI Open Data / custom toll_plazas.csv\n",
+        "- **Fields:** Name, NH Number, Latitude, Longitude\n",
+        "- **Coverage:** All operational toll plazas on National Highways\n",
+        "\n",
+        "### 🔄 Pipeline\n",
+        "```\n",
+        "toll_plazas.csv → Select key columns → Rename headers → Export toll_plazas_lite.json\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📦 Step 1 — Upload & Process Toll Plaza CSV\n",
+        "\n",
+        "Upload `toll_plazas.csv` from:  \n",
+        "```\n",
+        "backend/data/roads/toll_plazas.csv\n",
+        "```\n",
+        "\n",
+        "The processing pipeline:\n",
+        "1. Reads the CSV with `pandas`\n",
+        "2. Selects only 4 essential columns: `name, id, lat, lon`\n",
+        "3. Drops rows with missing coordinates\n",
+        "4. Renames to human-readable headers\n",
+        "5. Exports as `toll_plazas_lite.json`\n",
+        "\n",
+        "The resulting JSON is consumed by the backend `/api/roads/tolls` endpoint  \n",
+        "and the offline PWA map layer for toll overlay rendering.\n",
+        "\n",
+        "> 📦 Output size: ~65KB (vs 2MB+ raw CSV)"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,

notebooks/YOLOv8_Pothole_Detector_Training_frontend_public_models_1.ipynb

@@ -16,6 +16,46 @@
     "accelerator": "GPU"
   },
   "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🚗 YOLOv8 Pothole & Road Damage Detector — Training Pipeline\n",
+        "\n",
+        "**Part of:** SafeVisionAI · IIT Madras Road Safety Hackathon 2026  \n",
+        "**Output:** `pothole_v1/weights/best.onnx` → deployed to `frontend/public/models/`\n",
+        "\n",
+        "This notebook trains a YOLOv8n object detection model to identify **potholes, cracks, and manholes** on Indian roads.  \n",
+        "The trained model is exported to ONNX format for in-browser inference via `onnxruntime-web`.\n",
+        "\n",
+        "---\n",
+        "### 📋 Pipeline Overview\n",
+        "| Step | What happens |\n",
+        "|------|-------------|\n",
+        "| 1 | Install Ultralytics + ONNX and verify GPU |\n",
+        "| 2 | Upload `archive.zip` dataset (road_damage_2025) |\n",
+        "| 3 | Extract the zip into `/content/pothole_data/` |\n",
+        "| 4 | Create master merged directory structure |\n",
+        "| 5 | Merge all dataset images + labels into one folder |\n",
+        "| 6 | Write `data.yaml` for 3-class detection |\n",
+        "| 7 | Train YOLOv8n for 50 epochs on T4 GPU (~45 min) |\n",
+        "| 8 | Export best weights to ONNX |\n",
+        "\n",
+        "> ⚠️ **Requires GPU runtime:** Runtime → Change runtime type → T4 GPU"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🔧 Step 1 — Environment Setup\n",
+        "\n",
+        "Keeps the Colab session alive during long training runs and installs all required libraries.\n",
+        "- `ultralytics` — YOLOv8 training framework by Ultralytics\n",
+        "- `roboflow` — dataset management (optional augmentation)\n",
+        "- `onnx` + `onnxruntime` — ONNX export and validation"
+      ]
+    },
     {
       "cell_type": "code",
       "execution_count": null,
@@ -65,6 +105,15 @@
         "print('Anti-disconnect activated')\n"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## ✅ Step 2 — Verify GPU & Import YOLO\n",
+        "\n",
+        "Confirms that the Tesla T4 GPU is available and the Ultralytics framework is ready."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -98,6 +147,19 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📁 Step 3 — Upload Dataset\n",
+        "\n",
+        "Upload the `archive.zip` file from the Hub:  \n",
+        "```\n",
+        "chatbot_service/data/pothole_training/road_damage_2025/archive.zip\n",
+        "```\n",
+        "> 📂 This contains ~2,009 labeled road damage images in YOLO format (potholes, cracks, manholes)."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -128,6 +190,16 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📦 Step 4 — Extract Dataset Archive\n",
+        "\n",
+        "Extracts `archive.zip` into `/content/pothole_data/`.  \n",
+        "This creates the raw YOLO-format dataset structure: `images/` and `labels/` subfolders."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -347,6 +419,16 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🗂️ Step 5 — Create Master Directory Structure\n",
+        "\n",
+        "Creates a unified `merged/` folder with separate `train/` and `valid/` splits.  \n",
+        "This allows merging images from multiple datasets (sachin_patel, andrew_mvd) if available."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -375,6 +457,18 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🔀 Step 6 — Merge Datasets (Bulletproof Search)\n",
+        "\n",
+        "Recursively searches all dataset folders for `.jpg` images and `.txt` YOLO labels,  \n",
+        "then copies them all into the master `merged/train/` directory.\n",
+        "\n",
+        "> ✅ Result: **2,009 training images** merged from road_damage_2025."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -409,6 +503,19 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📝 Step 7 — Write `data.yaml`\n",
+        "\n",
+        "Creates the YOLO dataset configuration file defining:\n",
+        "- 3 detection classes: `['pothole', 'crack', 'manhole']`\n",
+        "- Train and validation paths\n",
+        "\n",
+        "The `nc: 3` setting overrides the default YOLOv8 ImageNet classes."
+      ]
+    },
     {
       "cell_type": "code",
       "source": [
@@ -451,6 +558,26 @@
         }
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 🚀 Step 8 — Train YOLOv8n (50 Epochs)\n",
+        "\n",
+        "Trains YOLOv8 nano on the merged dataset using these hyperparameters:\n",
+        "\n",
+        "| Parameter | Value | Reason |\n",
+        "|-----------|-------|--------|\n",
+        "| `model` | yolov8n.pt | Smallest model — runs well in browser via ONNX |\n",
+        "| `epochs` | 50 | Balanced between accuracy and training time |\n",
+        "| `imgsz` | 640 | Standard YOLO input resolution |\n",
+        "| `batch` | 16 | Fits T4 14GB VRAM |\n",
+        "| `device` | 0 (GPU) | CUDA training |\n",
+        "\n",
+        "> ⏱️ Expected training time: **~45 minutes** on Tesla T4  \n",
+        "> 📈 Final mAP@50: ~**0.75+** after 50 epochs"
+      ]
+    },
     {
       "cell_type": "code",
       "source": [