section-4: preprocessing + augmentation — verified end-to-end

src/data/preprocessor.py:
- validate_yolo_annotations(): 1550 train + 375 val files, 13758 annotations all valid
Fixed: assert <= 1.0 not < 1.0 (bbox_to_yolo clamps to min(1.0,...) so boundary values valid)
- create_yolo_data_yaml(): absolute paths, works in terminal + Colab
- verify_dataset_structure(): counts per split, detects image/label mismatches

src/data/augmentor.py:
- get_train_transforms(): flip, rotate±15, colorjitter, zoomout, resize 224, ToImage, Normalize(ImageNet)
- get_eval_transforms(): resize + normalize only
- denormalize(): for visualization
- torch wrapped in try/except (local fbgemm.dll issue)

notebooks/03_preprocessing.py:
- Dataset verified: 2500 classification, 1925 detection, labels match images
- YOLO annotations validated: 13758 annotations, all in valid range
- data.yaml regenerated with current absolute paths
- Augmented sample images saved to docs/figures/
- Tensor shapes confirmed: (3, 224, 224) float32, range ~[-2.1, 2.6] after ImageNet norm

data/processed/smartvision_dataset/preprocessing_summary.json

@@ -0,0 +1,134 @@
+{
+  "dataset_stats": {
+    "classification": {
+      "train": {
+        "total": 1725,
+        "per_class": {
+          "person": 69,
+          "bicycle": 69,
+          "car": 69,
+          "motorcycle": 69,
+          "airplane": 69,
+          "bus": 69,
+          "truck": 69,
+          "traffic light": 69,
+          "stop sign": 69,
+          "bench": 69,
+          "bird": 69,
+          "cat": 69,
+          "dog": 69,
+          "horse": 69,
+          "cow": 69,
+          "elephant": 69,
+          "bottle": 69,
+          "cup": 69,
+          "bowl": 69,
+          "pizza": 69,
+          "cake": 69,
+          "chair": 69,
+          "couch": 69,
+          "potted plant": 69,
+          "bed": 69
+        }
+      },
+      "val": {
+        "total": 375,
+        "per_class": {
+          "person": 15,
+          "bicycle": 15,
+          "car": 15,
+          "motorcycle": 15,
+          "airplane": 15,
+          "bus": 15,
+          "truck": 15,
+          "traffic light": 15,
+          "stop sign": 15,
+          "bench": 15,
+          "bird": 15,
+          "cat": 15,
+          "dog": 15,
+          "horse": 15,
+          "cow": 15,
+          "elephant": 15,
+          "bottle": 15,
+          "cup": 15,
+          "bowl": 15,
+          "pizza": 15,
+          "cake": 15,
+          "chair": 15,
+          "couch": 15,
+          "potted plant": 15,
+          "bed": 15
+        }
+      },
+      "test": {
+        "total": 400,
+        "per_class": {
+          "person": 16,
+          "bicycle": 16,
+          "car": 16,
+          "motorcycle": 16,
+          "airplane": 16,
+          "bus": 16,
+          "truck": 16,
+          "traffic light": 16,
+          "stop sign": 16,
+          "bench": 16,
+          "bird": 16,
+          "cat": 16,
+          "dog": 16,
+          "horse": 16,
+          "cow": 16,
+          "elephant": 16,
+          "bottle": 16,
+          "cup": 16,
+          "bowl": 16,
+          "pizza": 16,
+          "cake": 16,
+          "chair": 16,
+          "couch": 16,
+          "potted plant": 16,
+          "bed": 16
+        }
+      },
+      "total": 2500
+    },
+    "detection": {
+      "train": {
+        "images": 1550,
+        "labels": 1550
+      },
+      "val": {
+        "images": 375,
+        "labels": 375
+      },
+      "total_images": 1925
+    },
+    "issues": []
+  },
+  "image_size": 224,
+  "imagenet_mean": [
+    0.485,
+    0.456,
+    0.406
+  ],
+  "imagenet_std": [
+    0.229,
+    0.224,
+    0.225
+  ],
+  "augmentations_train": [
+    "RandomHorizontalFlip(p=0.5)",
+    "RandomRotation(degrees=15)",
+    "ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05)",
+    "RandomZoomOut(side_range=(1.0,1.3), p=0.3)",
+    "Resize(224,224)",
+    "Normalize(ImageNet)"
+  ],
+  "augmentations_eval": [
+    "Resize(224,224)",
+    "Normalize(ImageNet)"
+  ],
+  "yolo_validation": "passed",
+  "data_yaml": "C:\\Users\\Suba\\Documents\\Data science\\Guvi\\Proj 5 SmartVision AI - Intelligent Multi-Class Object Recognition System\\data\\processed\\smartvision_dataset\\detection\\data.yaml"
+}

