Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+demo-frontend/node_modules/@esbuild/win32-x64/esbuild.exe filter=lfs diff=lfs merge=lfs -text
+demo-frontend/node_modules/@rollup/rollup-win32-x64-gnu/rollup.win32-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
+demo-frontend/node_modules/@rollup/rollup-win32-x64-msvc/rollup.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text
+FInal[[:space:]]Project[[:space:]]Intro.pdf filter=lfs diff=lfs merge=lfs -text
+tmp-demo-frontend/node_modules/@esbuild/win32-x64/esbuild.exe filter=lfs diff=lfs merge=lfs -text
+tmp-demo-frontend/node_modules/@rollup/rollup-win32-x64-gnu/rollup.win32-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
+tmp-demo-frontend/node_modules/@rollup/rollup-win32-x64-msvc/rollup.win32-x64-msvc.node filter=lfs diff=lfs merge=lfs -text

.github/copilot-instructions.md

@@ -0,0 +1,106 @@
+<!-- Use this file to provide workspace-specific custom instructions to Copilot. For more details, visit https://code.visualstudio.com/docs/copilot/copilot-customization#_use-a-githubcopilotinstructionsmd-file -->
+- [x] Verify that the copilot-instructions.md file in the .github directory is created. (Created file with checklist template.)
+
+- [x] Clarify Project Requirements (Frontend demo: Vite React TS with Tailwind, faux AI output, map view, no backend.)
+	<!-- Ask for project type, language, and frameworks if not specified. Skip if already provided. -->
+
+- [ ] Scaffold the Project
+	<!--
+	Ensure that the previous step has been marked as completed.
+	Call project setup tool with projectType parameter.
+	Run scaffolding command to create project files and folders.
+	Use '.' as the working directory.
+	If no appropriate projectType is available, search documentation using available tools.
+	Otherwise, create the project structure manually using available file creation tools.
+	-->
+
+- [ ] Customize the Project
+	<!--
+	Verify that all previous steps have been completed successfully and you have marked the step as completed.
+	Develop a plan to modify codebase according to user requirements.
+	Apply modifications using appropriate tools and user-provided references.
+	Skip this step for "Hello World" projects.
+	-->
+
+- [ ] Install Required Extensions
+	<!-- ONLY install extensions provided mentioned in the get_project_setup_info. Skip this step otherwise and mark as completed. -->
+
+- [ ] Compile the Project
+	<!--
+	Verify that all previous steps have been completed.
+	Install any missing dependencies.
+	Run diagnostics and resolve any issues.
+	Check for markdown files in project folder for relevant instructions on how to do this.
+	-->
+
+- [ ] Create and Run Task
+	<!--
+	Verify that all previous steps have been completed.
+	Check https://code.visualstudio.com/docs/debugtest/tasks to determine if the project needs a task. If so, use the create_and_run_task to create and launch a task based on package.json, README.md, and project structure.
+	Skip this step otherwise.
+	 -->
+
+- [ ] Launch the Project
+	<!--
+	Verify that all previous steps have been completed.
+	Prompt user for debug mode, launch only if confirmed.
+	 -->
+
+- [ ] Ensure Documentation is Complete
+	<!--
+	Verify that all previous steps have been completed.
+	Verify that README.md and the copilot-instructions.md file in the .github directory exists and contains current project information.
+	Clean up the copilot-instructions.md file in the .github directory by removing all HTML comments.
+	 -->
+
+<!--
+## Execution Guidelines
+PROGRESS TRACKING:
+- If any tools are available to manage the above todo list, use it to track progress through this checklist.
+- After completing each step, mark it complete and add a summary.
+- Read current todo list status before starting each new step.
+
+COMMUNICATION RULES:
+- Avoid verbose explanations or printing full command outputs.
+- If a step is skipped, state that briefly (e.g. "No extensions needed").
+- Do not explain project structure unless asked.
+- Keep explanations concise and focused.
+
+DEVELOPMENT RULES:
+- Use '.' as the working directory unless user specifies otherwise.
+- Avoid adding media or external links unless explicitly requested.
+- Use placeholders only with a note that they should be replaced.
+- Use VS Code API tool only for VS Code extension projects.
+- Once the project is created, it is already opened in Visual Studio Code—do not suggest commands to open this project in Visual Studio again.
+- If the project setup information has additional rules, follow them strictly.
+
+FOLDER CREATION RULES:
+- Always use the current directory as the project root.
+- If you are running any terminal commands, use the '.' argument to ensure that the current working directory is used ALWAYS.
+- Do not create a new folder unless the user explicitly requests it besides a .vscode folder for a tasks.json file.
+- If any of the scaffolding commands mention that the folder name is not correct, let the user know to create a new folder with the correct name and then reopen it again in vscode.
+
+EXTENSION INSTALLATION RULES:
+- Only install extension specified by the get_project_setup_info tool. DO NOT INSTALL any other extensions.
+
+PROJECT CONTENT RULES:
+- If the user has not specified project details, assume they want a "Hello World" project as a starting point.
+- Avoid adding links of any type (URLs, files, folders, etc.) or integrations that are not explicitly required.
+- Avoid generating images, videos, or any other media files unless explicitly requested.
+- If you need to use any media assets as placeholders, let the user know that these are placeholders and should be replaced with the actual assets later.
+- Ensure all generated components serve a clear purpose within the user's requested workflow.
+- If a feature is assumed but not confirmed, prompt the user for clarification before including it.
+- If you are working on a VS Code extension, use the VS Code API tool with a query to find relevant VS Code API references and samples related to that query.
+
+TASK COMPLETION RULES:
+- Your task is complete when:
+  - Project is successfully scaffolded and compiled without errors
+  - copilot-instructions.md file in the .github directory exists in the project
+  - README.md file exists and is up to date
+  - User is provided with clear instructions to debug/launch the project
+
+Before starting a new task in the above plan, update progress in the plan.
+-->
+- Work through each checklist item systematically.
+- Keep communication concise and focused.
+- Follow development best practices.

