diff --git a/models/SiaN/.gitignore b/models/SiaN/.gitignore index cb1d07b..39162b9 100644 --- a/models/SiaN/.gitignore +++ b/models/SiaN/.gitignore @@ -1 +1,2 @@ -runs \ No newline at end of file +runs +*.gen.py \ No newline at end of file diff --git a/models/SiaN/_schema.md b/models/SiaN/_schema.md new file mode 100644 index 0000000..a82577a --- /dev/null +++ b/models/SiaN/_schema.md @@ -0,0 +1,23 @@ +# _schema.md + +## Format + +``` +# === IMPORTS === + + +# code: ./src/file.py +# markdown +"""Description""" + +# inline: + +``` + +## Directives + +- `# code:` - include file from src/ +- `# markdown` - description block +- `# inline:` - custom code cell + +`build.py` generates notebook from `_schema.py`. diff --git a/models/SiaN/_schema.py b/models/SiaN/_schema.py new file mode 100644 index 0000000..9dfdd29 --- /dev/null +++ b/models/SiaN/_schema.py @@ -0,0 +1,47 @@ +# _schema.py + +# === IMPORTS === +import os +import random +import logging +from typing import Tuple + +import cv2 +import numpy as np +import torch +import torch.nn as nn +import torch.optim as optim +import matplotlib.pyplot as plt +from PIL import Image +from torch.utils.data import DataLoader, Dataset, Subset +from torch.utils.tensorboard import SummaryWriter +from torchvision import transforms, models +from tqdm import tqdm + +# code: ./src/utils.py +# markdown +"""# SiaN Model""" + +# code: ./src/dataloader.py +# markdown +"""Dataset for Google/Yandex image pairs with homography augmentation.""" + +# code: ./src/model.py +# markdown +"""HomographyCNN6 predicts 6 params: rx, ry, rz, tx, ty, scale.""" + +# code: ./src/train.py +# markdown +"""HomographyTrainer manages training loop with validation.""" + +# code: ./src/analyze.py +# markdown +"""Visualization and analysis of predictions.""" + +# code: ./src/main.py +# markdown +"""Run main() to execute the full pipeline.""" + +# inline: +if __name__ == "__main__": + main() diff --git a/models/SiaN/build.py b/models/SiaN/build.py new file mode 100644 index 0000000..7e0b240 --- /dev/null +++ b/models/SiaN/build.py @@ -0,0 +1,235 @@ +import json +import os +import re + + +def parse_schema(schema_path): + with open(schema_path, 'r', encoding='utf-8') as f: + content = f.read() + + imports = [] + items = [] + + in_imports_section = False + lines = content.split('\n') + + i = 0 + while i < len(lines): + line = lines[i] + stripped = line.strip() + + if stripped == '# === IMPORTS ===': + in_imports_section = True + i += 1 + continue + elif stripped.startswith('# ==='): + in_imports_section = False + i += 1 + continue + + if in_imports_section and stripped and not stripped.startswith('#'): + imports.append(stripped) + i += 1 + continue + + if in_imports_section and stripped.startswith('#'): + in_imports_section = False + + if stripped.startswith('# code:'): + match = re.search(r'# code:\s*(.+)', stripped) + if match: + items.append(('code', match.group(1).strip())) + i += 1 + continue + + if stripped.startswith('# inline:'): + i += 1 + code_lines = [] + while i < len(lines): + stripped = lines[i].strip() + if stripped.startswith('#'): + if stripped.startswith('# code:') or stripped.startswith('# inline:') or stripped == '# markdown' or stripped.startswith('# ==='): + break + i += 1 + continue + if stripped == '': + i += 1 + continue + code_lines.append(lines[i]) + i += 1 + if code_lines: + items.append(('inline', '\n'.join(code_lines).rstrip())) + continue + + if stripped == '# markdown': + i += 1 + if i < len(lines): + next_line = lines[i].strip() + if next_line.startswith('"""'): + if next_line.endswith('"""') and len(next_line) > 3: + md_content = next_line[3:-3].strip() + i += 1 + else: + end_idx = None + for j in range(i + 1, len(lines)): + if '"""' in lines[j]: + end_idx = j + break + if end_idx: + md_content = '\n'.join(lines[i:end_idx]) + md_content = md_content.strip('"""').strip() + i = end_idx + 1 + else: + md_content = "" + i += 1 + items.append(('markdown', md_content)) + continue + + i += 1 + + return imports, items + + +def strip_all_imports(content): + lines = content.split('\n') + result_lines = [] + skip_block = False + if_block_indent = 0 + + for line in lines: + stripped = line.strip() + + if stripped.startswith('if __name__') or stripped.startswith('if __name__ =='): + skip_block = True + if_block_indent = len(line) - len(line.lstrip()) + continue + + if skip_block: + current_indent = len(line) - len(line.lstrip()) + if line.strip() == '': + continue + if current_indent < if_block_indent: + skip_block = False + elif current_indent == if_block_indent and stripped.startswith('if '): + skip_block = True + if_block_indent = current_indent + continue + else: + continue + + if stripped.startswith('import ') or stripped.startswith('from '): + continue + + result_lines.append(line) + + while result_lines and result_lines[-1].strip() == '': + result_lines.pop() + + return '\n'.join(result_lines) + + +def read_src_file(ref, base_dir): + ref_path = ref.replace('./src/', '').replace('src/', '') + full_path = os.path.join(base_dir, 'src', ref_path.replace('./src/', '').lstrip('/')) + + if not full_path.endswith('.py'): + full_path += '.py' + + with open(full_path, 'r', encoding='utf-8') as f: + return f.read() + + +def build_notebook(schema_path, output_path=None): + schema_dir = os.path.dirname(os.path.abspath(schema_path)) + if output_path is None: + output_path = os.path.join(schema_dir, 'notebook.gen.ipynb') + + imports, items = parse_schema(schema_path) + + cells = [] + + if imports: + imports_cell = { + "cell_type": "code", + "execution_count": None, + "metadata": {}, + "outputs": [], + "source": [imp + "\n" for imp in imports] + } + cells.append(imports_cell) + + for item_type, item_content in items: + if item_type == 'markdown': + md_cell = { + "cell_type": "markdown", + "metadata": {}, + "source": item_content + "\n" + } + cells.append(md_cell) + elif item_type == 'inline': + lines = item_content.split('\n') + while lines and lines[-1].strip() == '': + lines.pop() + if lines: + lines.append('') + cell = { + "cell_type": "code", + "execution_count": None, + "metadata": {}, + "outputs": [], + "source": [line + "\n" for line in lines] + } + cells.append(cell) + elif item_type == 'code': + try: + content = read_src_file(item_content, schema_dir) + content = strip_all_imports(content) + + lines = content.split('\n') + while lines and lines[-1].strip() == '': + lines.pop() + if lines: + lines.append('') + + cell = { + "cell_type": "code", + "execution_count": None, + "metadata": {}, + "outputs": [], + "source": [line + "\n" for line in lines] + } + cells.append(cell) + except FileNotFoundError: + print(f"Warning: Could not find: {item_content}") + + notebook = { + "cells": cells, + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 + } + + with open(output_path, 'w', encoding='utf-8') as f: + json.dump(notebook, f, indent=1, ensure_ascii=False) + + print(f"Notebook generated: {output_path}") + + +if __name__ == "__main__": + script_dir = os.path.dirname(os.path.abspath(__file__)) + schema_path = os.path.join(script_dir, '_schema.py') + + if os.path.exists(schema_path): + build_notebook(schema_path) + else: + print(f"Error: _schema.py not found at {schema_path}") diff --git a/models/SiaN/notebook.gen.ipynb b/models/SiaN/notebook.gen.ipynb new file mode 100644 index 0000000..b602f46 --- /dev/null +++ b/models/SiaN/notebook.gen.ipynb @@ -0,0 +1,501 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import random\n", + "import logging\n", + "from typing import Tuple\n", + "import cv2\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "from torch.utils.data import DataLoader, Dataset, Subset\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "from torchvision import transforms, models\n", + "from tqdm import tqdm\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "config = {\n", + " \"data_dir\": r\"C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\",\n", + " \"image_size\": (256, 256),\n", + " \"batch_size\": 32,\n", + " \"train_split\": 0.8,\n", + " \"num_workers\": 0,\n", + " \"epochs\": 100,\n", + " \"learning_rate\": 2e-4,\n", + " \"dropout_rate\": 0.3,\n", + " \"backbone\": \"resnet18\",\n", + " \"output_dir\": r\"C:\\Users\\admin\\Projects\\autopilot\\models\\SiaN\\runs\",\n", + "}\n", + "\n", + "\n", + "def get_camera_matrix(w, h):\n", + " return np.array([[w / 2, 0, w / 2], [0, h / 2, h / 2], [0, 0, 1]], dtype=np.float32)\n", + "\n", + "\n", + "def generate_random_homography_params(angle_range=10, translation_range=0.1, scale_range=(0.9, 1.1)):\n", + " scale = np.random.uniform(*scale_range)\n", + " tx = np.random.uniform(-translation_range, translation_range)\n", + " ty = np.random.uniform(-translation_range, translation_range)\n", + " rx = np.radians(np.random.uniform(-angle_range, angle_range))\n", + " ry = np.radians(np.random.uniform(-angle_range, angle_range))\n", + " rz = np.radians(np.random.uniform(-angle_range, angle_range))\n", + " return np.array([rx, ry, rz, tx, ty, scale])\n", + "\n", + "\n", + "def homography_params_to_matrix(params, K):\n", + " rx, ry, rz, tx, ty, scale = params\n", + " cy, sy = np.cos(rz), np.sin(rz)\n", + " cp, sp = np.cos(ry), np.sin(ry)\n", + " cr, sr = np.cos(rx), np.sin(rx)\n", + " Rz = np.array([[cy, -sy, 0], [sy, cy, 0], [0, 0, 1]], dtype=np.float32)\n", + " Ry = np.array([[cp, 0, sp], [0, 1, 0], [-sp, 0, cp]], dtype=np.float32)\n", + " Rx = np.array([[1, 0, 0], [0, cr, -sr], [0, sr, cr]], dtype=np.float32)\n", + " T = np.array([[1, 0, tx], [0, 1, ty], [0, 0, scale]], dtype=np.float32)\n", + " return K @ Rx @ Ry @ Rz @ T @ np.linalg.inv(K)\n", + "\n", + "\n", + "def matrix_to_homography_params(H, K):\n", + " K_inv = np.linalg.inv(K)\n", + " E = K_inv @ H @ K\n", + " scale = np.sqrt(np.linalg.det(E[:2, :2]))\n", + " R = E[:2, :2] / scale\n", + " tx, ty = E[0, 2], E[1, 2]\n", + " rz = np.arctan2(R[1, 0], R[0, 0])\n", + " r20, r21 = E[2, 0], E[2, 1]\n", + " ry = np.arctan2(r20, r21)\n", + " rx = np.arctan2(-E[1, 2], E[1, 1])\n", + " return np.array([rx, ry, rz, tx, ty, scale], dtype=np.float32)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "# SiaN Model\n" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "\n", + "\n", + "class YaGoDataset(Dataset):\n", + " def __init__(self, root_dir: str, transform=None, augment: bool = True, \n", + " image_size: Tuple[int, int] = (256, 256)):\n", + " self.root_dir = root_dir\n", + " self.transform = transform\n", + " self.augment = augment\n", + " self.image_size = image_size\n", + " self.K = get_camera_matrix(image_size[1], image_size[0])\n", + " self.image_pairs = self._discover_image_pairs()\n", + "\n", + " def _discover_image_pairs(self):\n", + " pairs = []\n", + " for f in os.listdir(self.root_dir):\n", + " if f.endswith(\"_google.png\"):\n", + " idx = f.split(\"_\")[0]\n", + " yandex_path = os.path.join(self.root_dir, f\"{idx}_yandex.png\")\n", + " if os.path.exists(yandex_path):\n", + " pairs.append({\"idx\": int(idx), \"google\": os.path.join(self.root_dir, f), \"yandex\": yandex_path})\n", + " return sorted(pairs, key=lambda x: x[\"idx\"])\n", + "\n", + " def __len__(self):\n", + " return len(self.image_pairs)\n", + "\n", + " def __getitem__(self, idx):\n", + " pair = self.image_pairs[idx]\n", + " google_img = Image.open(pair[\"google\"]).convert(\"RGB\").resize((self.image_size[1], self.image_size[0]), Image.BILINEAR)\n", + " yandex_img = Image.open(pair[\"yandex\"]).convert(\"RGB\").resize((self.image_size[1], self.image_size[0]), Image.BILINEAR)\n", + "\n", + " if self.augment:\n", + " params1 = generate_random_homography_params()\n", + " params2 = generate_random_homography_params()\n", + " H1 = homography_params_to_matrix(params1, self.K)\n", + " H2 = homography_params_to_matrix(params2, self.K)\n", + " H_combined = np.linalg.inv(H1) @ H2\n", + " yandex_img = Image.fromarray(cv2.warpPerspective(np.array(yandex_img), H1, self.image_size))\n", + " google_img = Image.fromarray(cv2.warpPerspective(np.array(google_img), H2, self.image_size))\n", + " target_params = matrix_to_homography_params(H_combined, self.K)\n", + " target_matrix = H_combined\n", + " else:\n", + " target_params = np.zeros(6, dtype=np.float32)\n", + " target_matrix = np.eye(3, dtype=np.float32)\n", + "\n", + " if self.transform:\n", + " google_img = self.transform(google_img)\n", + " yandex_img = self.transform(yandex_img)\n", + "\n", + " return {\n", + " \"google_img\": google_img,\n", + " \"yandex_img\": yandex_img,\n", + " \"homography_matrix\": torch.from_numpy(target_matrix).float(),\n", + " \"homography_params\": torch.from_numpy(target_params).float(),\n", + " }\n", + "\n", + "\n", + "def create_data_loaders(root_dir, batch_size=32, train_split=0.8, num_workers=0, \n", + " image_size=(256, 256), augment_train=True):\n", + " transform = transforms.Compose([transforms.ToTensor()])\n", + " \n", + " full_ds = YaGoDataset(root_dir, transform=transform, augment=False, image_size=image_size)\n", + " aug_ds = YaGoDataset(root_dir, transform=transform, augment=True, image_size=image_size)\n", + "\n", + " indices = list(range(len(full_ds)))\n", + " random.shuffle(indices)\n", + " split = int(train_split * len(indices))\n", + " \n", + " train_ds = Subset(aug_ds if augment_train else full_ds, indices[:split])\n", + " val_ds = Subset(full_ds, indices[split:])\n", + "\n", + " return (DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True),\n", + " DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True))\n", + "\n", + "\n", + "def get_dataset_info():\n", + " ds = YaGoDataset(config[\"data_dir\"], augment=True, image_size=config[\"image_size\"])\n", + " return {\n", + " \"size\": len(ds),\n", + " \"sample_keys\": list(ds[0].keys()),\n", + " \"sample_params\": ds[0][\"homography_params\"].numpy()\n", + " }\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "Dataset for Google/Yandex image pairs with homography augmentation.\n" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class HomographyCNN6(nn.Module):\n", + " def __init__(self, input_channels=3, backbone_name=\"resnet18\", pretrained=True, dropout_rate=0.3):\n", + " super().__init__()\n", + " backbone = getattr(models, backbone_name)(weights=models.ResNet18_Weights.IMAGENET1K_V1 if pretrained else None)\n", + " self.feature_dim = backbone.fc.in_features\n", + " backbone.fc = nn.Identity()\n", + " self.backbone = backbone\n", + "\n", + " self.head = nn.Sequential(\n", + " nn.Linear(self.feature_dim * 4, 512),\n", + " nn.ReLU(inplace=True),\n", + " nn.Dropout(dropout_rate),\n", + " nn.Linear(512, 256),\n", + " nn.ReLU(inplace=True),\n", + " nn.Dropout(dropout_rate),\n", + " nn.Linear(256, 6),\n", + " )\n", + "\n", + " def forward(self, img1, img2):\n", + " f1 = self.backbone(img1)\n", + " f2 = self.backbone(img2)\n", + " combined = torch.cat([f1, f2, torch.abs(f1 - f2), f1 * f2], dim=1)\n", + " return self.head(combined)\n", + "\n", + "\n", + "class HomographyLoss6(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.criterion = nn.MSELoss()\n", + "\n", + " def forward(self, pred, target):\n", + " return self.criterion(pred, target)\n", + "\n", + "\n", + "def count_parameters(model):\n", + " return sum(p.numel() for p in model.parameters())\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "HomographyCNN6 predicts 6 params: rx, ry, rz, tx, ty, scale.\n" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "\n", + "\n", + "class HomographyTrainer:\n", + " def __init__(self, model, train_loader, val_loader, device):\n", + " self.model = model.to(device)\n", + " self.train_loader = train_loader\n", + " self.val_loader = val_loader\n", + " self.device = device\n", + " self.criterion = HomographyLoss6()\n", + " self.optimizer = optim.Adam(model.parameters(), lr=config[\"learning_rate\"])\n", + " self.writer = None\n", + " self.best_val_loss = float(\"inf\")\n", + "\n", + " def train_epoch(self, epoch):\n", + " self.model.train()\n", + " total_loss, total_samples = 0, 0\n", + " pbar = tqdm(self.train_loader, desc=f\"Epoch {epoch}\")\n", + " for batch_idx, batch in enumerate(pbar):\n", + " google_img = batch[\"google_img\"].to(self.device)\n", + " yandex_img = batch[\"yandex_img\"].to(self.device)\n", + " target = batch[\"homography_params\"].to(self.device)\n", + "\n", + " self.optimizer.zero_grad()\n", + " output = self.model(google_img, yandex_img)\n", + " loss = self.criterion(output, target)\n", + " loss.backward()\n", + " self.optimizer.step()\n", + "\n", + " total_loss += loss.item() * google_img.size(0)\n", + " total_samples += google_img.size(0)\n", + " pbar.set_postfix({\"loss\": loss.item()})\n", + "\n", + " return {\"loss\": total_loss / total_samples}\n", + "\n", + " def validate(self):\n", + " self.model.eval()\n", + " total_loss, total_samples = 0, 0\n", + " with torch.no_grad():\n", + " for batch in tqdm(self.val_loader, desc=\"Validation\"):\n", + " google_img = batch[\"google_img\"].to(self.device)\n", + " yandex_img = batch[\"yandex_img\"].to(self.device)\n", + " target = batch[\"homography_params\"].to(self.device)\n", + " output = self.model(google_img, yandex_img)\n", + " loss = self.criterion(output, target)\n", + " total_loss += loss.item() * google_img.size(0)\n", + " total_samples += google_img.size(0)\n", + " return {\"loss\": total_loss / total_samples}\n", + "\n", + " def train(self, num_epochs):\n", + " log_dir = config[\"output_dir\"]\n", + " os.makedirs(log_dir, exist_ok=True)\n", + " self.writer = SummaryWriter(log_dir)\n", + "\n", + " for epoch in range(1, num_epochs + 1):\n", + " train_metrics = self.train_epoch(epoch)\n", + " val_metrics = self.validate()\n", + " print(f\"Train Loss: {train_metrics['loss']:.4f}, Val Loss: {val_metrics['loss']:.4f}\")\n", + "\n", + " if val_metrics[\"loss\"] < self.best_val_loss:\n", + " self.best_val_loss = val_metrics[\"loss\"]\n", + " self.save_checkpoint(epoch, is_best=True)\n", + " print(f\"Best model saved (val loss: {val_metrics['loss']:.4f})\")\n", + "\n", + " self.writer.close()\n", + "\n", + " def save_checkpoint(self, epoch, is_best=False):\n", + " ckpt_dir = os.path.join(config[\"output_dir\"], \"checkpoints\")\n", + " os.makedirs(ckpt_dir, exist_ok=True)\n", + " ckpt = {\"epoch\": epoch, \"model_state_dict\": self.model.state_dict(), \"val_loss\": self.best_val_loss}\n", + " torch.save(ckpt, os.path.join(ckpt_dir, f\"checkpoint_epoch_{epoch}.pt\"))\n", + " if is_best:\n", + " torch.save(ckpt, os.path.join(ckpt_dir, \"best_model.pt\"))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "HomographyTrainer manages training loop with validation.\n" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "def analyze_training(trainer):\n", + " print(\"=== Training Analysis ===\\n\")\n", + "\n", + " if trainer.writer:\n", + " print(\"TensorBoard logs available at:\", trainer.writer.log_dir)\n", + "\n", + " print(f\"\\nBest val loss: {trainer.best_val_loss:.4f}\")\n", + "\n", + " trainer.model.eval()\n", + " with torch.no_grad():\n", + " batch = next(iter(trainer.val_loader))\n", + " google_img = batch[\"google_img\"].to(trainer.device)\n", + " yandex_img = batch[\"yandex_img\"].to(trainer.device)\n", + " target_params = batch[\"homography_params\"].to(trainer.device)\n", + "\n", + " pred_params = trainer.model(google_img, yandex_img)\n", + "\n", + " print(f\"\\nSample predictions (first 3 of batch):\")\n", + " print(f\"{'Param':<8} {'Target':>12} {'Predicted':>12} {'Error':>12}\")\n", + " print(\"-\" * 46)\n", + " names = [\"rx\", \"ry\", \"rz\", \"tx\", \"ty\", \"scale\"]\n", + " for i in range(6):\n", + " t = target_params[0, i].item()\n", + " p = pred_params[0, i].item()\n", + " print(f\"{names[i]:<8} {t:>12.4f} {p:>12.4f} {abs(t-p):>12.4f}\")\n", + "\n", + " print(f\"\\nBatch mean abs error: {torch.mean(torch.abs(pred_params - target_params)).item():.4f}\")\n", + "\n", + " print(\"\\n=== Visualization ===\")\n", + " fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", + " img1 = google_img[0].cpu()\n", + " img2 = yandex_img[0].cpu()\n", + " axes[0].imshow(img1.permute(1, 2, 0))\n", + " axes[0].set_title(\"Google\")\n", + " axes[0].axis(\"off\")\n", + " axes[1].imshow(img2.permute(1, 2, 0))\n", + " axes[1].set_title(\"Yandex\")\n", + " axes[1].axis(\"off\")\n", + " axes[2].bar(names, pred_params[0].cpu().numpy())\n", + " axes[2].set_title(\"Predicted params\")\n", + " axes[2].axhline(y=0, color=\"k\", lw=0.5)\n", + " plt.tight_layout()\n", + " plt.savefig(\"prediction_sample.png\")\n", + " print(\"Saved prediction_sample.png\")\n", + " plt.show()\n", + "\n", + " return {\"best_val_loss\": trainer.best_val_loss}\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "Visualization and analysis of predictions.\n" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "\n", + "\n", + "logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(message)s\")\n", + "logger = logging.getLogger(__name__)\n", + "\n", + "\n", + "def create_dataset():\n", + " logger.info(\"Creating data loaders...\")\n", + " train_loader, val_loader = create_data_loaders(\n", + " root_dir=config[\"data_dir\"],\n", + " batch_size=config[\"batch_size\"],\n", + " train_split=config[\"train_split\"],\n", + " num_workers=config[\"num_workers\"],\n", + " image_size=config[\"image_size\"],\n", + " )\n", + " logger.info(f\"Data loaders created: train={len(train_loader.dataset)}, val={len(val_loader.dataset)}\")\n", + " return train_loader, val_loader\n", + "\n", + "\n", + "def create_model():\n", + " logger.info(\"Creating model...\")\n", + " model = HomographyCNN6(\n", + " input_channels=3,\n", + " backbone_name=config[\"backbone\"],\n", + " pretrained=True,\n", + " dropout_rate=config[\"dropout_rate\"]\n", + " )\n", + " logger.info(f\"Model created with {count_parameters(model):,} parameters\")\n", + " return model\n", + "\n", + "\n", + "def train_model(model, train_loader, val_loader):\n", + " device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + " logger.info(f\"Using device: {device}\")\n", + " \n", + " trainer = HomographyTrainer(model, train_loader, val_loader, device)\n", + " logger.info(\"Starting training...\")\n", + " trainer.train(config[\"epochs\"])\n", + " logger.info(\"Training completed\")\n", + " return trainer\n", + "\n", + "\n", + "def analyze_model(trainer):\n", + " logger.info(\"Analyzing model...\")\n", + " results = analyze_training(trainer)\n", + " logger.info(f\"Analysis complete: best_val_loss={results['best_val_loss']:.4f}\")\n", + " return results\n", + "\n", + "\n", + "def main():\n", + " logger.info(\"=\" * 50)\n", + " logger.info(\"SiaN Training Pipeline\")\n", + " logger.info(\"=\" * 50)\n", + " \n", + " dataset_info = get_dataset_info()\n", + " logger.info(f\"Dataset: {dataset_info['size']} samples, keys={dataset_info['sample_keys']}\")\n", + " \n", + " train_loader, val_loader = create_dataset()\n", + " model = create_model()\n", + " trainer = train_model(model, train_loader, val_loader)\n", + " results = analyze_model(trainer)\n", + " \n", + " logger.info(\"=\" * 50)\n", + " logger.info(\"Pipeline completed successfully\")\n", + " logger.info(\"=\" * 50)\n", + " \n", + " return trainer, results\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "Run main() to execute the full pipeline.\n" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if __name__ == \"__main__\":\n", + " main()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/models/SiaN/notebook.ipynb b/models/SiaN/notebook.ipynb deleted file mode 100644 index 434b241..0000000 --- a/models/SiaN/notebook.ipynb +++ /dev/null @@ -1,1275 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 25, - "id": "1ba72f8d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dataset size: 327\n", - "Sample keys: ['google_img', 'yandex_img', 'homography', 'same_domain', 'idx']\n", - "Google image shape: torch.Size([3, 256, 256])\n", - "Yandex image shape: torch.Size([3, 256, 256])\n", - "Homography shape: torch.Size([3, 3])\n", - "Train batches: 17\n", - "Val batches: 5\n" - ] - } - ], - "source": [ - "config = {\n", - " \"learning_rate\": 2e-4,\n", - " \"beta1\": 0.5,\n", - " \"beta2\": 0.999,\n", - " \"batch_size\": 32,\n", - " \"epochs\": 100,\n", - " \"gan_mode\": \"vanilla\",\n", - " \"lambda_L1\": 100.0,\n", - " \"grad_clip\": 1.0,\n", - " \"early_stopping_patience\": 20,\n", - " \"output_dir\": \"runs/gan_training\",\n", - " \"log_interval\": 10,\n", - " \"save_interval\": 5,\n", - " \"data_dir\": r\"C:\\Users\\admin\\Projects\\autopilot\\datasets\\ya_go_maps\\images\",\n", - " \"image_size\": [256, 256],\n", - " \"train_split\": 0.8,\n", - " \"num_workers\": 0,\n", - "}\n", - "\n", - "import os\n", - "from typing import Dict, List, Tuple\n", - "\n", - "import torch\n", - "from PIL import Image\n", - "from torch.utils.data import DataLoader, Dataset\n", - "from torchvision import transforms\n", - "\n", - "\n", - "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, Subset\n", - "from torchvision import transforms\n", - "\n", - "\n", - "class YaGoDataset(Dataset):\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", - " device=None,\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", - " self.device = device\n", - " self.image_pairs = self._discover_image_pairs()\n", - " if max_samples is not None:\n", - " self.image_pairs = self.image_pairs[:max_samples]\n", - "\n", - " def _discover_image_pairs(self) -> List[Dict[str, Any]]:\n", - " image_pairs = []\n", - " google_files = [f for f in os.listdir(self.root_dir) if f.endswith(\"_google.png\")]\n", - " for google_file in sorted(google_files):\n", - " idx_str = google_file.split(\"_\")[0]\n", - " try:\n", - " idx = int(idx_str)\n", - " except ValueError:\n", - " continue\n", - " yandex_file = f\"{idx:04d}_yandex.png\"\n", - " yandex_path = os.path.join(self.root_dir, yandex_file)\n", - " if os.path.exists(yandex_path):\n", - " image_pairs.append({\n", - " \"idx\": idx,\n", - " \"google_path\": os.path.join(self.root_dir, google_file),\n", - " \"yandex_path\": yandex_path,\n", - " })\n", - " return image_pairs\n", - "\n", - " def __len__(self) -> int:\n", - " return len(self.image_pairs)\n", - "\n", - " def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:\n", - " pair_info = self.image_pairs[idx]\n", - " google_path = pair_info[\"google_path\"]\n", - " yandex_path = pair_info[\"yandex_path\"]\n", - " same_domain = True\n", - " \n", - " if np.random.rand() > 0.5:\n", - " random_idx = np.random.randint(0, len(self))\n", - " google_path = self.image_pairs[random_idx][\"google_path\"]\n", - " same_domain = random_idx == idx\n", - "\n", - " yandex_img = Image.open(yandex_path).convert(\"RGB\")\n", - " google_img = Image.open(google_path).convert(\"RGB\")\n", - "\n", - " google_img = google_img.resize((self.image_size[1], self.image_size[0]), Image.BILINEAR)\n", - " yandex_img = yandex_img.resize((self.image_size[1], self.image_size[0]), Image.BILINEAR)\n", - " \n", - " matrices = self._get_homography_matrix(pair_info[\"idx\"])\n", - " \n", - " if self.augment:\n", - " google_img, yandex_img, homography_matrix = self._apply_augmentation(\n", - " google_img, yandex_img, matrices\n", - " )\n", - " homography_tensor = torch.from_numpy(homography_matrix).float()\n", - " else:\n", - " homography_tensor = torch.from_numpy(np.eye(3))\n", - " \n", - " if self.transform:\n", - " google_img = self.transform(google_img)\n", - " yandex_img = self.transform(yandex_img)\n", - " else:\n", - " google_img = torch.from_numpy(np.array(google_img)).float().permute(2, 0, 1) / 255.0\n", - " yandex_img = torch.from_numpy(np.array(yandex_img)).float().permute(2, 0, 1) / 255.0\n", - " \n", - "\n", - " \n", - " return {\n", - " \"google_img\": google_img,\n", - " \"yandex_img\": yandex_img,\n", - " \"homography\": homography_tensor,\n", - " \"same_domain\": same_domain,\n", - " \"idx\": torch.tensor(pair_info[\"idx\"], dtype=torch.long),\n", - " }\n", - "\n", - " def _get_homography_matrix(self, idx: int) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n", - " homography_matrix_1 = self.generate_random_homography()\n", - " homography_matrix_2 = self.generate_random_homography()\n", - " homography_matrix_r = np.linalg.inv(homography_matrix_1) @ homography_matrix_2\n", - " return (homography_matrix_1, homography_matrix_2, homography_matrix_r)\n", - "\n", - " def generate_random_homography(self) -> np.ndarray:\n", - " scale = np.random.uniform(0.8, 1.2)\n", - " tx = np.random.uniform(-0.50, 0.50)\n", - " ty = np.random.uniform(-0.50, 0.50)\n", - " \n", - " angle_x = np.random.uniform(np.radians(-10), np.radians(10))\n", - " angle_y = np.random.uniform(np.radians(-10), np.radians(10))\n", - " angle_z = np.random.uniform(np.radians(-10), np.radians(10))\n", - " \n", - " cy, sy = np.cos(angle_z), np.sin(angle_z)\n", - " cp, sp = np.cos(angle_y), np.sin(angle_y)\n", - " cr, sr = np.cos(angle_x), np.sin(angle_x)\n", - " \n", - " Rz = np.array([[cy, -sy, 0], [sy, cy, 0], [0, 0, 1]])\n", - " Ry = np.array([[cp, 0, sp], [0, 1, 0], [-sp, 0, cp]])\n", - " Rx = np.array([[1, 0, 0], [0, cr, -sr], [0, sr, cr]])\n", - " \n", - " T = np.array([[1, 0, tx], [0, 1, ty], [0, 0, scale]])\n", - " K = self.get_camera_matrix()\n", - " return K @ Rx @ Ry @ Rz @ T @ np.linalg.inv(K)\n", - "\n", - " def get_camera_matrix(self) -> np.ndarray:\n", - " w, h = config[\"image_size\"]\n", - " return np.array([[w / 2, 0, w / 2], [0, h / 2, h / 2], [0, 0, 1]])\n", - "\n", - " def _apply_augmentation(\n", - " self,\n", - " google_img: Image.Image,\n", - " yandex_img: Image.Image,\n", - " matrices: Tuple[np.ndarray, np.ndarray, np.ndarray],\n", - " ) -> Tuple[Image.Image, Image.Image, np.ndarray]:\n", - " combined_homography = matrices[2]\n", - " yandex_aug = self._apply_homography_to_image(yandex_img, matrices[0])\n", - " google_aug = self._apply_homography_to_image(yandex_img, matrices[1])\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", - " img_np = np.array(img)\n", - " h, w = img_np.shape[:2]\n", - " transformed = cv2.warpPerspective(\n", - " img_np, homography, (w, h), flags=cv2.INTER_LINEAR\n", - " )\n", - " return Image.fromarray(transformed)\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", - " device=None,\n", - ") -> Tuple[DataLoader, DataLoader]:\n", - " transform = transforms.Compose([\n", - " transforms.ToTensor(),\n", - " # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n", - " ])\n", - " \n", - " full_dataset = YaGoDataset(\n", - " root_dir=root_dir,\n", - " transform=transform,\n", - " augment=False,\n", - " image_size=image_size,\n", - " cache_homographies=True,\n", - " device=device,\n", - " )\n", - " \n", - " aug_dataset = YaGoDataset(\n", - " root_dir=root_dir,\n", - " transform=transform,\n", - " augment=True,\n", - " image_size=image_size,\n", - " cache_homographies=False,\n", - " device=device,\n", - " )\n", - " \n", - " dataset_size = len(full_dataset)\n", - " train_size = int(train_split * dataset_size)\n", - " val_size = dataset_size - train_size\n", - " \n", - " indices = list(range(dataset_size))\n", - " random.shuffle(indices)\n", - " train_indices = indices[:train_size]\n", - " val_indices = indices[train_size:]\n", - " \n", - " train_dataset = Subset(full_dataset, train_indices)\n", - " val_dataset = Subset(full_dataset, val_indices)\n", - " \n", - " if augment_train:\n", - " train_dataset = Subset(aug_dataset, train_indices)\n", - " \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", - "\n", - "# Example usage\n", - "dataset = YaGoDataset(\n", - " root_dir=config[\"data_dir\"],\n", - " augment=True,\n", - " image_size=(256, 256),\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=config[\"data_dir\"],\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": 26, - "id": "5ee4bab0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[ 8.7449e-01, 2.5444e-01, 1.8631e+01],\n", - " [-3.4327e-01, 9.2921e-01, 3.7883e+01],\n", - " [-4.8316e-04, -2.7548e-04, 9.5037e-01]])\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[[0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " ...,\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4189, 0.4174, 0.4172],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4110, 0.4116, 0.4124],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4045, 0.4087, 0.4085]],\n", - "\n", - " [[0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " ...,\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4545, 0.4538, 0.4555],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4509, 0.4509, 0.4516],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4504, 0.4499, 0.4477]],\n", - "\n", - " [[0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", - " ...,\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4310, 0.4303, 0.4320],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4262, 0.4273, 0.4281],\n", - " [0.0000, 0.0000, 0.0000, ..., 0.4222, 0.4244, 0.4241]]])\n" - ] - } - ], - "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[25]\n", - "\n", - "f(temp['google_img'])\n", - "f(temp['yandex_img'])\n", - "print(temp['homography'])\n", - "# Вывод трансформированной картинки по матрице гомографии\n", - "tr = temp['yandex_img'].permute((1, 2, 0)).numpy()\n", - "tr = cv2.warpPerspective(tr, temp['homography'].numpy(), (256, 256))\n", - "tr = torch.Tensor(tr).permute((2, 0, 1))\n", - "f(tr)\n", - "print(tr)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "2dad9a5f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using device: cpu\n", - "Model created with 12,360,777 parameters\n", - "\n", - "Testing forward pass...\n", - "Output shape: torch.Size([4, 3, 3])\n", - "\n", - "Testing prediction...\n", - "Prediction shape: torch.Size([4, 3, 3])\n", - "\n", - "Testing loss function...\n", - "Loss value: 0.421955\n", - "\n", - "All tests completed successfully!\n" - ] - } - ], - "source": [ - "from typing import Tuple\n", - "\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "from torchvision import models\n", - "\n", - "\n", - "class HomographyCNN(nn.Module):\n", - " \"\"\"\n", - " Model for estimating homography matrix (3x3) between two images.\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " input_channels: int = 3,\n", - " backbone_name: str = \"resnet18\",\n", - " pretrained: bool = True,\n", - " dropout_rate: float = 0.3,\n", - " use_batch_norm: bool = True,\n", - " ):\n", - " super().__init__()\n", - "\n", - " self.input_channels = input_channels\n", - " self.backbone_name = backbone_name\n", - " self.pretrained = pretrained\n", - " self.dropout_rate = dropout_rate\n", - " self.use_batch_norm = use_batch_norm\n", - "\n", - " backbone = self._create_backbone(backbone_name, pretrained)\n", - "\n", - " self.feature_dim = backbone.fc.in_features\n", - " backbone.fc = nn.Identity()\n", - " self.backbone = backbone\n", - "\n", - " compare_input_dim = self.feature_dim * 4\n", - "\n", - " layers = [\n", - " nn.Linear(compare_input_dim, 512),\n", - " nn.BatchNorm1d(512) if use_batch_norm else nn.Identity(),\n", - " nn.ReLU(inplace=True),\n", - " nn.Dropout(dropout_rate),\n", - "\n", - " nn.Linear(512, 256),\n", - " nn.BatchNorm1d(256) if use_batch_norm else nn.Identity(),\n", - " nn.ReLU(inplace=True),\n", - " nn.Dropout(dropout_rate),\n", - "\n", - " nn.Linear(256, 9),\n", - " ]\n", - " self.head = nn.Sequential(*layers)\n", - "\n", - " def _create_backbone(self, name: str, pretrained: bool) -> nn.Module:\n", - " name = name.lower()\n", - " if name == \"resnet18\":\n", - " model = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1 if pretrained else None)\n", - " elif name == \"resnet34\":\n", - " model = models.resnet34(weights=models.ResNet34_Weights.IMAGENET1K_V1 if pretrained else None)\n", - " else:\n", - " raise ValueError(f\"Unsupported backbone: {name}\")\n", - " if self.input_channels != 3:\n", - " old_conv = model.conv1\n", - " model.conv1 = nn.Conv2d(\n", - " self.input_channels,\n", - " old_conv.out_channels,\n", - " kernel_size=old_conv.kernel_size,\n", - " stride=old_conv.stride,\n", - " padding=old_conv.padding,\n", - " bias=old_conv.bias is not None,\n", - " )\n", - " return model\n", - "\n", - " def _extract_features(self, x: torch.Tensor) -> torch.Tensor:\n", - " return self.backbone(x)\n", - "\n", - " def forward(self, img1: torch.Tensor, img2: torch.Tensor) -> torch.Tensor:\n", - " f1 = self._extract_features(img1)\n", - " f2 = self._extract_features(img2)\n", - "\n", - " diff = torch.abs(f1 - f2)\n", - " prod = f1 * f2\n", - " combined = torch.cat([f1, f2, diff, prod], dim=1)\n", - "\n", - " h = self.head(combined)\n", - " h = h.view(-1, 3, 3)\n", - " return h\n", - "\n", - " def predict_homography(self, img1: torch.Tensor, img2: torch.Tensor) -> torch.Tensor:\n", - " was_training = self.training\n", - " self.eval()\n", - " with torch.no_grad():\n", - " h = self.forward(img1, img2)\n", - " if was_training:\n", - " self.train()\n", - " return h\n", - "\n", - "\n", - "class HomographyLoss(nn.Module):\n", - " def __init__(self):\n", - " super().__init__()\n", - " self.criterion = nn.MSELoss()\n", - "\n", - " def forward(self, pred_homography: torch.Tensor, target_homography: torch.Tensor) -> torch.Tensor:\n", - " return self.criterion(pred_homography, target_homography)\n", - "\n", - "\n", - "def create_homography_model(\n", - " model_type: str = \"backbone\",\n", - " input_size: Tuple[int, int] = (256, 256),\n", - " **kwargs,\n", - ") -> nn.Module:\n", - " if model_type == \"backbone\":\n", - " return HomographyCNN(**kwargs)\n", - " else:\n", - " raise ValueError(f\"Unknown model type: {model_type}\")\n", - "\n", - "\n", - "if __name__ == \"__main__\":\n", - " device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - " print(f\"Using device: {device}\")\n", - "\n", - " model = HomographyCNN(\n", - " input_channels=3,\n", - " backbone_name=\"resnet18\",\n", - " pretrained=True,\n", - " dropout_rate=0.3,\n", - " use_batch_norm=True,\n", - " ).to(device)\n", - "\n", - " print(f\"Model created with {sum(p.numel() for p in model.parameters()):,} parameters\")\n", - "\n", - " batch_size = 4\n", - " height, width = 256, 256\n", - "\n", - " img1 = torch.randn(batch_size, 3, height, width).to(device)\n", - " img2 = torch.randn(batch_size, 3, height, width).to(device)\n", - "\n", - " print(\"\\nTesting forward pass...\")\n", - " output = model(img1, img2)\n", - " print(f\"Output shape: {output.shape}\")\n", - "\n", - " print(\"\\nTesting prediction...\")\n", - " pred = model.predict_homography(img1, img2)\n", - " print(f\"Prediction shape: {pred.shape}\")\n", - "\n", - " print(\"\\nTesting loss function...\")\n", - " target = torch.eye(3).unsqueeze(0).expand(batch_size, -1, -1).to(device)\n", - " loss_fn = HomographyLoss().to(device)\n", - " loss = loss_fn(output, target)\n", - " print(f\"Loss value: {loss.item():.6f}\")\n", - "\n", - " print(\"\\nAll tests completed successfully!\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "e573b201", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using device: cpu\n", - "Creating data loaders...\n", - "Train batches: 9\n", - "Val batches: 3\n", - "Creating model...\n", - "Model parameters: 12,360,777\n", - "Starting training...\n", - "Starting training for 100 epochs\n", - "Logging to: runs/gan_training\n", - "\n", - "Epoch 1/100\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 1: 0%| | 0/9 [00:00 dict:\n", - " self.model.train()\n", - " total_loss = 0\n", - " total_samples = 0\n", - "\n", - " pbar = tqdm(self.train_loader, desc=f\"Epoch {epoch}\")\n", - " for batch_idx, batch in enumerate(pbar):\n", - " google_img = batch[\"google_img\"].to(self.device)\n", - " yandex_img = batch[\"yandex_img\"].to(self.device)\n", - " target = batch[\"homography\"].to(self.device)\n", - "\n", - " self.optimizer.zero_grad()\n", - "\n", - " output = self.model(google_img, yandex_img)\n", - " loss = self.criterion(output, target)\n", - "\n", - " loss.backward()\n", - " self.optimizer.step()\n", - "\n", - " total_loss += loss.item() * google_img.size(0)\n", - " total_samples += google_img.size(0)\n", - "\n", - " if batch_idx % self.config.get(\"log_interval\", 10) == 0:\n", - " pbar.set_postfix({\"loss\": loss.item()})\n", - "\n", - " if self.writer:\n", - " self.writer.add_scalar(\n", - " \"train/loss\",\n", - " loss.item(),\n", - " epoch * len(self.train_loader) + batch_idx,\n", - " )\n", - "\n", - " avg_loss = total_loss / total_samples\n", - " return {\"loss\": avg_loss}\n", - "\n", - " def validate(self) -> dict:\n", - " self.model.eval()\n", - " total_loss = 0\n", - " total_samples = 0\n", - "\n", - " with torch.no_grad():\n", - " for batch in tqdm(self.val_loader, desc=\"Validation\"):\n", - " google_img = batch[\"google_img\"].to(self.device)\n", - " yandex_img = batch[\"yandex_img\"].to(self.device)\n", - " target = batch[\"homography\"].to(self.device)\n", - "\n", - " output = self.model(google_img, yandex_img)\n", - " loss = self.criterion(output, target)\n", - "\n", - " total_loss += loss.item() * google_img.size(0)\n", - " total_samples += google_img.size(0)\n", - "\n", - " avg_loss = total_loss / total_samples\n", - " return {\"loss\": avg_loss}\n", - "\n", - " def train(self, num_epochs: int):\n", - " log_dir = self.config.get(\"output_dir\", \"runs/homography\")\n", - " os.makedirs(log_dir, exist_ok=True)\n", - " self.writer = SummaryWriter(log_dir)\n", - "\n", - " print(f\"Starting training for {num_epochs} epochs\")\n", - " print(f\"Logging to: {log_dir}\")\n", - "\n", - " for epoch in range(1, num_epochs + 1):\n", - " print(f\"\\nEpoch {epoch}/{num_epochs}\")\n", - "\n", - " train_metrics = self.train_epoch(epoch)\n", - " val_metrics = self.validate()\n", - "\n", - " print(f\"Train Loss: {train_metrics['loss']:.4f}\")\n", - " print(f\"Val Loss: {val_metrics['loss']:.4f}\")\n", - "\n", - " if self.writer:\n", - " self.writer.add_scalar(\"epoch/train_loss\", train_metrics[\"loss\"], epoch)\n", - " self.writer.add_scalar(\"epoch/val_loss\", val_metrics[\"loss\"], epoch)\n", - "\n", - " if val_metrics[\"loss\"] < self.best_val_loss:\n", - " self.best_val_loss = val_metrics[\"loss\"]\n", - " self.epochs_without_improvement = 0\n", - " self.save_checkpoint(epoch, val_metrics[\"loss\"], is_best=True)\n", - " print(f\"New best model saved with val loss: {val_metrics['loss']:.4f}\")\n", - " else:\n", - " self.epochs_without_improvement += 1\n", - " self.save_checkpoint(epoch, val_metrics[\"loss\"], is_best=False)\n", - "\n", - " patience = self.config.get(\"early_stopping_patience\", 20)\n", - " if self.epochs_without_improvement >= patience:\n", - " print(f\"Early stopping triggered after {patience} epochs without improvement\")\n", - " break\n", - "\n", - " self.writer.close()\n", - "\n", - " def save_checkpoint(self, epoch: int, val_loss: float, is_best: bool = False):\n", - " checkpoint_dir = os.path.join(\n", - " self.config.get(\"output_dir\", \"runs/homography\"), \"checkpoints\"\n", - " )\n", - " os.makedirs(checkpoint_dir, exist_ok=True)\n", - "\n", - " checkpoint = {\n", - " \"epoch\": epoch,\n", - " \"model_state_dict\": self.model.state_dict(),\n", - " \"optimizer_state_dict\": self.optimizer.state_dict(),\n", - " \"val_loss\": val_loss,\n", - " \"config\": self.config,\n", - " }\n", - "\n", - " checkpoint_path = os.path.join(checkpoint_dir, f\"checkpoint_epoch_{epoch}.pt\")\n", - " torch.save(checkpoint, checkpoint_path)\n", - "\n", - " if is_best:\n", - " best_path = os.path.join(checkpoint_dir, \"best_model.pt\")\n", - " torch.save(checkpoint, best_path)\n", - "\n", - " def load_checkpoint(self, checkpoint_path: str):\n", - " checkpoint = torch.load(checkpoint_path, map_location=self.device)\n", - " self.model.load_state_dict(checkpoint[\"model_state_dict\"])\n", - " self.optimizer.load_state_dict(checkpoint[\"optimizer_state_dict\"])\n", - " return checkpoint[\"epoch\"], checkpoint[\"val_loss\"]\n", - "\n", - "\n", - "def main():\n", - " config_dict = config.copy()\n", - "\n", - " if isinstance(config_dict.get(\"image_size\"), list):\n", - " config_dict[\"image_size\"] = tuple(config_dict[\"image_size\"])\n", - "\n", - " device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - " print(f\"Using device: {device}\")\n", - "\n", - " print(\"Creating data loaders...\")\n", - " train_loader, val_loader = create_data_loaders(\n", - " root_dir=config_dict[\"data_dir\"],\n", - " batch_size=config_dict[\"batch_size\"],\n", - " train_split=config_dict[\"train_split\"],\n", - " num_workers=config_dict[\"num_workers\"],\n", - " image_size=config_dict[\"image_size\"],\n", - " augment_train=True,\n", - " augment_val=False,\n", - " device=device,\n", - " )\n", - "\n", - " print(f\"Train batches: {len(train_loader)}\")\n", - " print(f\"Val batches: {len(val_loader)}\")\n", - "\n", - " print(\"Creating model...\")\n", - " model = create_homography_model(\n", - " model_type=\"backbone\",\n", - " input_channels=3,\n", - " backbone_name=\"resnet18\",\n", - " pretrained=True,\n", - " dropout_rate=0.3,\n", - " use_batch_norm=True,\n", - " )\n", - "\n", - " print(f\"Model parameters: {sum(p.numel() for p in model.parameters()):,}\")\n", - "\n", - " trainer = HomographyTrainer(\n", - " model=model,\n", - " train_loader=train_loader,\n", - " val_loader=val_loader,\n", - " device=device,\n", - " config=config_dict,\n", - " )\n", - "\n", - " print(\"Starting training...\")\n", - " trainer.train(config_dict[\"epochs\"])\n", - "\n", - " print(\"Training completed!\")\n", - "\n", - "\n", - "if __name__ == \"__main__\":\n", - " main()\n" - ] - } - ], - "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 -} diff --git a/models/SiaN/analyze.py b/models/SiaN/src/analyze.py similarity index 93% rename from models/SiaN/analyze.py rename to models/SiaN/src/analyze.py index 91dfbf2..1180446 100644 --- a/models/SiaN/analyze.py +++ b/models/SiaN/src/analyze.py @@ -1,7 +1,6 @@ import torch import numpy as np import matplotlib.pyplot as plt -from torchvision.utils import make_grid def analyze_training(trainer): @@ -51,8 +50,3 @@ def analyze_training(trainer): plt.show() return {"best_val_loss": trainer.best_val_loss} - - -if __name__ == "__main__": - from train import trainer - analyze_training(trainer) diff --git a/models/SiaN/dataloader.py b/models/SiaN/src/dataloader.py similarity index 92% rename from models/SiaN/dataloader.py rename to models/SiaN/src/dataloader.py index c05569f..dc8a5b7 100644 --- a/models/SiaN/dataloader.py +++ b/models/SiaN/src/dataloader.py @@ -9,7 +9,7 @@ from PIL import Image from torch.utils.data import DataLoader, Dataset, Subset from torchvision import transforms -from utils import config, get_camera_matrix, generate_random_homography_params, homography_params_to_matrix, matrix_to_homography_params +from .utils import config, get_camera_matrix, generate_random_homography_params, homography_params_to_matrix, matrix_to_homography_params class YaGoDataset(Dataset): @@ -84,9 +84,10 @@ def create_data_loaders(root_dir, batch_size=32, train_split=0.8, num_workers=0, DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True)) -if __name__ == "__main__": +def get_dataset_info(): ds = YaGoDataset(config["data_dir"], augment=True, image_size=config["image_size"]) - print(f"Dataset size: {len(ds)}") - s = ds[0] - print(f"Keys: {list(s.keys())}") - print(f"Params: {s['homography_params'].numpy()}") + return { + "size": len(ds), + "sample_keys": list(ds[0].keys()), + "sample_params": ds[0]["homography_params"].numpy() + } diff --git a/models/SiaN/src/main.py b/models/SiaN/src/main.py new file mode 100644 index 0000000..b69c08a --- /dev/null +++ b/models/SiaN/src/main.py @@ -0,0 +1,80 @@ +import logging + +import torch + +from .dataloader import create_data_loaders, get_dataset_info +from .model import HomographyCNN6, count_parameters +from .train import HomographyTrainer +from .analyze import analyze_training +from .utils import config + + +logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s") +logger = logging.getLogger(__name__) + + +def create_dataset(): + logger.info("Creating data loaders...") + train_loader, val_loader = create_data_loaders( + root_dir=config["data_dir"], + batch_size=config["batch_size"], + train_split=config["train_split"], + num_workers=config["num_workers"], + image_size=config["image_size"], + ) + logger.info(f"Data loaders created: train={len(train_loader.dataset)}, val={len(val_loader.dataset)}") + return train_loader, val_loader + + +def create_model(): + logger.info("Creating model...") + model = HomographyCNN6( + input_channels=3, + backbone_name=config["backbone"], + pretrained=True, + dropout_rate=config["dropout_rate"] + ) + logger.info(f"Model created with {count_parameters(model):,} parameters") + return model + + +def train_model(model, train_loader, val_loader): + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + logger.info(f"Using device: {device}") + + trainer = HomographyTrainer(model, train_loader, val_loader, device) + logger.info("Starting training...") + trainer.train(config["epochs"]) + logger.info("Training completed") + return trainer + + +def analyze_model(trainer): + logger.info("Analyzing model...") + results = analyze_training(trainer) + logger.info(f"Analysis complete: best_val_loss={results['best_val_loss']:.4f}") + return results + + +def main(): + logger.info("=" * 50) + logger.info("SiaN Training Pipeline") + logger.info("=" * 50) + + dataset_info = get_dataset_info() + logger.info(f"Dataset: {dataset_info['size']} samples, keys={dataset_info['sample_keys']}") + + train_loader, val_loader = create_dataset() + model = create_model() + trainer = train_model(model, train_loader, val_loader) + results = analyze_model(trainer) + + logger.info("=" * 50) + logger.info("Pipeline completed successfully") + logger.info("=" * 50) + + return trainer, results + + +if __name__ == "__main__": + main() diff --git a/models/SiaN/model.py b/models/SiaN/src/model.py similarity index 84% rename from models/SiaN/model.py rename to models/SiaN/src/model.py index 6ef8ed6..b2ee78a 100644 --- a/models/SiaN/model.py +++ b/models/SiaN/src/model.py @@ -37,9 +37,5 @@ class HomographyLoss6(nn.Module): return self.criterion(pred, target) -if __name__ == "__main__": - model = HomographyCNN6() - img1 = torch.randn(2, 3, 256, 256) - img2 = torch.randn(2, 3, 256, 256) - out = model(img1, img2) - print(f"Output shape: {out.shape}, mean: {out.mean():.3f}") +def count_parameters(model): + return sum(p.numel() for p in model.parameters()) diff --git a/models/SiaN/train.py b/models/SiaN/src/train.py similarity index 80% rename from models/SiaN/train.py rename to models/SiaN/src/train.py index 694d69e..092fed0 100644 --- a/models/SiaN/train.py +++ b/models/SiaN/src/train.py @@ -3,12 +3,13 @@ import os import torch import torch.nn as nn import torch.optim as optim -from dataloader import create_data_loaders -from model import HomographyCNN6, HomographyLoss6 -from utils import config from torch.utils.tensorboard import SummaryWriter from tqdm import tqdm +from .dataloader import create_data_loaders +from .model import HomographyCNN6, HomographyLoss6, count_parameters +from .utils import config + class HomographyTrainer: def __init__(self, model, train_loader, val_loader, device): @@ -80,26 +81,3 @@ class HomographyTrainer: torch.save(ckpt, os.path.join(ckpt_dir, f"checkpoint_epoch_{epoch}.pt")) if is_best: torch.save(ckpt, os.path.join(ckpt_dir, "best_model.pt")) - - -device = torch.device("cuda" if torch.cuda.is_available() else "cpu") -print(f"Using device: {device}") - -train_loader, val_loader = create_data_loaders( - root_dir=config["data_dir"], - batch_size=config["batch_size"], - train_split=config["train_split"], - num_workers=config["num_workers"], - image_size=config["image_size"], -) - -model = HomographyCNN6( - input_channels=3, - backbone_name=config["backbone"], - pretrained=True, - dropout_rate=config["dropout_rate"] -) -print(f"Model parameters: {sum(p.numel() for p in model.parameters()):,}") - -trainer = HomographyTrainer(model, train_loader, val_loader, device) -trainer.train(config["epochs"]) diff --git a/models/SiaN/utils.py b/models/SiaN/src/utils.py similarity index 100% rename from models/SiaN/utils.py rename to models/SiaN/src/utils.py