autopilot/models/SiaN/homography.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92144cc0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 327 image pairs in C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\n",
      "Dataset size: 327\n",
      "Sample keys: ['google_img', 'yandex_img', 'homography', 'idx']\n",
      "Google image shape: torch.Size([3, 700, 700])\n",
      "Yandex image shape: torch.Size([3, 700, 700])\n",
      "Homography shape: torch.Size([3, 3])\n",
      "Found 327 image pairs in C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\n",
      "Train batches: 17\n",
      "Val batches: 5\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import random\n",
    "from typing import Any, Dict, List, Optional, Tuple\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import torch\n",
    "from PIL import Image\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "\n",
    "\n",
    "class HomographyDataset(Dataset):\n",
    "    \"\"\"\n",
    "    Dataset for homography estimation between Yandex and Google map image pairs.\n",
    "\n",
    "    This dataset loads pairs of images (Yandex and Google maps) and provides\n",
    "    homography matrices for data augmentation and training.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        root_dir: str,\n",
    "        transform=None,\n",
    "        augment: bool = True,\n",
    "        max_samples: Optional[int] = None,\n",
    "        image_size: Tuple[int, int] = (700, 700),\n",
    "        cache_homographies: bool = True,\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Initialize the HomographyDataset.\n",
    "\n",
    "        Args:\n",
    "            root_dir: Directory containing image pairs (format: {idx:04d}_google.png, {idx:04d}_yandex.png)\n",
    "            transform: Optional torchvision transforms to apply\n",
    "            augment: Whether to apply homography-based data augmentation\n",
    "            max_samples: Maximum number of samples to load (None for all)\n",
    "            image_size: Target size for images (height, width)\n",
    "            cache_homographies: Whether to cache generated homography matrices to disk\n",
    "        \"\"\"\n",
    "        self.root_dir = root_dir\n",
    "        self.transform = transform\n",
    "        self.augment = augment\n",
    "        self.image_size = image_size\n",
    "        self.cache_homographies = cache_homographies\n",
    "\n",
    "        # Find all image pairs\n",
    "        self.image_pairs = self._discover_image_pairs()\n",
    "\n",
    "        if max_samples is not None:\n",
    "            self.image_pairs = self.image_pairs[:max_samples]\n",
    "\n",
    "        print(f\"Found {len(self.image_pairs)} image pairs in {root_dir}\")\n",
    "\n",
    "        # Create directory for cached homographies if needed\n",
    "        if cache_homographies:\n",
    "            self.homography_cache_dir = os.path.join(root_dir, \"homography_cache\")\n",
    "            os.makedirs(self.homography_cache_dir, exist_ok=True)\n",
    "\n",
    "    def _discover_image_pairs(self) -> List[Dict[str, Any]]:\n",
    "        \"\"\"Discover all Google-Yandex image pairs in the dataset directory.\"\"\"\n",
    "        image_pairs = []\n",
    "\n",
    "        # Get all Google images\n",
    "        google_files = [\n",
    "            f for f in os.listdir(self.root_dir) if f.endswith(\"_google.png\")\n",
    "        ]\n",
    "\n",
    "        for google_file in sorted(google_files):\n",
    "            # Extract index from filename\n",
    "            idx_str = google_file.split(\"_\")[0]\n",
    "            try:\n",
    "                idx = int(idx_str)\n",
    "            except ValueError:\n",
    "                continue\n",
    "\n",
    "            # Check if corresponding Yandex image exists\n",
    "            yandex_file = f\"{idx:04d}_yandex.png\"\n",
    "            yandex_path = os.path.join(self.root_dir, yandex_file)\n",
    "\n",
    "            if os.path.exists(yandex_path):\n",
    "                image_pairs.append(\n",
    "                    {\n",
    "                        \"idx\": idx,\n",
    "                        \"google_path\": os.path.join(self.root_dir, google_file),\n",
    "                        \"yandex_path\": yandex_path,\n",
    "                    }\n",
    "                )\n",
    "\n",
    "        return image_pairs\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        \"\"\"Return the number of image pairs in the dataset.\"\"\"\n",
    "        return len(self.image_pairs)\n",
    "\n",
    "    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:\n",
    "        \"\"\"\n",
    "        Get a sample from the dataset.\n",
    "\n",
    "        Returns a dictionary with:\n",
    "            - 'google_img': Google map image tensor\n",
    "            - 'yandex_img': Yandex map image tensor\n",
    "            - 'homography': Ground truth homography matrix (3x3)\n",
    "            - 'idx': Sample index\n",
    "        \"\"\"\n",
    "        pair_info = self.image_pairs[idx]\n",
    "\n",
    "        # Load images\n",
    "        google_img = Image.open(pair_info[\"google_path\"]).convert(\"RGB\")\n",
    "        yandex_img = Image.open(pair_info[\"yandex_path\"]).convert(\"RGB\")\n",
    "\n",
    "        # Resize images to target size\n",
    "        google_img = google_img.resize(\n",
    "            (self.image_size[1], self.image_size[0]), Image.BILINEAR\n",
    "        )\n",
    "        yandex_img = yandex_img.resize(\n",
    "            (self.image_size[1], self.image_size[0]), Image.BILINEAR\n",
    "        )\n",
    "\n",
    "        # Get or generate homography matrix\n",
    "        homography_matrix = self._get_homography_matrix(pair_info[\"idx\"])\n",
    "\n",
    "        # Apply data augmentation if enabled\n",
    "        if self.augment:\n",
    "            google_img, yandex_img, homography_matrix = self._apply_augmentation(\n",
    "                google_img, yandex_img, homography_matrix\n",
    "            )\n",
    "\n",
    "        # Convert images to tensors\n",
    "        if self.transform:\n",
    "            google_img = self.transform(google_img)\n",
    "            yandex_img = self.transform(yandex_img)\n",
    "        else:\n",
    "            # Default conversion to tensor\n",
    "            google_img = (\n",
    "                torch.from_numpy(np.array(google_img)).float().permute(2, 0, 1) / 255.0\n",
    "            )\n",
    "            yandex_img = (\n",
    "                torch.from_numpy(np.array(yandex_img)).float().permute(2, 0, 1) / 255.0\n",
    "            )\n",
    "\n",
    "        # Convert homography to tensor\n",
    "        homography_tensor = torch.from_numpy(homography_matrix).float()\n",
    "\n",
    "        return {\n",
    "            \"google_img\": google_img,\n",
    "            \"yandex_img\": yandex_img,\n",
    "            \"homography\": homography_tensor,\n",
    "            \"idx\": torch.tensor(pair_info[\"idx\"], dtype=torch.long),\n",
    "        }\n",
    "\n",
    "    def _get_homography_matrix(self, idx: int) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Get homography matrix for a given index.\n",
    "\n",
    "        If cached homography exists, load it. Otherwise generate a new one.\n",
    "        \"\"\"\n",
    "        if self.cache_homographies:\n",
    "            cache_path = os.path.join(\n",
    "                self.homography_cache_dir, f\"{idx:04d}_homography.npy\"\n",
    "            )\n",
    "            if os.path.exists(cache_path):\n",
    "                return np.load(cache_path)\n",
    "\n",
    "        # Generate new homography matrix\n",
    "        homography_matrix = self.generate_random_homography()\n",
    "\n",
    "        # Cache if enabled\n",
    "        if self.cache_homographies:\n",
    "            np.save(cache_path, homography_matrix)\n",
    "\n",
    "        return homography_matrix\n",
    "\n",
    "    def generate_random_homography(self) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Generate a random homography matrix for data augmentation.\n",
    "\n",
    "        Returns:\n",
    "            np.ndarray: 3x3 homography matrix.\n",
    "        \"\"\"\n",
    "        # Generate random affine transformation parameters\n",
    "        angle = np.random.uniform(-30, 30)  # rotation in degrees\n",
    "        scale = np.random.uniform(0.8, 1.2)  # scaling factor\n",
    "        tx = np.random.uniform(-50, 50)  # translation in x\n",
    "        ty = np.random.uniform(-50, 50)  # translation in y\n",
    "\n",
    "        # Convert angle to radians\n",
    "        theta = np.radians(angle)\n",
    "\n",
    "        # Create affine transformation matrix\n",
    "        affine_matrix = np.array(\n",
    "            [\n",
    "                [scale * np.cos(theta), -scale * np.sin(theta), tx],\n",
    "                [scale * np.sin(theta), scale * np.cos(theta), ty],\n",
    "                [0, 0, 1],\n",
    "            ]\n",
    "        )\n",
    "\n",
    "        # Add small perspective distortion\n",
    "        perspective = np.random.uniform(-0.001, 0.001, (2, 3))\n",
    "        perspective = np.vstack([perspective, [0, 0, 0]])\n",
    "\n",
    "        homography_matrix = affine_matrix + perspective\n",
    "\n",
    "        return homography_matrix\n",
    "\n",
    "    def _apply_augmentation(\n",
    "        self,\n",
    "        google_img: Image.Image,\n",
    "        yandex_img: Image.Image,\n",
    "        base_homography: np.ndarray,\n",
    "    ) -> Tuple[Image.Image, Image.Image, np.ndarray]:\n",
    "        \"\"\"\n",
    "        Apply homography-based data augmentation to image pair.\n",
    "\n",
    "        Args:\n",
    "            google_img: Google map image\n",
    "            yandex_img: Yandex map image\n",
    "            base_homography: Base homography matrix\n",
    "\n",
    "        Returns:\n",
    "            Tuple of (augmented_google_img, augmented_yandex_img, augmented_homography)\n",
    "        \"\"\"\n",
    "        # Generate augmentation homography\n",
    "        aug_homography = self.generate_random_homography()\n",
    "\n",
    "        # Combine with base homography\n",
    "        combined_homography = aug_homography @ base_homography\n",
    "\n",
    "        # Apply augmentation to both images\n",
    "        # google_aug = self._apply_homography_to_image(google_img, aug_homography)\n",
    "        google_aug = google_img.copy()\n",
    "        yandex_aug = self._apply_homography_to_image(yandex_img, aug_homography)\n",
    "\n",
    "        return google_aug, yandex_aug, combined_homography\n",
    "\n",
    "    def _apply_homography_to_image(\n",
    "        self, img: Image.Image, homography: np.ndarray\n",
    "    ) -> Image.Image:\n",
    "        \"\"\"\n",
    "        Apply homography transformation to a single image.\n",
    "\n",
    "        Args:\n",
    "            img: PIL Image to transform\n",
    "            homography: 3x3 homography matrix\n",
    "\n",
    "        Returns:\n",
    "            Transformed PIL Image\n",
    "        \"\"\"\n",
    "        # Convert to numpy array\n",
    "        img_np = np.array(img)\n",
    "\n",
    "        # Get image dimensions\n",
    "        h, w = img_np.shape[:2]\n",
    "\n",
    "        # Apply homography transformation\n",
    "        transformed = cv2.warpPerspective(\n",
    "            img_np,\n",
    "            homography,\n",
    "            (w, h),\n",
    "            flags=cv2.INTER_LINEAR,\n",
    "            borderMode=cv2.BORDER_TRANSPARENT,\n",
    "        )\n",
    "\n",
    "        # Convert back to PIL Image\n",
    "        return Image.fromarray(transformed)\n",
    "\n",
    "    def get_sample_without_augmentation(self, idx: int) -> Dict[str, Any]:\n",
    "        \"\"\"\n",
    "        Get a sample without data augmentation.\n",
    "\n",
    "        Useful for visualization and evaluation.\n",
    "        \"\"\"\n",
    "        pair_info = self.image_pairs[idx]\n",
    "\n",
    "        # Load images\n",
    "        google_img = Image.open(pair_info[\"google_path\"]).convert(\"RGB\")\n",
    "        yandex_img = Image.open(pair_info[\"yandex_path\"]).convert(\"RGB\")\n",
    "\n",
    "        # Resize\n",
    "        google_img = google_img.resize(\n",
    "            (self.image_size[1], self.image_size[0]), Image.BILINEAR\n",
    "        )\n",
    "        yandex_img = yandex_img.resize(\n",
    "            (self.image_size[1], self.image_size[0]), Image.BILINEAR\n",
    "        )\n",
    "\n",
    "        # Get homography matrix\n",
    "        homography_matrix = self._get_homography_matrix(pair_info[\"idx\"])\n",
    "\n",
    "        return {\n",
    "            \"google_img\": google_img,\n",
    "            \"yandex_img\": yandex_img,\n",
    "            \"homography\": homography_matrix,\n",
    "            \"idx\": pair_info[\"idx\"],\n",
    "            \"google_path\": pair_info[\"google_path\"],\n",
    "            \"yandex_path\": pair_info[\"yandex_path\"],\n",
    "        }\n",
    "\n",
    "\n",
    "def create_data_loaders(\n",
    "    root_dir: str,\n",
    "    batch_size: int = 32,\n",
    "    train_split: float = 0.8,\n",
    "    num_workers: int = 4,\n",
    "    image_size: Tuple[int, int] = (256, 256),\n",
    "    augment_train: bool = True,\n",
    "    augment_val: bool = False,\n",
    ") -> Tuple[DataLoader, DataLoader]:\n",
    "    \"\"\"\n",
    "    Create train and validation data loaders for homography estimation.\n",
    "\n",
    "    Args:\n",
    "        root_dir: Directory containing image pairs\n",
    "        batch_size: Batch size for data loaders\n",
    "        train_split: Fraction of data to use for training\n",
    "        num_workers: Number of worker processes for data loading\n",
    "        image_size: Target image size (height, width)\n",
    "        augment_train: Whether to augment training data\n",
    "        augment_val: Whether to augment validation data\n",
    "\n",
    "    Returns:\n",
    "        Tuple of (train_loader, val_loader)\n",
    "    \"\"\"\n",
    "    from torchvision import transforms\n",
    "\n",
    "    # Define transforms\n",
    "    transform = transforms.Compose(\n",
    "        [\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    # Create full dataset\n",
    "    full_dataset = HomographyDataset(\n",
    "        root_dir=root_dir,\n",
    "        transform=transform,\n",
    "        augment=False,  # We'll handle augmentation separately\n",
    "        image_size=image_size,\n",
    "        cache_homographies=True,\n",
    "    )\n",
    "\n",
    "    # Split dataset\n",
    "    dataset_size = len(full_dataset)\n",
    "    train_size = int(train_split * dataset_size)\n",
    "    val_size = dataset_size - train_size\n",
    "\n",
    "    # Create indices for splitting\n",
    "    indices = list(range(dataset_size))\n",
    "    random.shuffle(indices)\n",
    "    train_indices = indices[:train_size]\n",
    "    val_indices = indices[train_size:]\n",
    "\n",
    "    # Create subset samplers\n",
    "    from torch.utils.data import Subset\n",
    "\n",
    "    train_dataset = Subset(full_dataset, train_indices)\n",
    "    val_dataset = Subset(full_dataset, val_indices)\n",
    "\n",
    "    # Apply augmentation by overriding __getitem__ for train dataset\n",
    "    if augment_train:\n",
    "\n",
    "        class AugmentedSubset(Subset):\n",
    "            def __getitem__(self, idx):\n",
    "                sample = self.dataset[self.indices[idx]]\n",
    "                # Apply augmentation\n",
    "                google_img = sample[\"google_img\"]\n",
    "                yandex_img = sample[\"yandex_img\"]\n",
    "                homography = sample[\"homography\"]\n",
    "\n",
    "                # Generate augmentation homography\n",
    "                aug_homography = torch.from_numpy(\n",
    "                    full_dataset.generate_random_homography()\n",
    "                ).float()\n",
    "\n",
    "                # Combine homographies\n",
    "                combined_homography = aug_homography @ homography\n",
    "\n",
    "                # Apply augmentation (simplified - in practice would warp images)\n",
    "                # For now, we just return the combined homography\n",
    "                return {\n",
    "                    \"google_img\": google_img,\n",
    "                    \"yandex_img\": yandex_img,\n",
    "                    \"homography\": combined_homography,\n",
    "                    \"idx\": sample[\"idx\"],\n",
    "                }\n",
    "\n",
    "        train_dataset = AugmentedSubset(full_dataset, train_indices)\n",
    "\n",
    "    # Create data loaders\n",
    "    train_loader = DataLoader(\n",
    "        train_dataset,\n",
    "        batch_size=batch_size,\n",
    "        shuffle=True,\n",
    "        num_workers=num_workers,\n",
    "        pin_memory=True,\n",
    "    )\n",
    "\n",
    "    val_loader = DataLoader(\n",
    "        val_dataset,\n",
    "        batch_size=batch_size,\n",
    "        shuffle=False,\n",
    "        num_workers=num_workers,\n",
    "        pin_memory=True,\n",
    "    )\n",
    "\n",
    "    return train_loader, val_loader\n",
    "\n",
    "\n",
    "# Example usage\n",
    "dataset = HomographyDataset(\n",
    "    root_dir=r\"C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\",\n",
    "    augment=True,\n",
    "    image_size=(700, 700),\n",
    ")\n",
    "\n",
    "print(f\"Dataset size: {len(dataset)}\")\n",
    "\n",
    "# Get a sample\n",
    "sample = dataset[0]\n",
    "print(f\"Sample keys: {list(sample.keys())}\")\n",
    "print(f\"Google image shape: {sample['google_img'].shape}\")\n",
    "print(f\"Yandex image shape: {sample['yandex_img'].shape}\")\n",
    "print(f\"Homography shape: {sample['homography'].shape}\")\n",
    "\n",
    "# Create data loaders\n",
    "train_loader, val_loader = create_data_loaders(\n",
    "    root_dir=r\"C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\",\n",
    "    batch_size=16,\n",
    "    train_split=0.8,\n",
    ")\n",
    "\n",
    "print(f\"Train batches: {len(train_loader)}\")\n",
    "print(f\"Val batches: {len(val_loader)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8fbcdfcb",
   "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": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def f(tensor: torch.Tensor):\n",
    "    arr_rgb = tensor.permute((1, 2, 0)).numpy() * 255\n",
    "    arr_rgb = arr_rgb.astype(np.uint8)\n",
    "    img = Image.fromarray(arr_rgb)\n",
    "    plt.imshow(img)\n",
    "    plt.show()\n",
    "\n",
    "temp = dataset[2]\n",
    "f(temp['google_img'])\n",
    "f(temp['yandex_img'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf3b0524",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n",
      "Model created with 1,728,137 parameters\n",
      "\n",
      "Testing forward pass...\n",
      "SHAPE OF GOOGLE FEATUES: torch.Size([4, 64, 175, 175])\n",
      "SHAPE OF YANDEX FEATUES: torch.Size([4, 64, 175, 175])\n",
      "SHAPE OF COMBINED FEATUES: torch.Size([4, 128, 175, 175])\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "Given groups=1, weight of size [256, 512, 3, 3], expected input[4, 128, 175, 175] to have 512 channels, but got 128 channels instead",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mRuntimeError\u001b[39m                              Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[20]\u001b[39m\u001b[32m, line 512\u001b[39m\n\u001b[32m    510\u001b[39m \u001b[38;5;66;03m# Test forward pass\u001b[39;00m\n\u001b[32m    511\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33mTesting forward pass...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m512\u001b[39m output = \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgoogle_img\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43myandex_img\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_matrix\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m    513\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mOutput shape: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00moutput.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)  \u001b[38;5;66;03m# Should be (4, 3, 3)\u001b[39;00m\n\u001b[32m    514\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mSample output:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00moutput[\u001b[32m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1776\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1774\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m   1775\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1776\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1787\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1782\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m   1783\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m   1784\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m   1785\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m   1786\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1787\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1789\u001b[39m result = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m   1790\u001b[39m called_always_called_hooks = \u001b[38;5;28mset\u001b[39m()\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[20]\u001b[39m\u001b[32m, line 193\u001b[39m, in \u001b[36mHomographyCNN.forward\u001b[39m\u001b[34m(self, google_img, yandex_img, return_matrix)\u001b[39m\n\u001b[32m    190\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mSHAPE OF COMBINED FEATUES:\u001b[39m\u001b[33m\"\u001b[39m, combined_features.shape)\n\u001b[32m    192\u001b[39m \u001b[38;5;66;03m# Fuse features\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m193\u001b[39m fused_features = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mfusion_layers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcombined_features\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    195\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mSHAPE OF FUSED FEATURES:\u001b[39m\u001b[33m\"\u001b[39m, fused_features.shape)\n\u001b[32m    197\u001b[39m \u001b[38;5;66;03m# Regression to get homography parameters\u001b[39;00m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1776\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1774\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m   1775\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1776\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1787\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1782\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m   1783\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m   1784\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m   1785\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m   1786\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1787\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1789\u001b[39m result = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m   1790\u001b[39m called_always_called_hooks = \u001b[38;5;28mset\u001b[39m()\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\container.py:253\u001b[39m, in \u001b[36mSequential.forward\u001b[39m\u001b[34m(self, input)\u001b[39m\n\u001b[32m    249\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    250\u001b[39m \u001b[33;03mRuns the forward pass.\u001b[39;00m\n\u001b[32m    251\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m    252\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m253\u001b[39m     \u001b[38;5;28minput\u001b[39m = \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m    254\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1776\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1774\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m   1775\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1776\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1787\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m   1782\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m   1783\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m   1784\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m   1785\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m   1786\u001b[39m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1787\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m   1789\u001b[39m result = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m   1790\u001b[39m called_always_called_hooks = \u001b[38;5;28mset\u001b[39m()\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\conv.py:553\u001b[39m, in \u001b[36mConv2d.forward\u001b[39m\u001b[34m(self, input)\u001b[39m\n\u001b[32m    552\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) -> Tensor:\n\u001b[32m--> \u001b[39m\u001b[32m553\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_conv_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\nn\\modules\\conv.py:548\u001b[39m, in \u001b[36mConv2d._conv_forward\u001b[39m\u001b[34m(self, input, weight, bias)\u001b[39m\n\u001b[32m    535\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.padding_mode != \u001b[33m\"\u001b[39m\u001b[33mzeros\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m    536\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m F.conv2d(\n\u001b[32m    537\u001b[39m         F.pad(\n\u001b[32m    538\u001b[39m             \u001b[38;5;28minput\u001b[39m, \u001b[38;5;28mself\u001b[39m._reversed_padding_repeated_twice, mode=\u001b[38;5;28mself\u001b[39m.padding_mode\n\u001b[32m   (...)\u001b[39m\u001b[32m    545\u001b[39m         \u001b[38;5;28mself\u001b[39m.groups,\n\u001b[32m    546\u001b[39m     )\n\u001b[32m--> \u001b[39m\u001b[32m548\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[43m.\u001b[49m\u001b[43mconv2d\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    549\u001b[39m \u001b[43m    \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mpadding\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdilation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mgroups\u001b[49m\n\u001b[32m    550\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[31mRuntimeError\u001b[39m: Given groups=1, weight of size [256, 512, 3, 3], expected input[4, 128, 175, 175] to have 512 channels, but got 128 channels instead"
     ]
    }
   ],
   "source": [
    "from typing import Optional, Tuple\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class HomographyCNN(nn.Module):\n",
    "    \"\"\"\n",
    "    CNN model for homography estimation between two images.\n",
    "\n",
    "    This model takes two images (Google and Yandex maps) as input and\n",
    "    outputs a 3x3 homography matrix that transforms one image to align with the other.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_channels: int = 3,\n",
    "        hidden_channels: int = 64,\n",
    "        num_blocks: int = 4,\n",
    "        dropout_rate: float = 0.3,\n",
    "        use_batch_norm: bool = True,\n",
    "        output_size: int = 9,  # Flattened 3x3 homography matrix\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Initialize the HomographyCNN model.\n",
    "\n",
    "        Args:\n",
    "            input_channels: Number of input channels per image (3 for RGB)\n",
    "            hidden_channels: Base number of channels in the network\n",
    "            num_blocks: Number of convolutional blocks\n",
    "            dropout_rate: Dropout rate for regularization\n",
    "            use_batch_norm: Whether to use batch normalization\n",
    "            output_size: Size of output vector (9 for flattened 3x3 matrix)\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "\n",
    "        self.input_channels = input_channels\n",
    "        self.hidden_channels = hidden_channels\n",
    "        self.num_blocks = num_blocks\n",
    "        self.dropout_rate = dropout_rate\n",
    "        self.use_batch_norm = use_batch_norm\n",
    "\n",
    "        # Feature extraction for each image separately\n",
    "        self.google_encoder = self._build_encoder()\n",
    "        self.yandex_encoder = self._build_encoder()\n",
    "\n",
    "        # Fusion layers to combine features from both images\n",
    "        self.fusion_layers = self._build_fusion_layers()\n",
    "\n",
    "        # Regression head for homography estimation\n",
    "        self.regression_head = self._build_regression_head(output_size)\n",
    "\n",
    "        # Initialize weights\n",
    "        self._initialize_weights()\n",
    "\n",
    "    def _build_encoder(self) -> nn.Module:\n",
    "        \"\"\"Build the encoder network for a single image.\"\"\"\n",
    "        layers = []\n",
    "        in_channels = self.input_channels\n",
    "        out_channels = self.hidden_channels\n",
    "\n",
    "        # First convolutional block\n",
    "        layers.append(\n",
    "            nn.Conv2d(in_channels, out_channels, kernel_size=7, stride=2, padding=3)\n",
    "        )\n",
    "        if self.use_batch_norm:\n",
    "            layers.append(nn.BatchNorm2d(out_channels))\n",
    "        layers.append(nn.ReLU(inplace=True))\n",
    "        layers.append(nn.MaxPool2d(kernel_size=3, stride=2, padding=1))\n",
    "\n",
    "        # Additional convolutional blocks\n",
    "        for i in range(self.num_blocks):\n",
    "            block_in_channels = out_channels\n",
    "            block_out_channels = out_channels * 2 if i < 2 else out_channels\n",
    "\n",
    "            layers.append(\n",
    "                ResidualBlock(\n",
    "                    in_channels=block_in_channels,\n",
    "                    out_channels=block_out_channels,\n",
    "                    stride=1 if i == 0 else 2,\n",
    "                    dropout_rate=self.dropout_rate,\n",
    "                    use_batch_norm=self.use_batch_norm,\n",
    "                )\n",
    "            )\n",
    "\n",
    "            if i < 2:\n",
    "                out_channels = block_out_channels\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def _build_fusion_layers(self) -> nn.Module:\n",
    "        \"\"\"Build layers to fuse features from both images.\"\"\"\n",
    "        # After encoding, each image has hidden_channels * 4 features\n",
    "        fused_channels = (\n",
    "            self.hidden_channels * 8\n",
    "        )  # Concatenated features from both images\n",
    "\n",
    "        layers = [\n",
    "            # Reduce dimensionality\n",
    "            nn.Conv2d(\n",
    "                fused_channels, self.hidden_channels * 4, kernel_size=3, padding=1\n",
    "            ),\n",
    "            nn.BatchNorm2d(self.hidden_channels * 4)\n",
    "            if self.use_batch_norm\n",
    "            else nn.Identity(),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout2d(self.dropout_rate),\n",
    "            # Further processing\n",
    "            nn.Conv2d(\n",
    "                self.hidden_channels * 4,\n",
    "                self.hidden_channels * 2,\n",
    "                kernel_size=3,\n",
    "                padding=1,\n",
    "            ),\n",
    "            nn.BatchNorm2d(self.hidden_channels * 2)\n",
    "            if self.use_batch_norm\n",
    "            else nn.Identity(),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout2d(self.dropout_rate),\n",
    "            # Global pooling\n",
    "            nn.AdaptiveAvgPool2d((1, 1)),\n",
    "        ]\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def _build_regression_head(self, output_size: int) -> nn.Module:\n",
    "        \"\"\"Build the regression head for homography estimation.\"\"\"\n",
    "        # Input size after fusion and global pooling\n",
    "        input_features = self.hidden_channels * 2\n",
    "\n",
    "        layers = [\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(input_features, 512),\n",
    "            nn.BatchNorm1d(512) if self.use_batch_norm else nn.Identity(),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(self.dropout_rate),\n",
    "            nn.Linear(512, 256),\n",
    "            nn.BatchNorm1d(256) if self.use_batch_norm else nn.Identity(),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(self.dropout_rate),\n",
    "            nn.Linear(256, 128),\n",
    "            nn.BatchNorm1d(128) if self.use_batch_norm else nn.Identity(),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Dropout(self.dropout_rate),\n",
    "            nn.Linear(128, output_size),\n",
    "        ]\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        \"\"\"Initialize model weights.\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n",
    "                if m.bias is not None:\n",
    "                    nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm1d):\n",
    "                nn.init.constant_(m.weight, 1)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        google_img: torch.Tensor,\n",
    "        yandex_img: torch.Tensor,\n",
    "        return_matrix: bool = True,\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Forward pass of the model.\n",
    "\n",
    "        Args:\n",
    "            google_img: Google map image tensor of shape (B, C, H, W)\n",
    "            yandex_img: Yandex map image tensor of shape (B, C, H, W)\n",
    "            return_matrix: If True, return 3x3 matrix; if False, return flattened vector\n",
    "\n",
    "        Returns:\n",
    "            Homography matrix tensor of shape (B, 3, 3) or flattened vector of shape (B, 9)\n",
    "        \"\"\"\n",
    "        # Extract features from both images\n",
    "        google_features = self.google_encoder(google_img)\n",
    "        yandex_features = self.yandex_encoder(yandex_img)\n",
    "        print(\"SHAPE OF GOOGLE FEATUES:\", google_features.shape)\n",
    "        print(\"SHAPE OF YANDEX FEATUES:\", yandex_features.shape)\n",
    "\n",
    "        # Concatenate features along channel dimension\n",
    "        combined_features = torch.cat([google_features, yandex_features], dim=1)\n",
    "        print(\"SHAPE OF COMBINED FEATUES:\", combined_features.shape)\n",
    "\n",
    "        # Fuse features\n",
    "        fused_features = self.fusion_layers(combined_features)\n",
    "\n",
    "        print(\"SHAPE OF FUSED FEATURES:\", fused_features.shape)\n",
    "\n",
    "        # Regression to get homography parameters\n",
    "        homography_flat = self.regression_head(fused_features)\n",
    "\n",
    "        if return_matrix:\n",
    "            # Reshape to 3x3 matrix\n",
    "            batch_size = homography_flat.shape[0]\n",
    "            homography_matrix = homography_flat.view(batch_size, 3, 3)\n",
    "\n",
    "            # Ensure the last element is 1 (homogeneous coordinate normalization)\n",
    "            # Add small epsilon to prevent division by zero\n",
    "            epsilon = 1e-8\n",
    "            homography_matrix = homography_matrix / (\n",
    "                homography_matrix[:, 2, 2].view(-1, 1, 1) + epsilon\n",
    "            )\n",
    "\n",
    "            return homography_matrix\n",
    "        else:\n",
    "            return homography_flat\n",
    "\n",
    "    def predict_homography(\n",
    "        self,\n",
    "        google_img: torch.Tensor,\n",
    "        yandex_img: torch.Tensor,\n",
    "        normalize: bool = True,\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Predict homography matrix with optional normalization.\n",
    "\n",
    "        Args:\n",
    "            google_img: Google map image tensor\n",
    "            yandex_img: Yandex map image tensor\n",
    "            normalize: Whether to normalize the homography matrix\n",
    "\n",
    "        Returns:\n",
    "            Predicted homography matrix\n",
    "        \"\"\"\n",
    "        self.eval()\n",
    "        with torch.no_grad():\n",
    "            homography = self.forward(google_img, yandex_img, return_matrix=True)\n",
    "\n",
    "            if normalize:\n",
    "                # Normalize so that last element is 1\n",
    "                homography = homography / homography[:, 2, 2].view(-1, 1, 1)\n",
    "\n",
    "            return homography\n",
    "\n",
    "\n",
    "class ResidualBlock(nn.Module):\n",
    "    \"\"\"Residual block with optional downsampling.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        in_channels: int,\n",
    "        out_channels: int,\n",
    "        stride: int = 1,\n",
    "        dropout_rate: float = 0.3,\n",
    "        use_batch_norm: bool = True,\n",
    "    ):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv2d(\n",
    "            in_channels,\n",
    "            out_channels,\n",
    "            kernel_size=3,\n",
    "            stride=stride,\n",
    "            padding=1,\n",
    "            bias=False,\n",
    "        )\n",
    "        self.bn1 = nn.BatchNorm2d(out_channels) if use_batch_norm else nn.Identity()\n",
    "        self.relu1 = nn.ReLU(inplace=True)\n",
    "        self.dropout1 = (\n",
    "            nn.Dropout2d(dropout_rate) if dropout_rate > 0 else nn.Identity()\n",
    "        )\n",
    "\n",
    "        self.conv2 = nn.Conv2d(\n",
    "            out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False\n",
    "        )\n",
    "        self.bn2 = nn.BatchNorm2d(out_channels) if use_batch_norm else nn.Identity()\n",
    "        self.relu2 = nn.ReLU(inplace=True)\n",
    "        self.dropout2 = (\n",
    "            nn.Dropout2d(dropout_rate) if dropout_rate > 0 else nn.Identity()\n",
    "        )\n",
    "\n",
    "        # Shortcut connection\n",
    "        self.shortcut = nn.Sequential()\n",
    "        if stride != 1 or in_channels != out_channels:\n",
    "            self.shortcut = nn.Sequential(\n",
    "                nn.Conv2d(\n",
    "                    in_channels, out_channels, kernel_size=1, stride=stride, bias=False\n",
    "                ),\n",
    "                nn.BatchNorm2d(out_channels) if use_batch_norm else nn.Identity(),\n",
    "            )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        identity = self.shortcut(x)\n",
    "\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu1(out)\n",
    "        out = self.dropout1(out)\n",
    "\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "\n",
    "        out += identity\n",
    "        out = self.relu2(out)\n",
    "        out = self.dropout2(out)\n",
    "\n",
    "        return out\n",
    "\n",
    "\n",
    "class HomographyLoss(nn.Module):\n",
    "    \"\"\"\n",
    "    Custom loss function for homography estimation.\n",
    "\n",
    "    Combines multiple loss terms:\n",
    "    1. Matrix element-wise L2 loss\n",
    "    2. Geometric consistency loss (warping error)\n",
    "    3. Determinant regularization (to prevent degenerate matrices)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        matrix_weight: float = 1.0,\n",
    "        geometric_weight: float = 0.5,\n",
    "        reg_weight: float = 0.1,\n",
    "        grid_size: int = 8,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.matrix_weight = matrix_weight\n",
    "        self.geometric_weight = geometric_weight\n",
    "        self.reg_weight = reg_weight\n",
    "        self.grid_size = grid_size\n",
    "\n",
    "        # Create grid of points for geometric loss\n",
    "        self.register_buffer(\n",
    "            \"grid_points\",\n",
    "            self._create_grid_points(grid_size),\n",
    "            persistent=False,\n",
    "        )\n",
    "\n",
    "    def _create_grid_points(self, grid_size: int) -> torch.Tensor:\n",
    "        \"\"\"Create a grid of points for geometric consistency loss.\"\"\"\n",
    "        x = torch.linspace(-1, 1, grid_size)\n",
    "        y = torch.linspace(-1, 1, grid_size)\n",
    "        grid_y, grid_x = torch.meshgrid(y, x, indexing=\"ij\")\n",
    "        grid_points = torch.stack([grid_x.flatten(), grid_y.flatten()], dim=1)\n",
    "        # Add homogeneous coordinate\n",
    "        ones = torch.ones(grid_points.shape[0], 1)\n",
    "        grid_points = torch.cat([grid_points, ones], dim=1)\n",
    "        return grid_points.T  # Shape: (3, grid_size*grid_size)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        pred_homography: torch.Tensor,\n",
    "        target_homography: torch.Tensor,\n",
    "        google_img: Optional[torch.Tensor] = None,\n",
    "        yandex_img: Optional[torch.Tensor] = None,\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Compute homography loss.\n",
    "\n",
    "        Args:\n",
    "            pred_homography: Predicted homography matrices (B, 3, 3)\n",
    "            target_homography: Target homography matrices (B, 3, 3)\n",
    "            google_img: Google images (optional, for geometric loss)\n",
    "            yandex_img: Yandex images (optional, for geometric loss)\n",
    "\n",
    "        Returns:\n",
    "            Combined loss value\n",
    "        \"\"\"\n",
    "        batch_size = pred_homography.shape[0]\n",
    "\n",
    "        # 1. Matrix element-wise L2 loss\n",
    "        matrix_loss = F.mse_loss(pred_homography, target_homography)\n",
    "\n",
    "        # 2. Geometric consistency loss (if images provided)\n",
    "        geometric_loss = torch.tensor(0.0, device=pred_homography.device)\n",
    "        if google_img is not None and yandex_img is not None:\n",
    "            # Warp grid points with predicted homography\n",
    "            grid_points = self.grid_points.unsqueeze(0).expand(batch_size, -1, -1)\n",
    "            warped_points = torch.bmm(pred_homography, grid_points)\n",
    "\n",
    "            # Normalize homogeneous coordinates\n",
    "            warped_points = warped_points / (warped_points[:, 2:3, :] + 1e-8)\n",
    "\n",
    "            # Warp with target homography for comparison\n",
    "            target_warped_points = torch.bmm(target_homography, grid_points)\n",
    "            target_warped_points = target_warped_points / (\n",
    "                target_warped_points[:, 2:3, :] + 1e-8\n",
    "            )\n",
    "\n",
    "            # Compute point-wise distance\n",
    "            geometric_loss = F.mse_loss(\n",
    "                warped_points[:, :2, :], target_warped_points[:, :2, :]\n",
    "            )\n",
    "\n",
    "        # 3. Regularization loss (prevent degenerate matrices)\n",
    "        # Encourage determinant to be close to 1\n",
    "        pred_det = torch.det(pred_homography)\n",
    "        reg_loss = F.mse_loss(pred_det, torch.ones_like(pred_det))\n",
    "\n",
    "        # Combine losses\n",
    "        total_loss = (\n",
    "            self.matrix_weight * matrix_loss\n",
    "            + self.geometric_weight * geometric_loss\n",
    "            + self.reg_weight * reg_loss\n",
    "        )\n",
    "\n",
    "        return total_loss\n",
    "\n",
    "    def compute_metrics(\n",
    "        self,\n",
    "        pred_homography: torch.Tensor,\n",
    "        target_homography: torch.Tensor,\n",
    "    ) -> dict:\n",
    "        \"\"\"\n",
    "        Compute evaluation metrics for homography estimation.\n",
    "\n",
    "        Args:\n",
    "            pred_homography: Predicted homography matrices\n",
    "            target_homography: Target homography matrices\n",
    "\n",
    "        Returns:\n",
    "            Dictionary of metrics\n",
    "        \"\"\"\n",
    "        with torch.no_grad():\n",
    "            # Normalize matrices\n",
    "            pred_norm = pred_homography / pred_homography[:, 2, 2].view(-1, 1, 1)\n",
    "            target_norm = target_homography / target_homography[:, 2, 2].view(-1, 1, 1)\n",
    "\n",
    "            # Matrix L2 error\n",
    "            matrix_error = F.mse_loss(pred_norm, target_norm, reduction=\"none\").mean(\n",
    "                dim=(1, 2)\n",
    "            )\n",
    "\n",
    "            # Corner error (warp 4 corners of the image)\n",
    "            corners = torch.tensor(\n",
    "                [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]],\n",
    "                dtype=torch.float32,\n",
    "                device=pred_homography.device,\n",
    "            ).T  # Shape: (3, 4)\n",
    "\n",
    "            corners = corners.unsqueeze(0).expand(pred_homography.shape[0], -1, -1)\n",
    "\n",
    "            pred_corners = torch.bmm(pred_norm, corners)\n",
    "            pred_corners = pred_corners / (pred_corners[:, 2:3, :] + 1e-8)\n",
    "\n",
    "            target_corners = torch.bmm(target_norm, corners)\n",
    "            target_corners = target_corners / (target_corners[:, 2:3, :] + 1e-8)\n",
    "\n",
    "            corner_error = torch.mean(\n",
    "                torch.norm(pred_corners[:, :2, :] - target_corners[:, :2, :], dim=1),\n",
    "                dim=1,\n",
    "            )\n",
    "\n",
    "            # Average corner error in pixels (assuming image coordinates in [-1, 1])\n",
    "            # Convert to pixel error if image size is known\n",
    "            avg_corner_error = corner_error.mean().item()\n",
    "\n",
    "            return {\n",
    "                \"matrix_mse\": matrix_error.mean().item(),\n",
    "                \"corner_error\": avg_corner_error,\n",
    "                \"corner_error_px\": avg_corner_error * 128,  # Assuming 256x256 images\n",
    "            }\n",
    "\n",
    "\n",
    "def create_homography_model(\n",
    "    model_type: str = \"cnn\",\n",
    "    input_size: Tuple[int, int] = (256, 256),\n",
    "    **kwargs,\n",
    ") -> nn.Module:\n",
    "    \"\"\"\n",
    "    Factory function to create homography estimation model.\n",
    "\n",
    "    Args:\n",
    "        model_type: Type of model to create ('cnn' or 'resnet')\n",
    "        input_size: Input image size (height, width)\n",
    "        **kwargs: Additional arguments passed to model constructor\n",
    "\n",
    "    Returns:\n",
    "        Homography estimation model\n",
    "    \"\"\"\n",
    "    if model_type == \"cnn\":\n",
    "        return HomographyCNN(**kwargs)\n",
    "    else:\n",
    "        raise ValueError(f\"Unknown model type: {model_type}\")\n",
    "\n",
    "\n",
    "# Test the model\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Create model\n",
    "model = HomographyCNN(\n",
    "    input_channels=3,\n",
    "    hidden_channels=64,\n",
    "    num_blocks=4,\n",
    "    dropout_rate=0.3,\n",
    "    use_batch_norm=True,\n",
    ").to(device)\n",
    "\n",
    "print(\n",
    "    f\"Model created with {sum(p.numel() for p in model.parameters()):,} parameters\"\n",
    ")\n",
    "\n",
    "# Create dummy input\n",
    "batch_size = 4\n",
    "height, width = 700, 700\n",
    "\n",
    "google_img = torch.randn(batch_size, 3, height, width).to(device)\n",
    "yandex_img = torch.randn(batch_size, 3, height, width).to(device)\n",
    "\n",
    "# Test forward pass\n",
    "print(\"\\nTesting forward pass...\")\n",
    "output = model(google_img, yandex_img, return_matrix=True)\n",
    "print(f\"Output shape: {output.shape}\")  # Should be (4, 3, 3)\n",
    "print(f\"Sample output:\\n{output[0]}\")\n",
    "\n",
    "# Test prediction\n",
    "print(\"\\nTesting prediction...\")\n",
    "pred = model.predict_homography(google_img, yandex_img)\n",
    "print(f\"Prediction shape: {pred.shape}\")\n",
    "print(f\"Last element (should be ~1): {pred[0, 2, 2]:.6f}\")\n",
    "\n",
    "# Test loss function\n",
    "print(\"\\nTesting loss function...\")\n",
    "target_homography = torch.eye(3).unsqueeze(0).expand(batch_size, -1, -1).to(device)\n",
    "loss_fn = HomographyLoss(\n",
    "    matrix_weight=1.0,\n",
    "    geometric_weight=0.5,\n",
    "    reg_weight=0.1,\n",
    "    grid_size=8,\n",
    ").to(device)\n",
    "\n",
    "loss = loss_fn(output, target_homography, google_img, yandex_img)\n",
    "print(f\"Loss value: {loss.item():.6f}\")\n",
    "\n",
    "# Test metrics\n",
    "print(\"\\nTesting metrics...\")\n",
    "metrics = loss_fn.compute_metrics(output, target_homography)\n",
    "for key, value in metrics.items():\n",
    "    print(f\"{key}: {value:.6f}\")\n",
    "\n",
    "# Test model factory\n",
    "print(\"\\nTesting model factory...\")\n",
    "model2 = create_homography_model(\n",
    "    model_type=\"cnn\",\n",
    "    input_size=(700, 700),\n",
    "    input_channels=3,\n",
    "    hidden_channels=32,\n",
    "    num_blocks=3,\n",
    ").to(device)\n",
    "\n",
    "print(\n",
    "    f\"Model2 created with {sum(p.numel() for p in model2.parameters()):,} parameters\"\n",
    ")\n",
    "\n",
    "print(\"\\nAll tests completed successfully!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d7979efa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n",
      "Creating data loaders...\n",
      "Found 327 image pairs in C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\n",
      "Train batches: 9\n",
      "Val batches: 3\n",
      "Creating model...\n",
      "Training configuration saved to runs\\homography\\config.json\n",
      "Model has 8,999,817 parameters\n",
      "Starting training for 100 epochs...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/9 [00:00<?, ?it/s]c:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\utils\\data\\dataloader.py:775: UserWarning: 'pin_memory' argument is set as true but no accelerator is found, then device pinned memory won't be used.\n",
      "  super().__init__(loader)\n",
      "Epoch 1: 100%|██████████| 9/9 [00:35<00:00,  3.91s/it, loss=700]    \n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.27s/it, loss=240]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 1/100:\n",
      "  Train Loss: 1479120.494765\n",
      "  Val Loss: 478.277028\n",
      "  Val Metrics:\n",
      "    matrix_mse: 147.178922\n",
      "    corner_error: 32.230527\n",
      "    corner_error_px: 4125.507487\n",
      "Best model saved to runs\\homography\\checkpoint_best.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 9/9 [00:27<00:00,  3.01s/it, loss=579]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.18s/it, loss=239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 2/100:\n",
      "  Train Loss: 576.320560\n",
      "  Val Loss: 478.246948\n",
      "  Val Metrics:\n",
      "    matrix_mse: 147.097862\n",
      "    corner_error: 32.266284\n",
      "    corner_error_px: 4130.084391\n",
      "Best model saved to runs\\homography\\checkpoint_best.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 9/9 [00:27<00:00,  3.03s/it, loss=662]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.20s/it, loss=239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 3/100:\n",
      "  Train Loss: 583.684543\n",
      "  Val Loss: 477.970149\n",
      "  Val Metrics:\n",
      "    matrix_mse: 147.042124\n",
      "    corner_error: 32.275155\n",
      "    corner_error_px: 4131.219808\n",
      "Best model saved to runs\\homography\\checkpoint_best.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 9/9 [00:26<00:00,  2.98s/it, loss=480]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.17s/it, loss=237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 4/100:\n",
      "  Train Loss: 566.442430\n",
      "  Val Loss: 477.443873\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.916545\n",
      "    corner_error: 32.347406\n",
      "    corner_error_px: 4140.468018\n",
      "Best model saved to runs\\homography\\checkpoint_best.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 9/9 [00:26<00:00,  2.96s/it, loss=511]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.17s/it, loss=237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 5/100:\n",
      "  Train Loss: 569.418077\n",
      "  Val Loss: 477.695648\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.986056\n",
      "    corner_error: 32.371653\n",
      "    corner_error_px: 4143.571615\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 9/9 [00:26<00:00,  2.96s/it, loss=572]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.19s/it, loss=236]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 6/100:\n",
      "  Train Loss: 575.172797\n",
      "  Val Loss: 477.494090\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.943362\n",
      "    corner_error: 32.346752\n",
      "    corner_error_px: 4140.384277\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 9/9 [00:27<00:00,  3.01s/it, loss=515]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.22s/it, loss=235]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 7/100:\n",
      "  Train Loss: 569.967285\n",
      "  Val Loss: 476.897807\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.790746\n",
      "    corner_error: 32.321693\n",
      "    corner_error_px: 4137.176676\n",
      "Best model saved to runs\\homography\\checkpoint_best.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 9/9 [00:27<00:00,  3.00s/it, loss=353]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.18s/it, loss=235]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 8/100:\n",
      "  Train Loss: 554.235372\n",
      "  Val Loss: 477.317505\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.863836\n",
      "    corner_error: 32.393528\n",
      "    corner_error_px: 4146.371582\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 9/9 [00:26<00:00,  2.99s/it, loss=559]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.17s/it, loss=233]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 9/100:\n",
      "  Train Loss: 575.319882\n",
      "  Val Loss: 476.710429\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.698456\n",
      "    corner_error: 32.465488\n",
      "    corner_error_px: 4155.582520\n",
      "Best model saved to runs\\homography\\checkpoint_best.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 9/9 [00:26<00:00,  2.97s/it, loss=402]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.18s/it, loss=235]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 10/100:\n",
      "  Train Loss: 569.601579\n",
      "  Val Loss: 476.900670\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.699109\n",
      "    corner_error: 32.328031\n",
      "    corner_error_px: 4137.987956\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 9/9 [00:27<00:00,  3.06s/it, loss=413]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.19s/it, loss=237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 11/100:\n",
      "  Train Loss: 579.589498\n",
      "  Val Loss: 477.335510\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.834834\n",
      "    corner_error: 32.289221\n",
      "    corner_error_px: 4133.020264\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 9/9 [00:27<00:00,  3.00s/it, loss=695]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.19s/it, loss=238]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 12/100:\n",
      "  Train Loss: 586.814080\n",
      "  Val Loss: 477.815531\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.969218\n",
      "    corner_error: 32.305283\n",
      "    corner_error_px: 4135.076172\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 9/9 [00:27<00:00,  3.01s/it, loss=610]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.20s/it, loss=237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 13/100:\n",
      "  Train Loss: 578.611084\n",
      "  Val Loss: 477.640121\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.942223\n",
      "    corner_error: 32.298669\n",
      "    corner_error_px: 4134.229574\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 9/9 [00:26<00:00,  3.00s/it, loss=514]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.19s/it, loss=237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 14/100:\n",
      "  Train Loss: 570.041660\n",
      "  Val Loss: 477.448573\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.903755\n",
      "    corner_error: 32.286489\n",
      "    corner_error_px: 4132.670654\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 9/9 [00:27<00:00,  3.04s/it, loss=546]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.23s/it, loss=239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 15/100:\n",
      "  Train Loss: 572.714983\n",
      "  Val Loss: 478.183182\n",
      "  Val Metrics:\n",
      "    matrix_mse: 147.095807\n",
      "    corner_error: 32.298265\n",
      "    corner_error_px: 4134.177897\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 9/9 [00:27<00:00,  3.08s/it, loss=506]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.21s/it, loss=238]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 16/100:\n",
      "  Train Loss: 569.011841\n",
      "  Val Loss: 477.966741\n",
      "  Val Metrics:\n",
      "    matrix_mse: 147.047829\n",
      "    corner_error: 32.295083\n",
      "    corner_error_px: 4133.770589\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 9/9 [00:27<00:00,  3.10s/it, loss=658]\n",
      "Validation: 100%|██████████| 3/3 [00:03<00:00,  1.22s/it, loss=237]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 17/100:\n",
      "  Train Loss: 583.327128\n",
      "  Val Loss: 477.646459\n",
      "  Val Metrics:\n",
      "    matrix_mse: 146.966235\n",
      "    corner_error: 32.288345\n",
      "    corner_error_px: 4132.908203\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18:  22%|██▏       | 2/9 [00:10<00:36,  5.19s/it, loss=618]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mKeyboardInterrupt\u001b[39m                         Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 533\u001b[39m\n\u001b[32m    530\u001b[39m     trainer.evaluate()\n\u001b[32m    531\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    532\u001b[39m     \u001b[38;5;66;03m# Train the model\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m533\u001b[39m     \u001b[43mtrainer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtrain\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnum_epochs\u001b[49m\u001b[43m=\u001b[49m\u001b[43margs\u001b[49m\u001b[43m.\u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    535\u001b[39m     \u001b[38;5;66;03m# Final evaluation\u001b[39;00m\n\u001b[32m    536\u001b[39m     \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33mPerforming final evaluation...\u001b[39m\u001b[33m\"\u001b[39m)\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 299\u001b[39m, in \u001b[36mHomographyTrainer.train\u001b[39m\u001b[34m(self, num_epochs)\u001b[39m\n\u001b[32m    296\u001b[39m \u001b[38;5;28mself\u001b[39m.current_epoch = epoch\n\u001b[32m    298\u001b[39m \u001b[38;5;66;03m# Train for one epoch\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m299\u001b[39m train_loss = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtrain_epoch\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    301\u001b[39m \u001b[38;5;66;03m# Validate\u001b[39;00m\n\u001b[32m    302\u001b[39m val_loss, val_metrics = \u001b[38;5;28mself\u001b[39m.validate()\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 162\u001b[39m, in \u001b[36mHomographyTrainer.train_epoch\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    154\u001b[39m loss = \u001b[38;5;28mself\u001b[39m.criterion(\n\u001b[32m    155\u001b[39m     pred_homography,\n\u001b[32m    156\u001b[39m     target_homography,\n\u001b[32m    157\u001b[39m     google_img,\n\u001b[32m    158\u001b[39m     yandex_img,\n\u001b[32m    159\u001b[39m )\n\u001b[32m    161\u001b[39m \u001b[38;5;66;03m# Backward pass\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m162\u001b[39m \u001b[43mloss\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m    164\u001b[39m \u001b[38;5;66;03m# Gradient clipping\u001b[39;00m\n\u001b[32m    165\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.config.get(\u001b[33m\"\u001b[39m\u001b[33mgrad_clip\u001b[39m\u001b[33m\"\u001b[39m, \u001b[32m1.0\u001b[39m) > \u001b[32m0\u001b[39m:\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\_tensor.py:630\u001b[39m, in \u001b[36mTensor.backward\u001b[39m\u001b[34m(self, gradient, retain_graph, create_graph, inputs)\u001b[39m\n\u001b[32m    620\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m    621\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[32m    622\u001b[39m         Tensor.backward,\n\u001b[32m    623\u001b[39m         (\u001b[38;5;28mself\u001b[39m,),\n\u001b[32m   (...)\u001b[39m\u001b[32m    628\u001b[39m         inputs=inputs,\n\u001b[32m    629\u001b[39m     )\n\u001b[32m--> \u001b[39m\u001b[32m630\u001b[39m \u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43mautograd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    631\u001b[39m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43minputs\u001b[49m\n\u001b[32m    632\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\autograd\\__init__.py:364\u001b[39m, in \u001b[36mbackward\u001b[39m\u001b[34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[39m\n\u001b[32m    359\u001b[39m     retain_graph = create_graph\n\u001b[32m    361\u001b[39m \u001b[38;5;66;03m# The reason we repeat the same comment below is that\u001b[39;00m\n\u001b[32m    362\u001b[39m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[32m    363\u001b[39m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m364\u001b[39m \u001b[43m_engine_run_backward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m    365\u001b[39m \u001b[43m    \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    366\u001b[39m \u001b[43m    \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    367\u001b[39m \u001b[43m    \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    368\u001b[39m \u001b[43m    \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    369\u001b[39m \u001b[43m    \u001b[49m\u001b[43minputs_tuple\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m    370\u001b[39m \u001b[43m    \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m    371\u001b[39m \u001b[43m    \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m    372\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\admin\\Projects\\autopilot\\.venv\\Lib\\site-packages\\torch\\autograd\\graph.py:865\u001b[39m, in \u001b[36m_engine_run_backward\u001b[39m\u001b[34m(t_outputs, *args, **kwargs)\u001b[39m\n\u001b[32m    863\u001b[39m     unregister_hooks = _register_logging_hooks_on_whole_graph(t_outputs)\n\u001b[32m    864\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m865\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mVariable\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_execution_engine\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[32m    866\u001b[39m \u001b[43m        \u001b[49m\u001b[43mt_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\n\u001b[32m    867\u001b[39m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Calls into the C++ engine to run the backward pass\u001b[39;00m\n\u001b[32m    868\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m    869\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m attach_logging_hooks:\n",
      "\u001b[31mKeyboardInterrupt\u001b[39m: "
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Training script for homography estimation between Google and Yandex map images.\n",
    "\n",
    "This script trains a CNN model to estimate homography matrices that align\n",
    "Google map images with Yandex map images.\n",
    "\"\"\"\n",
    "\n",
    "import argparse\n",
    "import json\n",
    "import os\n",
    "import time\n",
    "from datetime import datetime\n",
    "from pathlib import Path\n",
    "from typing import Dict, List, Optional, Tuple\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "from tqdm import tqdm\n",
    "\n",
    "\n",
    "class HomographyTrainer:\n",
    "    \"\"\"Trainer class for homography estimation model.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        model: nn.Module,\n",
    "        train_loader: DataLoader,\n",
    "        val_loader: DataLoader,\n",
    "        device: torch.device,\n",
    "        config: Dict,\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Initialize the trainer.\n",
    "\n",
    "        Args:\n",
    "            model: Homography estimation model\n",
    "            train_loader: Training data loader\n",
    "            val_loader: Validation data loader\n",
    "            device: Device to run training on\n",
    "            config: Training configuration dictionary\n",
    "        \"\"\"\n",
    "        self.model = model.to(device)\n",
    "        self.train_loader = train_loader\n",
    "        self.val_loader = val_loader\n",
    "        self.device = device\n",
    "        self.config = config\n",
    "\n",
    "        # Loss function\n",
    "        self.criterion = HomographyLoss(\n",
    "            matrix_weight=config.get(\"matrix_weight\", 1.0),\n",
    "            geometric_weight=config.get(\"geometric_weight\", 0.5),\n",
    "            reg_weight=config.get(\"reg_weight\", 0.1),\n",
    "            grid_size=config.get(\"grid_size\", 8),\n",
    "        ).to(device)\n",
    "\n",
    "        # Optimizer\n",
    "        optimizer_name = config.get(\"optimizer\", \"adam\").lower()\n",
    "        lr = config.get(\"learning_rate\", 1e-3)\n",
    "        weight_decay = config.get(\"weight_decay\", 1e-4)\n",
    "\n",
    "        if optimizer_name == \"adam\":\n",
    "            self.optimizer = optim.Adam(\n",
    "                self.model.parameters(), lr=lr, weight_decay=weight_decay\n",
    "            )\n",
    "        elif optimizer_name == \"adamw\":\n",
    "            self.optimizer = optim.AdamW(\n",
    "                self.model.parameters(), lr=lr, weight_decay=weight_decay\n",
    "            )\n",
    "        elif optimizer_name == \"sgd\":\n",
    "            self.optimizer = optim.SGD(\n",
    "                self.model.parameters(),\n",
    "                lr=lr,\n",
    "                momentum=config.get(\"momentum\", 0.9),\n",
    "                weight_decay=weight_decay,\n",
    "            )\n",
    "        else:\n",
    "            raise ValueError(f\"Unknown optimizer: {optimizer_name}\")\n",
    "\n",
    "        # Learning rate scheduler\n",
    "        scheduler_name = config.get(\"scheduler\", \"plateau\").lower()\n",
    "        if scheduler_name == \"plateau\":\n",
    "            self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(\n",
    "                self.optimizer,\n",
    "                mode=\"min\",\n",
    "                factor=config.get(\"scheduler_factor\", 0.5),\n",
    "                patience=config.get(\"scheduler_patience\", 5),\n",
    "            )\n",
    "        elif scheduler_name == \"cosine\":\n",
    "            self.scheduler = optim.lr_scheduler.CosineAnnealingLR(\n",
    "                self.optimizer,\n",
    "                T_max=config.get(\"epochs\", 100),\n",
    "                eta_min=config.get(\"min_lr\", 1e-6),\n",
    "            )\n",
    "        elif scheduler_name == \"step\":\n",
    "            self.scheduler = optim.lr_scheduler.StepLR(\n",
    "                self.optimizer,\n",
    "                step_size=config.get(\"step_size\", 30),\n",
    "                gamma=config.get(\"gamma\", 0.1),\n",
    "            )\n",
    "        else:\n",
    "            self.scheduler = None\n",
    "\n",
    "        # Training state\n",
    "        self.current_epoch = 0\n",
    "        self.best_val_loss = float(\"inf\")\n",
    "        self.train_losses: List[float] = []\n",
    "        self.val_losses: List[float] = []\n",
    "        self.val_metrics: List[Dict] = []\n",
    "\n",
    "        # Create output directory\n",
    "        self.output_dir = Path(config.get(\"output_dir\", \"runs/homography\"))\n",
    "        self.output_dir.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "        # TensorBoard writer\n",
    "        self.writer = SummaryWriter(log_dir=self.output_dir / \"tensorboard\")\n",
    "\n",
    "        # Save configuration\n",
    "        config_path = self.output_dir / \"config.json\"\n",
    "        with open(config_path, \"w\") as f:\n",
    "            json.dump(config, f, indent=2)\n",
    "\n",
    "        print(f\"Training configuration saved to {config_path}\")\n",
    "        print(\n",
    "            f\"Model has {sum(p.numel() for p in self.model.parameters()):,} parameters\"\n",
    "        )\n",
    "\n",
    "    def train_epoch(self) -> float:\n",
    "        \"\"\"\n",
    "        Train for one epoch.\n",
    "\n",
    "        Returns:\n",
    "            Average training loss for the epoch\n",
    "        \"\"\"\n",
    "        self.model.train()\n",
    "        total_loss = 0.0\n",
    "        num_batches = len(self.train_loader)\n",
    "\n",
    "        progress_bar = tqdm(self.train_loader, desc=f\"Epoch {self.current_epoch + 1}\")\n",
    "        for batch_idx, batch in enumerate(progress_bar):\n",
    "            # Move data to device\n",
    "            google_img = batch[\"google_img\"].to(self.device)\n",
    "            yandex_img = batch[\"yandex_img\"].to(self.device)\n",
    "            target_homography = batch[\"homography\"].to(self.device)\n",
    "\n",
    "            # Forward pass\n",
    "            self.optimizer.zero_grad()\n",
    "            pred_homography = self.model(google_img, yandex_img, return_matrix=True)\n",
    "\n",
    "            # Compute loss\n",
    "            loss = self.criterion(\n",
    "                pred_homography,\n",
    "                target_homography,\n",
    "                google_img,\n",
    "                yandex_img,\n",
    "            )\n",
    "\n",
    "            # Backward pass\n",
    "            loss.backward()\n",
    "\n",
    "            # Gradient clipping\n",
    "            if self.config.get(\"grad_clip\", 1.0) > 0:\n",
    "                torch.nn.utils.clip_grad_norm_(\n",
    "                    self.model.parameters(),\n",
    "                    self.config.get(\"grad_clip\", 1.0),\n",
    "                )\n",
    "\n",
    "            # Optimizer step\n",
    "            self.optimizer.step()\n",
    "\n",
    "            # Update statistics\n",
    "            total_loss += loss.item()\n",
    "\n",
    "            # Update progress bar\n",
    "            progress_bar.set_postfix({\"loss\": loss.item()})\n",
    "\n",
    "            # Log batch loss to TensorBoard\n",
    "            global_step = self.current_epoch * num_batches + batch_idx\n",
    "            self.writer.add_scalar(\"train/batch_loss\", loss.item(), global_step)\n",
    "\n",
    "        avg_loss = total_loss / num_batches\n",
    "        self.train_losses.append(avg_loss)\n",
    "\n",
    "        return avg_loss\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def validate(self) -> Tuple[float, Dict]:\n",
    "        \"\"\"\n",
    "        Validate the model.\n",
    "\n",
    "        Returns:\n",
    "            Tuple of (average validation loss, validation metrics)\n",
    "        \"\"\"\n",
    "        self.model.eval()\n",
    "        total_loss = 0.0\n",
    "        all_metrics = []\n",
    "\n",
    "        progress_bar = tqdm(self.val_loader, desc=\"Validation\")\n",
    "        for batch in progress_bar:\n",
    "            # Move data to device\n",
    "            google_img = batch[\"google_img\"].to(self.device)\n",
    "            yandex_img = batch[\"yandex_img\"].to(self.device)\n",
    "            target_homography = batch[\"homography\"].to(self.device)\n",
    "\n",
    "            # Forward pass\n",
    "            pred_homography = self.model(google_img, yandex_img, return_matrix=True)\n",
    "\n",
    "            # Compute loss\n",
    "            loss = self.criterion(\n",
    "                pred_homography,\n",
    "                target_homography,\n",
    "                google_img,\n",
    "                yandex_img,\n",
    "            )\n",
    "\n",
    "            # Compute metrics\n",
    "            metrics = self.criterion.compute_metrics(pred_homography, target_homography)\n",
    "\n",
    "            # Update statistics\n",
    "            total_loss += loss.item()\n",
    "            all_metrics.append(metrics)\n",
    "\n",
    "            # Update progress bar\n",
    "            progress_bar.set_postfix({\"loss\": loss.item()})\n",
    "\n",
    "        avg_loss = total_loss / len(self.val_loader)\n",
    "        self.val_losses.append(avg_loss)\n",
    "\n",
    "        # Aggregate metrics\n",
    "        avg_metrics = {}\n",
    "        for key in all_metrics[0].keys():\n",
    "            avg_metrics[key] = np.mean([m[key] for m in all_metrics])\n",
    "\n",
    "        self.val_metrics.append(avg_metrics)\n",
    "\n",
    "        return avg_loss, avg_metrics\n",
    "\n",
    "    def save_checkpoint(self, is_best: bool = False):\n",
    "        \"\"\"Save model checkpoint.\"\"\"\n",
    "        checkpoint = {\n",
    "            \"epoch\": self.current_epoch,\n",
    "            \"model_state_dict\": self.model.state_dict(),\n",
    "            \"optimizer_state_dict\": self.optimizer.state_dict(),\n",
    "            \"train_losses\": self.train_losses,\n",
    "            \"val_losses\": self.val_losses,\n",
    "            \"val_metrics\": self.val_metrics,\n",
    "            \"best_val_loss\": self.best_val_loss,\n",
    "            \"config\": self.config,\n",
    "        }\n",
    "\n",
    "        if self.scheduler is not None:\n",
    "            checkpoint[\"scheduler_state_dict\"] = self.scheduler.state_dict()\n",
    "\n",
    "        # Save latest checkpoint\n",
    "        checkpoint_path = self.output_dir / \"checkpoint_latest.pth\"\n",
    "        torch.save(checkpoint, checkpoint_path)\n",
    "\n",
    "        # Save best checkpoint\n",
    "        if is_best:\n",
    "            best_path = self.output_dir / \"checkpoint_best.pth\"\n",
    "            torch.save(checkpoint, best_path)\n",
    "            print(f\"Best model saved to {best_path}\")\n",
    "\n",
    "    def load_checkpoint(self, checkpoint_path: str):\n",
    "        \"\"\"Load model checkpoint.\"\"\"\n",
    "        checkpoint = torch.load(checkpoint_path, map_location=self.device)\n",
    "\n",
    "        self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n",
    "        self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n",
    "\n",
    "        if self.scheduler is not None and \"scheduler_state_dict\" in checkpoint:\n",
    "            self.scheduler.load_state_dict(checkpoint[\"scheduler_state_dict\"])\n",
    "\n",
    "        self.current_epoch = checkpoint[\"epoch\"]\n",
    "        self.train_losses = checkpoint[\"train_losses\"]\n",
    "        self.val_losses = checkpoint[\"val_losses\"]\n",
    "        self.val_metrics = checkpoint[\"val_metrics\"]\n",
    "        self.best_val_loss = checkpoint[\"best_val_loss\"]\n",
    "\n",
    "        print(f\"Loaded checkpoint from epoch {self.current_epoch}\")\n",
    "\n",
    "    def train(self, num_epochs: int):\n",
    "        \"\"\"\n",
    "        Train the model for specified number of epochs.\n",
    "\n",
    "        Args:\n",
    "            num_epochs: Number of epochs to train\n",
    "        \"\"\"\n",
    "        print(f\"Starting training for {num_epochs} epochs...\")\n",
    "        start_time = time.time()\n",
    "\n",
    "        for epoch in range(num_epochs):\n",
    "            self.current_epoch = epoch\n",
    "\n",
    "            # Train for one epoch\n",
    "            train_loss = self.train_epoch()\n",
    "\n",
    "            # Validate\n",
    "            val_loss, val_metrics = self.validate()\n",
    "\n",
    "            # Update learning rate scheduler\n",
    "            if self.scheduler is not None:\n",
    "                if isinstance(self.scheduler, optim.lr_scheduler.ReduceLROnPlateau):\n",
    "                    self.scheduler.step(val_loss)\n",
    "                else:\n",
    "                    self.scheduler.step()\n",
    "\n",
    "            # Log to TensorBoard\n",
    "            self.writer.add_scalar(\"train/epoch_loss\", train_loss, epoch)\n",
    "            self.writer.add_scalar(\"val/epoch_loss\", val_loss, epoch)\n",
    "            for metric_name, metric_value in val_metrics.items():\n",
    "                self.writer.add_scalar(f\"val/{metric_name}\", metric_value, epoch)\n",
    "\n",
    "            # Print epoch summary\n",
    "            print(f\"\\nEpoch {epoch + 1}/{num_epochs}:\")\n",
    "            print(f\"  Train Loss: {train_loss:.6f}\")\n",
    "            print(f\"  Val Loss: {val_loss:.6f}\")\n",
    "            print(\"  Val Metrics:\")\n",
    "            for metric_name, metric_value in val_metrics.items():\n",
    "                print(f\"    {metric_name}: {metric_value:.6f}\")\n",
    "\n",
    "            # Save checkpoint\n",
    "            is_best = val_loss < self.best_val_loss\n",
    "            if is_best:\n",
    "                self.best_val_loss = val_loss\n",
    "\n",
    "            self.save_checkpoint(is_best=is_best)\n",
    "\n",
    "            # Early stopping\n",
    "            if self.config.get(\"early_stopping_patience\", 0) > 0:\n",
    "                if (\n",
    "                    epoch - np.argmin(self.val_losses)\n",
    "                    >= self.config[\"early_stopping_patience\"]\n",
    "                ):\n",
    "                    print(f\"Early stopping at epoch {epoch + 1}\")\n",
    "                    break\n",
    "\n",
    "        # Training completed\n",
    "        training_time = time.time() - start_time\n",
    "        print(f\"\\nTraining completed in {training_time:.2f} seconds\")\n",
    "        print(f\"Best validation loss: {self.best_val_loss:.6f}\")\n",
    "\n",
    "        # Save final model\n",
    "        final_model_path = self.output_dir / \"model_final.pth\"\n",
    "        torch.save(self.model.state_dict(), final_model_path)\n",
    "        print(f\"Final model saved to {final_model_path}\")\n",
    "\n",
    "        # Close TensorBoard writer\n",
    "        self.writer.close()\n",
    "\n",
    "    def evaluate(self, test_loader: Optional[DataLoader] = None) -> Dict:\n",
    "        \"\"\"\n",
    "        Evaluate the model on test data.\n",
    "\n",
    "        Args:\n",
    "            test_loader: Test data loader (uses validation loader if None)\n",
    "\n",
    "        Returns:\n",
    "            Dictionary of evaluation metrics\n",
    "        \"\"\"\n",
    "        if test_loader is None:\n",
    "            test_loader = self.val_loader\n",
    "\n",
    "        self.model.eval()\n",
    "        all_metrics = []\n",
    "\n",
    "        print(\"Evaluating model...\")\n",
    "        with torch.no_grad():\n",
    "            for batch in tqdm(test_loader):\n",
    "                # Move data to device\n",
    "                google_img = batch[\"google_img\"].to(self.device)\n",
    "                yandex_img = batch[\"yandex_img\"].to(self.device)\n",
    "                target_homography = batch[\"homography\"].to(self.device)\n",
    "\n",
    "                # Forward pass\n",
    "                pred_homography = self.model(google_img, yandex_img, return_matrix=True)\n",
    "\n",
    "                # Compute metrics\n",
    "                metrics = self.criterion.compute_metrics(\n",
    "                    pred_homography, target_homography\n",
    "                )\n",
    "                all_metrics.append(metrics)\n",
    "\n",
    "        # Aggregate metrics\n",
    "        avg_metrics = {}\n",
    "        for key in all_metrics[0].keys():\n",
    "            avg_metrics[key] = np.mean([m[key] for m in all_metrics])\n",
    "\n",
    "        # Print evaluation results\n",
    "        print(\"\\nEvaluation Results:\")\n",
    "        for metric_name, metric_value in avg_metrics.items():\n",
    "            print(f\"  {metric_name}: {metric_value:.6f}\")\n",
    "\n",
    "        # Save evaluation results\n",
    "        eval_path = self.output_dir / \"evaluation_results.json\"\n",
    "        with open(eval_path, \"w\") as f:\n",
    "            json.dump(avg_metrics, f, indent=2)\n",
    "        print(f\"Evaluation results saved to {eval_path}\")\n",
    "\n",
    "        return avg_metrics\n",
    "\n",
    "\n",
    "from types import SimpleNamespace\n",
    "\n",
    "# Дефолтные значения параметров\n",
    "args = SimpleNamespace(\n",
    "    # Data arguments\n",
    "    data_dir=r\"C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\",\n",
    "    batch_size=32,\n",
    "    image_size=[256, 256],\n",
    "    train_split=0.8,\n",
    "    num_workers=0,\n",
    "    \n",
    "    # Model arguments\n",
    "    model_type=\"cnn\",\n",
    "    hidden_channels=64,\n",
    "    num_blocks=4,\n",
    "    dropout_rate=0.3,\n",
    "    use_batch_norm=False,\n",
    "    \n",
    "    # Training arguments\n",
    "    epochs=100,\n",
    "    lr=1e-3,\n",
    "    weight_decay=1e-4,\n",
    "    optimizer=\"adam\",\n",
    "    scheduler=\"plateau\",\n",
    "    grad_clip=1.0,\n",
    "    \n",
    "    # Loss arguments\n",
    "    matrix_weight=1.0,\n",
    "    geometric_weight=0.5,\n",
    "    reg_weight=0.1,\n",
    "    \n",
    "    # Other arguments\n",
    "    output_dir=\"runs/homography\",\n",
    "    resume=None,\n",
    "    eval_only=False,\n",
    "    seed=42\n",
    ")\n",
    "\n",
    "\n",
    "    # Set random seeds for reproducibility\n",
    "torch.manual_seed(args.seed)\n",
    "np.random.seed(args.seed)\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.manual_seed(args.seed)\n",
    "    torch.cuda.manual_seed_all(args.seed)\n",
    "\n",
    "# Set device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Create data loaders\n",
    "print(\"Creating data loaders...\")\n",
    "train_loader, val_loader = create_data_loaders(\n",
    "    root_dir=args.data_dir,\n",
    "    batch_size=args.batch_size,\n",
    "    train_split=args.train_split,\n",
    "    num_workers=args.num_workers,\n",
    "    image_size=tuple(args.image_size),\n",
    "    augment_train=False,\n",
    "    augment_val=False,\n",
    ")\n",
    "\n",
    "print(f\"Train batches: {len(train_loader)}\")\n",
    "print(f\"Val batches: {len(val_loader)}\")\n",
    "\n",
    "# Create model\n",
    "print(\"Creating model...\")\n",
    "model = create_homography_model(\n",
    "    model_type=args.model_type,\n",
    "    input_size=tuple(args.image_size),\n",
    "    input_channels=3,\n",
    "    hidden_channels=args.hidden_channels,\n",
    "    num_blocks=args.num_blocks,\n",
    "    dropout_rate=args.dropout_rate,\n",
    "    use_batch_norm=args.use_batch_norm,\n",
    ")\n",
    "\n",
    "# Create trainer configuration\n",
    "config = {\n",
    "    # Model config\n",
    "    \"model_type\": args.model_type,\n",
    "    \"hidden_channels\": args.hidden_channels,\n",
    "    \"num_blocks\": args.num_blocks,\n",
    "    \"dropout_rate\": args.dropout_rate,\n",
    "    \"use_batch_norm\": args.use_batch_norm,\n",
    "    \"image_size\": args.image_size,\n",
    "    # Training config\n",
    "    \"epochs\": args.epochs,\n",
    "    \"batch_size\": args.batch_size,\n",
    "    \"learning_rate\": args.lr,\n",
    "    \"weight_decay\": args.weight_decay,\n",
    "    \"optimizer\": args.optimizer,\n",
    "    \"scheduler\": args.scheduler,\n",
    "    \"grad_clip\": args.grad_clip,\n",
    "    # Loss config\n",
    "    \"matrix_weight\": args.matrix_weight,\n",
    "    \"geometric_weight\": args.geometric_weight,\n",
    "    \"reg_weight\": args.reg_weight,\n",
    "    \"grid_size\": 8,\n",
    "    # Data config\n",
    "    \"data_dir\": args.data_dir,\n",
    "    \"train_split\": args.train_split,\n",
    "    \"num_workers\": args.num_workers,\n",
    "    # Output config\n",
    "    \"output_dir\": args.output_dir,\n",
    "    \"seed\": args.seed,\n",
    "}\n",
    "\n",
    "# Create trainer\n",
    "trainer = HomographyTrainer(\n",
    "    model=model,\n",
    "    train_loader=train_loader,\n",
    "    val_loader=val_loader,\n",
    "    device=device,\n",
    "    config=config,\n",
    ")\n",
    "\n",
    "# Resume from checkpoint if specified\n",
    "if args.resume:\n",
    "    print(f\"Resuming from checkpoint: {args.resume}\")\n",
    "    trainer.load_checkpoint(args.resume)\n",
    "\n",
    "# Evaluate only mode\n",
    "if args.eval_only:\n",
    "    trainer.evaluate()\n",
    "else:\n",
    "    # Train the model\n",
    "    trainer.train(num_epochs=args.epochs)\n",
    "\n",
    "    # Final evaluation\n",
    "    print(\"\\nPerforming final evaluation...\")\n",
    "    trainer.evaluate()\n",
    "\n",
    "    print(\"\\nTraining completed successfully!\")\n",
    "    print(f\"Results saved to: {args.output_dir}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1cd4bb8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}