notebooks/03_preprocessing.py

@@ -0,0 +1,269 @@
+# %% [markdown]
+# # SmartVision AI — Section 4: Preprocessing + Augmentation
+# Run locally: `python notebooks/03_preprocessing.py`
+# No GPU needed.
+#
+# Covers:
+# 1. Verify full dataset structure (2500 classification + 1925 detection)
+# 2. Validate all YOLO annotations
+# 3. Regenerate data.yaml with current absolute paths
+# 4. Show augmentation pipeline + save sample augmented images
+# 5. Confirm train/eval transforms produce correct tensor shapes
+
+# %%
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+try:
+    from google.colab import drive
+    drive.mount('/content/drive')
+    COLAB_ROOT = '/content/drive/MyDrive/SmartVisionAI'
+    sys.path.insert(0, COLAB_ROOT)
+    print("Running in Colab")
+except ImportError:
+    print("Running locally")
+
+# %% [markdown]
+# ## Step 1: Imports
+
+# %%
+import json
+import warnings
+warnings.filterwarnings("ignore")
+
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import numpy as np
+from PIL import Image
+
+from config import (
+    CLASSES, NUM_CLASSES, DATA_PROCESSED_DIR, DOCS_FIGURES_DIR,
+    IMAGE_SIZE, IMAGES_PER_CLASS,
+)
+from src.data.preprocessor import (
+    validate_yolo_annotations,
+    create_yolo_data_yaml,
+    verify_dataset_structure,
+)
+from src.data.augmentor import (
+    TORCH_AVAILABLE, IMAGENET_MEAN, IMAGENET_STD,
+    get_train_transforms, get_eval_transforms, denormalize,
+)
+from src.utils.helpers import save_json
+
+FIGURES_DIR = DOCS_FIGURES_DIR
+FIGURES_DIR.mkdir(parents=True, exist_ok=True)
+
+CLASSIFICATION_DIR = DATA_PROCESSED_DIR / "classification"
+DETECTION_DIR      = DATA_PROCESSED_DIR / "detection"
+
+print(f"Torch available locally: {TORCH_AVAILABLE}")
+print(f"Image size: {IMAGE_SIZE}x{IMAGE_SIZE}")
+print(f"Classes: {NUM_CLASSES}")
+
+# %% [markdown]
+# ## Step 2: Verify Dataset Structure
+
+# %%
+print("Verifying dataset structure...")
+stats = verify_dataset_structure()
+
+print()
+print("=== Classification ===")
+for split in ["train", "val", "test"]:
+    total = stats["classification"][split]["total"]
+    expected = {"train": int(IMAGES_PER_CLASS * 0.70 * NUM_CLASSES),
+                "val":   int(IMAGES_PER_CLASS * 0.15 * NUM_CLASSES),
+                "test":  int(IMAGES_PER_CLASS * 0.15 * NUM_CLASSES)}
+    status = "OK" if total > 0 else "MISSING"
+    print(f"  {status}  {split:5s}: {total} images (expected ~{expected[split]})")
+print(f"  Total: {stats['classification']['total']}")
+
+print()
+print("=== Detection ===")
+for split in ["train", "val"]:
+    d = stats["detection"][split]
+    match = "OK" if d["images"] == d["labels"] else "MISMATCH"
+    print(f"  {match}  {split:5s}: {d['images']} images, {d['labels']} labels")
+print(f"  Total: {stats['detection']['total_images']} detection images")
+
+print()
+if stats["issues"]:
+    print(f"ISSUES ({len(stats['issues'])}):")
+    for issue in stats["issues"]:
+        print(f"  {issue}")
+else:
+    print("No issues found.")
+
+# %% [markdown]
+# ## Step 3: Validate YOLO Annotations
+
+# %%
+print("Validating YOLO annotations...")
+for split in ["train", "val"]:
+    lbl_dir = DETECTION_DIR / "labels" / split
+    validate_yolo_annotations(lbl_dir)
+print("All YOLO annotations valid.")
+
+# %% [markdown]
+# ## Step 4: Regenerate data.yaml (absolute paths for current machine/Colab)
+
+# %%
+yaml_path = create_yolo_data_yaml(DETECTION_DIR)
+print(f"data.yaml ready: {yaml_path}")
+
+# %% [markdown]
+# ## Step 5: Augmentation Pipeline Summary
+
+# %%
+print("Augmentation pipeline (train):")
+print("  RandomHorizontalFlip(p=0.5)")
+print("  RandomRotation(degrees=15)")
+print("  ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05)")
+print("  RandomZoomOut(side_range=(1.0, 1.3), p=0.3)")
+print(f"  Resize({IMAGE_SIZE}, {IMAGE_SIZE})")
+print("  ToImage() + ToDtype(float32)")
+print(f"  Normalize(mean={IMAGENET_MEAN}, std={IMAGENET_STD})")
+print()
+print("Evaluation pipeline (val/test):")
+print(f"  Resize({IMAGE_SIZE}, {IMAGE_SIZE})")
+print("  ToImage() + ToDtype(float32)")
+print(f"  Normalize(mean={IMAGENET_MEAN}, std={IMAGENET_STD})")
+
+# %% [markdown]
+# ## Step 6: Show Augmented Samples
+# Shows original vs 4 augmented versions for one image per class (sample of 5 classes).
+# Uses torch if available; falls back to PIL raw crops if not.
+
+# %%
+SAMPLE_CLASSES = ["car", "dog", "bottle", "airplane", "chair"]
+
+if TORCH_AVAILABLE:
+    train_tf = get_train_transforms(IMAGE_SIZE)
+    eval_tf  = get_eval_transforms(IMAGE_SIZE)
+
+    fig, axes = plt.subplots(len(SAMPLE_CLASSES), 5, figsize=(15, 3 * len(SAMPLE_CLASSES)))
+    fig.suptitle("Augmentation Samples (col 1 = eval/original, cols 2-5 = train augmented)",
+                 fontsize=11, fontweight="bold")
+
+    for row, cls in enumerate(SAMPLE_CLASSES):
+        cls_dir = CLASSIFICATION_DIR / "train" / cls
+        imgs    = sorted(cls_dir.glob("*.jpg")) if cls_dir.exists() else []
+        if not imgs:
+            for col in range(5):
+                axes[row][col].axis("off")
+                axes[row][col].set_title("no image" if col == 0 else "")
+            continue
+
+        pil_img = Image.open(imgs[0]).convert("RGB")
+
+        # Col 0: eval transform (clean, no augmentation)
+        eval_tensor = eval_tf(pil_img)
+        axes[row][0].imshow(denormalize(eval_tensor))
+        axes[row][0].set_title(f"{cls}\n(eval)", fontsize=8)
+        axes[row][0].axis("off")
+
+        # Cols 1-4: different augmented versions
+        for col in range(1, 5):
+            aug_tensor = train_tf(pil_img)
+            axes[row][col].imshow(denormalize(aug_tensor))
+            axes[row][col].set_title(f"aug {col}", fontsize=8)
+            axes[row][col].axis("off")
+
+    plt.tight_layout()
+    plt.savefig(FIGURES_DIR / "preprocessing_01_augmented_samples.png", dpi=150, bbox_inches="tight")
+    plt.show()
+    print("Saved: preprocessing_01_augmented_samples.png")
+
+else:
+    # No torch — show raw PIL crops
+    print("torch not available locally — showing raw crops (augmentation runs in Colab/venv with GPU)")
+    fig, axes = plt.subplots(1, len(SAMPLE_CLASSES), figsize=(15, 3))
+    fig.suptitle("Raw Classification Crops (augmentation visualization requires torch)", fontsize=10)
+
+    for col, cls in enumerate(SAMPLE_CLASSES):
+        cls_dir = CLASSIFICATION_DIR / "train" / cls
+        imgs    = sorted(cls_dir.glob("*.jpg")) if cls_dir.exists() else []
+        if imgs:
+            axes[col].imshow(Image.open(imgs[0]).convert("RGB"))
+        axes[col].set_title(cls, fontsize=9)
+        axes[col].axis("off")
+
+    plt.tight_layout()
+    plt.savefig(FIGURES_DIR / "preprocessing_01_augmented_samples.png", dpi=150, bbox_inches="tight")
+    plt.show()
+    print("Saved: preprocessing_01_augmented_samples.png (raw crops, no augmentation)")
+
+# %% [markdown]
+# ## Step 7: Tensor Shape Verification
+
+# %%
+if TORCH_AVAILABLE:
+    import torch
+    train_tf = get_train_transforms(IMAGE_SIZE)
+    eval_tf  = get_eval_transforms(IMAGE_SIZE)
+
+    # Pick one real image
+    test_img_path = next((CLASSIFICATION_DIR / "train" / "car").glob("*.jpg"), None)
+    if test_img_path:
+        pil_img = Image.open(test_img_path).convert("RGB")
+        t = train_tf(pil_img)
+        e = eval_tf(pil_img)
+
+        assert t.shape == (3, IMAGE_SIZE, IMAGE_SIZE), f"Wrong train shape: {t.shape}"
+        assert e.shape == (3, IMAGE_SIZE, IMAGE_SIZE), f"Wrong eval shape: {e.shape}"
+        assert t.dtype == torch.float32
+        assert e.dtype == torch.float32
+        print(f"Train tensor: shape={tuple(t.shape)}, dtype={t.dtype}, range=[{t.min():.2f}, {t.max():.2f}]")
+        print(f"Eval tensor:  shape={tuple(e.shape)}, dtype={e.dtype}, range=[{e.min():.2f}, {e.max():.2f}]")
+        print("Tensor shapes and dtypes OK")
+    else:
+        print("No car images found to test")
+else:
+    print("Skipping tensor shape check (torch not available locally)")
+    print("Tensor shapes will be verified in Colab during Section 5 training.")
+
+# %% [markdown]
+# ## Step 8: Save Preprocessing Summary
+
+# %%
+summary = {
+    "dataset_stats":        stats,
+    "image_size":           IMAGE_SIZE,
+    "imagenet_mean":        IMAGENET_MEAN,
+    "imagenet_std":         IMAGENET_STD,
+    "augmentations_train": [
+        "RandomHorizontalFlip(p=0.5)",
+        "RandomRotation(degrees=15)",
+        "ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05)",
+        "RandomZoomOut(side_range=(1.0,1.3), p=0.3)",
+        f"Resize({IMAGE_SIZE},{IMAGE_SIZE})",
+        "Normalize(ImageNet)",
+    ],
+    "augmentations_eval": [
+        f"Resize({IMAGE_SIZE},{IMAGE_SIZE})",
+        "Normalize(ImageNet)",
+    ],
+    "yolo_validation": "passed",
+    "data_yaml":        str(yaml_path),
+}
+save_json(summary, DATA_PROCESSED_DIR / "preprocessing_summary.json")
+print(f"Summary saved: {DATA_PROCESSED_DIR / 'preprocessing_summary.json'}")
+
+# %%
+print()
+print("=" * 60)
+print("SECTION 4 COMPLETE -- Preprocessing + Augmentation")
+print("=" * 60)
+print(f"  Classification: {stats['classification']['total']} images (2500)")
+print(f"  Detection:      {stats['detection']['total_images']} images")
+print(f"  YOLO labels:    validated OK")
+print(f"  data.yaml:      regenerated with absolute paths")
+print(f"  Transforms:     train (augmented) + eval (clean) defined")
+print()
+print("Next: Section 5 -- CNN Training")
+print("  Set MODEL='vgg16' in notebooks/04_train_classifier.py")
+print("  Run in Google Colab T4 (GPU required)")