.gitignore

@@ -0,0 +1,39 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+
+# C extensions
+*.so
+
+# Distribution / packaging
+*.egg-info/
+*.egg
+dist/
+build/
+
+# Virtual environments
+venv/
+env/
+.venv/
+.env
+
+# Jupyter
+.ipynb_checkpoints
+
+# VS Code
+.vscode/
+
+# Data (large files)
+data/raw_images/
+data/*.tar
+data/*.zip
+data/*.npz
+data/*.h5
+data/*.db
+
+# Logs and OS files
+*.log
+.DS_Store
+Thumbs.db

FInal Project Intro.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6742d8b4e83b38cbbb564269fb1b3de312082c1c3b83114d821087f72016153d
+size 594116

Release_baseline_model_team1.ipynb

@@ -0,0 +1,583 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Y0bKqI_UZNso"
+      },
+      "source": [
+        "# Installing dependencies\n",
+        "\n",
+        "Please make a copy of this notebook.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VBj9R3VCAYkv"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install geopy > delete.txt\n",
+        "!pip install datasets > delete.txt\n",
+        "!pip install torch torchvision datasets > delete.txt\n",
+        "!pip install huggingface_hub > delete.txt\n",
+        "!rm delete.txt"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_d8uxEsCZTBc"
+      },
+      "source": [
+        "# Huggingface login\n",
+        "You will require your personal token."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "N5vOXHY5Ifv2"
+      },
+      "outputs": [],
+      "source": [
+        "!huggingface-cli login"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sv_nG_P8W7Bn"
+      },
+      "source": [
+        "# Data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0GokzmxKZupF"
+      },
+      "source": [
+        "## Downloading the train and test dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import pandas as pd\n",
+        "from PIL import Image\n",
+        "from tqdm.auto import tqdm\n",
+        "from datasets import load_dataset\n",
+        "\n",
+        "LAT_MIN, LAT_MAX = 39.9500, 39.9530\n",
+        "LON_MIN, LON_MAX = -75.1930, -75.1900\n",
+        "TARGET_SIZE = (224, 224)\n",
+        "OUTPUT_DIR = \"/content/small_data\"\n",
+        "\n",
+        "def process_dataset():\n",
+        "    print(\"Starting data processing...\")\n",
+        "    try:\n",
+        "        ds_train = load_dataset(\"LarryD123/Image2GPS_combined\", split=\"train\", streaming=True)\n",
+        "    except Exception as e:\n",
+        "        print(f\"Error loading dataset: {e}\")\n",
+        "        return\n",
+        "\n",
+        "    os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+        "    metadata = []\n",
+        "    count_kept = 0\n",
+        "    count_rejected = 0\n",
+        "\n",
+        "    for i, item in enumerate(tqdm(ds_train)):\n",
+        "        lat = item.get('Latitude') or item.get('latitude')\n",
+        "        lon = item.get('Longitude') or item.get('longitude')\n",
+        "\n",
+        "        if lat and lon and LAT_MIN <= lat <= LAT_MAX and LON_MIN <= lon <= LON_MAX:\n",
+        "            try:\n",
+        "                img = item['image'].convert('RGB').resize(TARGET_SIZE, Image.LANCZOS)\n",
+        "                file_name = f\"small_{i:05d}.jpg\"\n",
+        "                img.save(os.path.join(OUTPUT_DIR, file_name), quality=95)\n",
+        "\n",
+        "                metadata.append({\n",
+        "                    \"file_name\": file_name,\n",
+        "                    \"Latitude\": lat,\n",
+        "                    \"Longitude\": lon\n",
+        "                })\n",
+        "                count_kept += 1\n",
+        "            except Exception:\n",
+        "                continue\n",
+        "        else:\n",
+        "            count_rejected += 1\n",
+        "\n",
+        "        if count_kept >= 5000:\n",
+        "            break\n",
+        "\n",
+        "    df = pd.DataFrame(metadata)\n",
+        "    df.to_csv(os.path.join(OUTPUT_DIR, \"metadata.csv\"), index=False)\n",
+        "\n",
+        "    print(\"-\" * 30)\n",
+        "    print(f\"Processing complete.\")\n",
+        "    print(f\"Saved images: {count_kept}\")\n",
+        "    print(f\"Rejected images: {count_rejected}\")\n",
+        "    print(f\"Metadata saved to {OUTPUT_DIR}/metadata.csv\")\n",
+        "    print(\"-\" * 30)\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    process_dataset()"
+      ],
+      "metadata": {
+        "id": "jgPn6XrpLs_U"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Ua-UFAGyaFvL"
+      },
+      "source": [
+        "## Creating dataloaders and visualizing the data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import numpy as np\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "from torchvision import transforms\n",
+        "from datasets import load_dataset\n",
+        "\n",
+        "LAT_MIN, LAT_MAX = 39.9495, 39.9550\n",
+        "LON_MIN, LON_MAX = -75.1940, -75.1905\n",
+        "TARGET_SIZE = (224, 224)\n",
+        "BATCH_SIZE = 32\n",
+        "NUM_WORKERS = 2\n",
+        "\n",
+        "class GPSDataset(Dataset):\n",
+        "    def __init__(self, hf_dataset, transform=None):\n",
+        "        self.hf_dataset = hf_dataset\n",
+        "        self.transform = transform\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.hf_dataset)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        item = self.hf_dataset[idx]\n",
+        "        image = item['image'].convert('RGB')\n",
+        "        if self.transform:\n",
+        "            image = self.transform(image)\n",
+        "        return image, torch.tensor([item['Latitude'], item['Longitude']], dtype=torch.float32)\n",
+        "\n",
+        "def standardize_columns(dataset):\n",
+        "    if 'latitude' in dataset.column_names:\n",
+        "        dataset = dataset.rename_column(\"latitude\", \"Latitude\")\n",
+        "    if 'longitude' in dataset.column_names:\n",
+        "        dataset = dataset.rename_column(\"longitude\", \"Longitude\")\n",
+        "    return dataset\n",
+        "\n",
+        "def get_dataloaders():\n",
+        "    try:\n",
+        "        ds_train = load_dataset(\"LarryD123/Image2GPS\", split=\"train\")\n",
+        "        ds_val = load_dataset(\"gydou/released_img\", split=\"train\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"Error loading datasets: {e}\")\n",
+        "        return None, None\n",
+        "\n",
+        "    ds_train = standardize_columns(ds_train)\n",
+        "    ds_val = standardize_columns(ds_val)\n",
+        "\n",
+        "    ds_train = ds_train.filter(lambda x: LAT_MIN <= x['Latitude'] <= LAT_MAX and\n",
+        "                                         LON_MIN <= x['Longitude'] <= LON_MAX)\n",
+        "\n",
+        "    lats = np.array(ds_train['Latitude'])\n",
+        "    lons = np.array(ds_train['Longitude'])\n",
+        "\n",
+        "    print(f\"Lat Mean: {np.mean(lats):.6f}, Std: {np.std(lats):.6f}\")\n",
+        "    print(f\"Lon Mean: {np.mean(lons):.6f}, Std: {np.std(lons):.6f}\")\n",
+        "\n",
+        "    train_transform = transforms.Compose([\n",
+        "        transforms.Resize(TARGET_SIZE),\n",
+        "        transforms.RandomHorizontalFlip(),\n",
+        "        transforms.RandomRotation(degrees=15),\n",
+        "        transforms.ColorJitter(brightness=0.2, contrast=0.2),\n",
+        "        transforms.ToTensor(),\n",
+        "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
+        "    ])\n",
+        "\n",
+        "    val_transform = transforms.Compose([\n",
+        "        transforms.Resize(TARGET_SIZE),\n",
+        "        transforms.ToTensor(),\n",
+        "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
+        "    ])\n",
+        "\n",
+        "    train_dataset = GPSDataset(ds_train, transform=train_transform)\n",
+        "    val_dataset = GPSDataset(ds_val, transform=val_transform)\n",
+        "\n",
+        "    train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)\n",
+        "    val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=NUM_WORKERS)\n",
+        "\n",
+        "    return train_loader, val_loader\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    train_loader, val_loader = get_dataloaders()"
+      ],
+      "metadata": {
+        "id": "I47GPJ-3QDUM"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "i028XRKnh6-v"
+      },
+      "outputs": [],
+      "source": [
+        "# Verify loading\n",
+        "for images, gps_coords in train_dataloader:\n",
+        "    print(images.size(), gps_coords.size())\n",
+        "    break"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "DkaQtacFiWK8"
+      },
+      "outputs": [],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import torchvision.transforms as transforms\n",
+        "import numpy as np\n",
+        "\n",
+        "def denormalize(tensor, mean, std):\n",
+        "    mean = np.array(mean)\n",
+        "    std = np.array(std)\n",
+        "    tensor = tensor.numpy().transpose((1, 2, 0))  # Convert from C x H x W to H x W x C\n",
+        "    tensor = std * tensor + mean  # Denormalize\n",
+        "    tensor = np.clip(tensor, 0, 1)  # Clip to keep pixel values between 0 and 1\n",
+        "    return tensor\n",
+        "\n",
+        "data_iter = iter(train_dataloader)\n",
+        "images, gps_coords = next(data_iter)  # Get a batch of images and labels\n",
+        "# Denormalize the first image in the batch for display\n",
+        "itr = 0\n",
+        "for im in images:\n",
+        "  image = denormalize(im, mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
+        "\n",
+        "  # Plot the image\n",
+        "  plt.imshow(image)\n",
+        "  plt.title(f'Latitude: {gps_coords[itr][0].item():.4f}, Longitude: {gps_coords[itr][1].item():.4f}')\n",
+        "  plt.axis('off')\n",
+        "  plt.show()\n",
+        "  itr += 1"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Fi0I3kbV0iTp"
+      },
+      "source": [
+        "# Swintransformer"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "lh5AiZc4gKXl"
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "from torch.optim.lr_scheduler import StepLR\n",
+        "import torchvision.models as models\n",
+        "import numpy as np\n",
+        "from geopy.distance import geodesic\n",
+        "from tqdm.auto import tqdm\n",
+        "from torch.cuda.amp import GradScaler, autocast\n",
+        "\n",
+        "print(\"Initializing Swin Transformer Base (Torchvision)...\")\n",
+        "\n",
+        "model = models.swin_b(weights='DEFAULT')\n",
+        "model.head = nn.Linear(1024, 2)\n",
+        "\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "model = model.to(device)\n",
+        "\n",
+        "criterion = nn.MSELoss()\n",
+        "optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=0.05)\n",
+        "scheduler = StepLR(optimizer, step_size=7, gamma=0.5)\n",
+        "scaler = GradScaler(enabled=True)\n",
+        "\n",
+        "best_val_dist = float('inf')\n",
+        "best_epoch = -1\n",
+        "save_path = \"model.pt\"\n",
+        "num_epochs = 50\n",
+        "\n",
+        "print(f\"Starting training for {num_epochs} epochs...\")\n",
+        "\n",
+        "for epoch in range(1, num_epochs + 1):\n",
+        "    model.train()\n",
+        "    running_loss = 0.0\n",
+        "\n",
+        "    train_bar = tqdm(train_dataloader, desc=f\"Epoch {epoch}/{num_epochs} [Train]\", leave=False)\n",
+        "\n",
+        "    for images, coords in train_bar:\n",
+        "        images = images.to(device)\n",
+        "        coords = coords.to(device)\n",
+        "\n",
+        "        target_lat = (coords[:, 0] - lat_mean) / lat_std\n",
+        "        target_lon = (coords[:, 1] - lon_mean) / lon_std\n",
+        "        targets = torch.stack([target_lat, target_lon], dim=1)\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "\n",
+        "        with autocast(enabled=True):\n",
+        "            outputs = model(images)\n",
+        "            loss = criterion(outputs, targets)\n",
+        "\n",
+        "        scaler.scale(loss).backward()\n",
+        "        scaler.step(optimizer)\n",
+        "        scaler.update()\n",
+        "\n",
+        "        running_loss += loss.item() * images.size(0)\n",
+        "        train_bar.set_postfix({'loss': f\"{loss.item():.4f}\"})\n",
+        "\n",
+        "    scheduler.step()\n",
+        "    epoch_loss = running_loss / len(train_dataloader.dataset)\n",
+        "\n",
+        "    model.eval()\n",
+        "    distances = []\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        val_bar = tqdm(val_dataloader, desc=f\"Epoch {epoch}/{num_epochs} [Val]\", leave=False)\n",
+        "\n",
+        "        for images, coords in val_bar:\n",
+        "            images = images.to(device)\n",
+        "            coords = coords.to(device)\n",
+        "\n",
+        "            with autocast(enabled=True):\n",
+        "                outputs = model(images)\n",
+        "\n",
+        "            preds = outputs.cpu().numpy() * np.array([lat_std, lon_std]) + np.array([lat_mean, lon_mean])\n",
+        "            actuals = coords.cpu().numpy()\n",
+        "\n",
+        "            for p, a in zip(preds, actuals):\n",
+        "                try:\n",
+        "                    dist = geodesic((a[0], a[1]), (p[0], p[1])).meters\n",
+        "                    distances.append(dist)\n",
+        "                except ValueError:\n",
+        "                    continue\n",
+        "\n",
+        "    avg_dist = np.mean(distances)\n",
+        "    print(f\"Epoch [{epoch}/{num_epochs}] | Train Loss: {epoch_loss:.6f} | Val Avg Distance: {avg_dist:.2f}m\")\n",
+        "\n",
+        "    if avg_dist < best_val_dist:\n",
+        "        best_val_dist = avg_dist\n",
+        "        best_epoch = epoch\n",
+        "        torch.save(model.state_dict(), save_path)\n",
+        "        print(f\"New best model saved. Distance: {best_val_dist:.2f}m\")\n",
+        "\n",
+        "print(\"Training complete.\")\n",
+        "print(f\"Best model saved to {save_path} (Epoch {best_epoch}) with Distance: {best_val_dist:.2f}m\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CdLEWIKhaX_o"
+      },
+      "source": [
+        "# Testing the model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "RXlnLpHvjdpd"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import mean_absolute_error, mean_squared_error\n",
+        "import numpy as np\n",
+        "from geopy.distance import geodesic\n",
+        "import torch\n",
+        "\n",
+        "# Ensure model is in evaluation mode\n",
+        "model.eval()\n",
+        "\n",
+        "all_preds = []\n",
+        "all_actuals = []\n",
+        "distances = []\n",
+        "\n",
+        "print(\"Starting model evaluation on validation set...\")\n",
+        "\n",
+        "with torch.no_grad():\n",
+        "    for images, gps_coords in val_dataloader:\n",
+        "        images = images.to(device)\n",
+        "        gps_coords = gps_coords.to(device)\n",
+        "\n",
+        "        # Forward pass\n",
+        "        outputs = model(images)\n",
+        "\n",
+        "        # Denormalize predictions\n",
+        "        # Using previously calculated statistics: lat_std, lon_std, lat_mean, lon_mean\n",
+        "        normalization_std = np.array([lat_std, lon_std])\n",
+        "        normalization_mean = np.array([lat_mean, lon_mean])\n",
+        "\n",
+        "        preds = outputs.cpu().numpy() * normalization_std + normalization_mean\n",
+        "        actuals = gps_coords.cpu().numpy()\n",
+        "\n",
+        "        all_preds.append(preds)\n",
+        "        all_actuals.append(actuals)\n",
+        "\n",
+        "        # Calculate Geodesic distance (in meters) for each sample\n",
+        "        for pred, actual in zip(preds, actuals):\n",
+        "            try:\n",
+        "                # geodesic() takes coordinates in (latitude, longitude) order\n",
+        "                dist = geodesic((actual[0], actual[1]), (pred[0], pred[1])).meters\n",
+        "                distances.append(dist)\n",
+        "            except ValueError:\n",
+        "                continue\n",
+        "\n",
+        "# Concatenate all batches\n",
+        "all_preds = np.concatenate(all_preds)\n",
+        "all_actuals = np.concatenate(all_actuals)\n",
+        "\n",
+        "# Calculate final metrics\n",
+        "mae = mean_absolute_error(all_actuals, all_preds)\n",
+        "rmse = np.sqrt(mean_squared_error(all_actuals, all_preds))\n",
+        "avg_distance = np.mean(distances)\n",
+        "\n",
+        "print(\"-\" * 30)\n",
+        "print(f\"Evaluation Results:\")\n",
+        "print(f\"Mean Absolute Error (Degrees): {mae:.6f}\")\n",
+        "print(f\"Root Mean Squared Error (Degrees): {rmse:.6f}\")\n",
+        "print(\"-\" * 30)\n",
+        "print(f\"Average Distance Error: {avg_distance:.2f} meters\")\n",
+        "print(\"-\" * 30)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "12BMgT0CXVu7"
+      },
+      "outputs": [],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "\n",
+        "plt.scatter(all_actuals[:, 1], all_actuals[:, 0],\n",
+        "            label='Actual Ground Truth', color='blue', alpha=0.6, s=20)\n",
+        "\n",
+        "plt.scatter(all_preds[:, 1], all_preds[:, 0],\n",
+        "            label='Model Prediction', color='red', alpha=0.6, s=20)\n",
+        "\n",
+        "print(\"Drawing error lines...\")\n",
+        "for i in range(len(all_actuals)):\n",
+        "    plt.plot(\n",
+        "        [all_actuals[i, 1], all_preds[i, 1]],\n",
+        "        [all_actuals[i, 0], all_preds[i, 0]],\n",
+        "        color='gray', linewidth=0.5, alpha=0.5\n",
+        "    )\n",
+        "\n",
+        "plt.legend()\n",
+        "plt.xlabel('Longitude')\n",
+        "plt.ylabel('Latitude')\n",
+        "plt.title('Actual vs. Predicted GPS Coordinates (Validation Set)')\n",
+        "plt.grid(True, linestyle='--', alpha=0.3)\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "V-nfMsIf0MHd"
+      },
+      "source": [
+        "# 2. Pushing the model to the Hugging Face (Torchvision Model)\n",
+        "\n",
+        "Use this code if you loaded the model from Torchvision or built the model from scratch using PyTorch. If you built your model from scratch, make sure to follow the guidelines described here - https://huggingface.co/docs/hub/en/models-uploading#upload-a-pytorch-model-using-huggingfacehub\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "from huggingface_hub import HfApi\n",
+        "\n",
+        "HF_USERNAME = \"HyadesL\"\n",
+        "REPO_NAME = \"swin-transformer-gps-penn\"\n",
+        "MODEL_FILENAME = \"model.pt\"\n",
+        "\n",
+        "def upload_to_huggingface():\n",
+        "    if not os.path.exists(MODEL_FILENAME):\n",
+        "        print(f\"Error: {MODEL_FILENAME} not found in the current directory.\")\n",
+        "        return\n",
+        "\n",
+        "    repo_id = f\"{HF_USERNAME}/{REPO_NAME}\"\n",
+        "    api = HfApi()\n",
+        "\n",
+        "    try:\n",
+        "        print(f\"Initializing repository: {repo_id}\")\n",
+        "        api.create_repo(repo_id=repo_id, exist_ok=True)\n",
+        "\n",
+        "        print(f\"Uploading {MODEL_FILENAME}...\")\n",
+        "        api.upload_file(\n",
+        "            path_or_fileobj=MODEL_FILENAME,\n",
+        "            path_in_repo=MODEL_FILENAME,\n",
+        "            repo_id=repo_id,\n",
+        "            repo_type=\"model\",\n",
+        "            commit_message=\"Upload torchvision Swin Transformer weights\"\n",
+        "        )\n",
+        "\n",
+        "        print(f\"Upload successful: https://huggingface.co/{repo_id}/blob/main/{MODEL_FILENAME}\")\n",
+        "\n",
+        "    except Exception as e:\n",
+        "        print(f\"Upload failed: {e}\")\n",
+        "        print(\"Ensure you are logged in via 'huggingface-cli login' with a write token.\")\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "    upload_to_huggingface()"
+      ],
+      "metadata": {
+        "id": "RcYKYGdToQE6"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

Release_post_process.ipynb

@@ -0,0 +1,245 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "5638b0d1",
+      "metadata": {
+        "id": "5638b0d1"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install exifread"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Extracting GPS Information from Images\n",
+        "\n",
+        "(You will need to modify this script based on how your dataset is stored in order to execute the code.).\n"
+      ],
+      "metadata": {
+        "id": "yT4UQMosNN02"
+      },
+      "id": "yT4UQMosNN02"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "\n",
+        "# train_or_test_or_validation could be either train, test, or validation.\n",
+        "train_or_test_or_validation = \"train\" # it could also be test or validation\n",
+        "PATH_TO_YOUR_DATA_FOLDER = \"{PATH TO YOUR DATA FOLDER}\"\n",
+        "directory_path = f\"{PATH_TO_YOUR_DATA_FOLDER}/{train_or_test_or_validation}\"\n",
+        "output_csv = \"metadata.csv\"\n",
+        "output_csv = os.path.join(directory_path, output_csv)"
+      ],
+      "metadata": {
+        "id": "7QcjgXtAQB5Q"
+      },
+      "id": "7QcjgXtAQB5Q",
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e1713e4e-a848-42e9-b8d8-d1273f1b9689",
+      "metadata": {
+        "id": "e1713e4e-a848-42e9-b8d8-d1273f1b9689"
+      },
+      "outputs": [],
+      "source": [
+        "import exifread, csv\n",
+        "\n",
+        "def get_exif_data(image_path):\n",
+        "    with open(image_path, 'rb') as image_file:\n",
+        "        tags = exifread.process_file(image_file)\n",
+        "    return tags\n",
+        "\n",
+        "def export_exif_to_json(exif_data, output_file):\n",
+        "    # Convert tags to a serializable format\n",
+        "    exif_data_serializable = {str(tag): str(value) for tag, value in exif_data.items()}\n",
+        "    with open(output_file, 'w') as json_file:\n",
+        "        json.dump(exif_data_serializable, json_file, indent=4)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "80fb378d",
+      "metadata": {
+        "id": "80fb378d"
+      },
+      "outputs": [],
+      "source": [
+        "# Function to convert GPS coordinates in degrees, minutes, and seconds to decimal degrees\n",
+        "def convert_to_decimal_degrees(value):\n",
+        "    d, m, s = value.values\n",
+        "    return d.num / d.den + (m.num / m.den) / 60 + (s.num / s.den) / 3600"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "### You will need to create subfolders in {PATH_TO_YOUR_DATA_FOLDER} for each split (train/test/validation) or just (train/test). Next, place the corresponding images into each split after randomly shuffling them. Then, create a metadata.csv file for each split and place it in the corresponding directory. Note that the current code only works for jpeg images. If the exported images are in some other format, convert them to .jpg before running this code."
+      ],
+      "metadata": {
+        "id": "yaoJPVKrNq9N"
+      },
+      "id": "yaoJPVKrNq9N"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "be3c347d",
+      "metadata": {
+        "id": "be3c347d"
+      },
+      "outputs": [],
+      "source": [
+        "with open(output_csv, mode='w', newline='') as csv_file:\n",
+        "    fieldnames = ['file_name', 'Latitude', 'Longitude']\n",
+        "    writer = csv.DictWriter(csv_file, fieldnames=fieldnames)\n",
+        "\n",
+        "    # Write the header row\n",
+        "    writer.writeheader()\n",
+        "    for filename in os.listdir(directory_path):\n",
+        "        if os.path.isfile(os.path.join(directory_path, filename)):\n",
+        "            exif_data = get_exif_data(os.path.join(directory_path, filename))\n",
+        "            if exif_data:\n",
+        "                gps_latitude = exif_data.get('GPS GPSLatitude', None)\n",
+        "                gps_latitude_ref = exif_data.get('GPS GPSLatitudeRef', None)\n",
+        "                gps_longitude = exif_data.get('GPS GPSLongitude', None)\n",
+        "                gps_longitude_ref = exif_data.get('GPS GPSLongitudeRef', None)\n",
+        "                if gps_latitude and gps_longitude:\n",
+        "                    # Convert latitude and longitude to decimal degrees\n",
+        "                    latitude = convert_to_decimal_degrees(gps_latitude)\n",
+        "                    longitude = convert_to_decimal_degrees(gps_longitude)\n",
+        "\n",
+        "                    # Adjust for N/S and E/W reference\n",
+        "                    if gps_latitude_ref.values[0] == 'S':\n",
+        "                        latitude = -latitude\n",
+        "                    if gps_longitude_ref.values[0] == 'W':\n",
+        "                        longitude = -longitude\n",
+        "\n",
+        "                    # Write the data to the CSV file\n",
+        "                    writer.writerow({'file_name': filename, 'Latitude': latitude, 'Longitude': longitude})"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Uploading and Reading a Dataset on Hugging Face"
+      ],
+      "metadata": {
+        "id": "WEkVLwUcQ7PV"
+      },
+      "id": "WEkVLwUcQ7PV"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install datasets"
+      ],
+      "metadata": {
+        "id": "xtmhkAUSRBxp",
+        "outputId": "cab82646-49d6-431e-bb91-a5fee48296f6",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "id": "xtmhkAUSRBxp",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting datasets\n",
+            "  Downloading datasets-3.1.0-py3-none-any.whl.metadata (20 kB)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from datasets) (3.16.1)\n",
+            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.26.4)\n",
+            "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (17.0.0)\n",
+            "Collecting dill<0.3.9,>=0.3.0 (from datasets)\n",
+            "  Downloading dill-0.3.8-py3-none-any.whl.metadata (10 kB)\n",
+            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (2.2.2)\n",
+            "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.10/dist-packages (from datasets) (2.32.3)\n",
+            "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.6)\n",
+            "Collecting xxhash (from datasets)\n",
+            "  Downloading xxhash-3.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n",
+            "Collecting multiprocess<0.70.17 (from datasets)\n",
+            "  Downloading multiprocess-0.70.16-py310-none-any.whl.metadata (7.2 kB)\n",
+            "Collecting fsspec<=2024.9.0,>=2023.1.0 (from fsspec[http]<=2024.9.0,>=2023.1.0->datasets)\n",
+            "  Downloading fsspec-2024.9.0-py3-none-any.whl.metadata (11 kB)\n",
+            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.10.10)\n",
+            "Requirement already satisfied: huggingface-hub>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.26.2)\n",
+            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (24.2)\n",
+            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.2)\n",
+            "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (2.4.3)\n",
+            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n",
+            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (24.2.0)\n",
+            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.5.0)\n",
+            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.1.0)\n",
+            "Requirement already satisfied: yarl<2.0,>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.17.1)\n",
+            "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.23.0->datasets) (4.12.2)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.4.0)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.10)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2.2.3)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2024.8.30)\n",
+            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n",
+            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n",
+            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.16.0)\n",
+            "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from yarl<2.0,>=1.12.0->aiohttp->datasets) (0.2.0)\n",
+            "Downloading datasets-3.1.0-py3-none-any.whl (480 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.6/480.6 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading dill-0.3.8-py3-none-any.whl (116 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m8.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading fsspec-2024.9.0-py3-none-any.whl (179 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m179.3/179.3 kB\u001b[0m \u001b[31m10.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading multiprocess-0.70.16-py310-none-any.whl (134 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading xxhash-3.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (194 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hInstalling collected packages: xxhash, fsspec, dill, multiprocess, datasets\n",
+            "  Attempting uninstall: fsspec\n",
+            "    Found existing installation: fsspec 2024.10.0\n",
+            "    Uninstalling fsspec-2024.10.0:\n",
+            "      Successfully uninstalled fsspec-2024.10.0\n",
+            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+            "gcsfs 2024.10.0 requires fsspec==2024.10.0, but you have fsspec 2024.9.0 which is incompatible.\u001b[0m\u001b[31m\n",
+            "\u001b[0mSuccessfully installed datasets-3.1.0 dill-0.3.8 fsspec-2024.9.0 multiprocess-0.70.16 xxhash-3.5.0\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "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.10.4"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}