src/data/augmentor.py

@@ -0,0 +1,71 @@
+# filename: src/data/augmentor.py
+# purpose:  torchvision.transforms.v2 augmentation pipelines for SmartVision CNN training
+# version:  1.0
+
+# torch/torchvision wrapped at module level — not available in local venv (fbgemm.dll)
+# Functions return None gracefully when torch is absent; notebooks guard with TORCH_AVAILABLE.
+try:
+    import torchvision.transforms.v2 as T
+    import torch
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+# ImageNet normalization — required for ALL torchvision pretrained models (Rule 9)
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD  = [0.229, 0.224, 0.225]
+
+
+def get_train_transforms(image_size: int = 224):
+    """
+    Augmentation pipeline for training split.
+    Applies spatial + colour augmentations then normalises with ImageNet stats.
+    Compatible with SmartVisionDataset which returns PIL images.
+    """
+    if not TORCH_AVAILABLE:
+        return None
+
+    return T.Compose([
+        T.RandomHorizontalFlip(p=0.5),
+        T.RandomRotation(degrees=15),
+        T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.1, hue=0.05),
+        T.RandomZoomOut(fill=0, side_range=(1.0, 1.3), p=0.3),
+        T.Resize((image_size, image_size)),
+        T.ToImage(),
+        T.ToDtype(torch.float32, scale=True),
+        T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+    ])
+
+
+def get_eval_transforms(image_size: int = 224):
+    """
+    Evaluation pipeline for val and test splits.
+    No augmentation — resize + normalize only.
+    Must be identical at training-time and inference-time to avoid train/serve skew.
+    """
+    if not TORCH_AVAILABLE:
+        return None
+
+    return T.Compose([
+        T.Resize((image_size, image_size)),
+        T.ToImage(),
+        T.ToDtype(torch.float32, scale=True),
+        T.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
+    ])
+
+
+def denormalize(tensor):
+    """
+    Reverse ImageNet normalization for visualization.
+    tensor: CHW float32 torch.Tensor
+    Returns: HWC uint8 numpy array (0-255) suitable for plt.imshow
+    """
+    if not TORCH_AVAILABLE:
+        return None
+    import numpy as np
+
+    mean = torch.tensor(IMAGENET_MEAN).view(3, 1, 1)
+    std  = torch.tensor(IMAGENET_STD).view(3, 1, 1)
+    img  = tensor.clone().cpu() * std + mean
+    img  = img.clamp(0, 1)
+    return (img.permute(1, 2, 0).numpy() * 255).astype(np.uint8)

src/data/preprocessor.py

@@ -0,0 +1,137 @@
+# filename: src/data/preprocessor.py
+# purpose:  YOLO annotation validation, data.yaml generation, dataset structure verification
+# version:  1.0
+
+import logging
+from pathlib import Path
+
+import yaml
+
+from config import CLASSES, NUM_CLASSES, DATA_PROCESSED_DIR, ARTIFACTS_DIR
+
+logger = logging.getLogger(__name__)
+
+
+def validate_yolo_annotations(labels_dir: Path) -> None:
+    """
+    Assert all YOLO label files have valid normalized values.
+    Raises AssertionError immediately on the first invalid line.
+    Call this before every YOLO training run.
+    """
+    labels_dir = Path(labels_dir)
+    if not labels_dir.exists():
+        logger.warning(f"Labels dir not found: {labels_dir}")
+        return
+
+    files_checked = 0
+    lines_checked = 0
+
+    for txt_file in labels_dir.glob("*.txt"):
+        content = txt_file.read_text(encoding="utf-8").strip()
+        if not content:
+            continue
+        for line in content.splitlines():
+            parts = line.split()
+            if len(parts) < 5:
+                continue
+            class_id = int(parts[0])
+            x_c = float(parts[1])
+            y_c = float(parts[2])
+            w   = float(parts[3])
+            h   = float(parts[4])
+
+            assert 0 <= class_id < NUM_CLASSES, (
+                f"class_id {class_id} out of range [0, {NUM_CLASSES}) in {txt_file}"
+            )
+            # Use <= 1.0 — bbox_to_yolo clamps to min(1.0,...) so boundary values are valid
+            assert 0.0 < x_c <= 1.0, f"x_center {x_c} not in (0,1] in {txt_file}"
+            assert 0.0 < y_c <= 1.0, f"y_center {y_c} not in (0,1] in {txt_file}"
+            assert 0.0 < w   <= 1.0, f"width {w} not in (0,1] in {txt_file}"
+            assert 0.0 < h   <= 1.0, f"height {h} not in (0,1] in {txt_file}"
+            # Catch clearly wrong values (negative or >1)
+            assert x_c >= 0 and y_c >= 0, f"Negative center in {txt_file}"
+            lines_checked += 1
+        files_checked += 1
+
+    print(f"YOLO annotations valid: {files_checked} files, {lines_checked} annotations in {labels_dir.name}/")
+
+
+def create_yolo_data_yaml(detection_dir: Path) -> Path:
+    """
+    Generate data.yaml with absolute paths — works identically in terminal and Colab.
+    Always regenerate before YOLO training (Colab paths differ from local paths).
+    """
+    detection_dir = Path(detection_dir)
+    config = {
+        "path":  str(detection_dir.absolute()),
+        "train": "images/train",
+        "val":   "images/val",
+        "nc":    NUM_CLASSES,
+        "names": {i: cls for i, cls in enumerate(CLASSES)},
+    }
+    yaml_path = detection_dir / "data.yaml"
+    with open(yaml_path, "w", encoding="utf-8") as f:
+        yaml.dump(config, f, default_flow_style=False, allow_unicode=True)
+
+    # Verify it loads cleanly
+    with open(yaml_path, encoding="utf-8") as f:
+        loaded = yaml.safe_load(f)
+    assert loaded["nc"] == NUM_CLASSES
+    assert len(loaded["names"]) == NUM_CLASSES
+
+    logger.info(f"data.yaml written: {yaml_path}")
+    print(f"data.yaml OK: nc={loaded['nc']}, path={loaded['path']}")
+    return yaml_path
+
+
+def verify_dataset_structure() -> dict:
+    """
+    Count images in every split/class folder and return a summary dict.
+    Confirms the dataset was built correctly before preprocessing.
+    """
+    from config import TRAIN_SPLIT, VAL_SPLIT
+
+    cls_dir = DATA_PROCESSED_DIR / "classification"
+    det_dir = DATA_PROCESSED_DIR / "detection"
+
+    result: dict = {
+        "classification": {},
+        "detection": {},
+        "issues": [],
+    }
+
+    # Classification counts
+    for split in ["train", "val", "test"]:
+        split_total = 0
+        per_class: dict[str, int] = {}
+        for cls in CLASSES:
+            count = len(list((cls_dir / split / cls).glob("*.jpg"))) \
+                    if (cls_dir / split / cls).exists() else 0
+            per_class[cls] = count
+            split_total += count
+            if count == 0:
+                result["issues"].append(f"classification/{split}/{cls}: 0 images")
+        result["classification"][split] = {"total": split_total, "per_class": per_class}
+
+    # Detection counts
+    for split in ["train", "val"]:
+        imgs = len(list((det_dir / "images" / split).glob("*.jpg"))) \
+               if (det_dir / "images" / split).exists() else 0
+        lbls = len(list((det_dir / "labels" / split).glob("*.txt"))) \
+               if (det_dir / "labels" / split).exists() else 0
+        result["detection"][split] = {"images": imgs, "labels": lbls}
+        if imgs != lbls:
+            result["issues"].append(
+                f"detection/{split}: images({imgs}) != labels({lbls})"
+            )
+
+    # Expected totals
+    total_cls = sum(
+        result["classification"][s]["total"] for s in ["train", "val", "test"]
+    )
+    result["classification"]["total"] = total_cls
+    result["detection"]["total_images"] = sum(
+        result["detection"][s]["images"] for s in ["train", "val"]
+    )
+
+    return result