Resnet_inference.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "Yr6oayCidlo_"
      },
      "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": "code",
      "source": [
        "!huggingface-cli login"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xCWmhF1kdrJZ",
        "outputId": "a06aeaf5-b95c-402a-bb5e-20d3c6a9465e"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "    _|    _|  _|    _|    _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|_|_|_|    _|_|      _|_|_|  _|_|_|_|\n",
            "    _|    _|  _|    _|  _|        _|          _|    _|_|    _|  _|            _|        _|    _|  _|        _|\n",
            "    _|_|_|_|  _|    _|  _|  _|_|  _|  _|_|    _|    _|  _|  _|  _|  _|_|      _|_|_|    _|_|_|_|  _|        _|_|_|\n",
            "    _|    _|  _|    _|  _|    _|  _|    _|    _|    _|    _|_|  _|    _|      _|        _|    _|  _|        _|\n",
            "    _|    _|    _|_|      _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|        _|    _|    _|_|_|  _|_|_|_|\n",
            "\n",
            "    To log in, `huggingface_hub` requires a token generated from https://huggingface.co/settings/tokens .\n",
            "Enter your token (input will not be visible): \n",
            "Add token as git credential? (Y/n) Y\n",
            "Token is valid (permission: write).\n",
            "The token `metadata_parser` has been saved to /root/.cache/huggingface/stored_tokens\n",
            "\u001b[1m\u001b[31mCannot authenticate through git-credential as no helper is defined on your machine.\n",
            "You might have to re-authenticate when pushing to the Hugging Face Hub.\n",
            "Run the following command in your terminal in case you want to set the 'store' credential helper as default.\n",
            "\n",
            "git config --global credential.helper store\n",
            "\n",
            "Read https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage for more details.\u001b[0m\n",
            "Token has not been saved to git credential helper.\n",
            "Your token has been saved to /root/.cache/huggingface/token\n",
            "Login successful.\n",
            "The current active token is: `metadata_parser`\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.models as models\n",
        "import torchvision.transforms as transforms\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "from transformers import AutoImageProcessor, AutoModelForImageClassification\n",
        "from huggingface_hub import PyTorchModelHubMixin\n",
        "from PIL import Image\n",
        "import os\n",
        "import numpy as np\n",
        "from datasets import load_dataset, Image\n",
        "from huggingface_hub import hf_hub_download"
      ],
      "metadata": {
        "id": "ofRgp3bKnOLR"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xzgVrXmd3xoZ"
      },
      "source": [
        "# INPUTS"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Latitude and longitude mean and std loaded from training data\n",
        "lat_mean = 39.95173675925926\n",
        "lat_std = 0.0006117096745964738\n",
        "lon_mean = -75.19119498148149\n",
        "lon_std = 0.0007743986248108865\n",
        "\n",
        "# Load dataset for inference\n",
        "dataset_test = load_dataset(\"{YOUR ORGANIZATION NAME}/{DATASET NAME}\", split=\"test\")"
      ],
      "metadata": {
        "id": "rolyYeqMiu21"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5QfMnfs34hn"
      },
      "source": [
        "# Data Processing"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class GPSImageDataset(Dataset):\n",
        "    def __init__(self, hf_dataset, transform=None, lat_mean=None, lat_std=None, lon_mean=None, lon_std=None):\n",
        "        self.hf_dataset = hf_dataset\n",
        "        self.transform = transform\n",
        "\n",
        "        # Compute mean and std from the dataframe if not provided\n",
        "        self.latitude_mean = lat_mean if lat_mean is not None else np.mean(np.array(self.hf_dataset['Latitude']))\n",
        "        self.latitude_std = lat_std if lat_std is not None else np.std(np.array(self.hf_dataset['Latitude']))\n",
        "        self.longitude_mean = lon_mean if lon_mean is not None else np.mean(np.array(self.hf_dataset['Longitude']))\n",
        "        self.longitude_std = lon_std if lon_std is not None else np.std(np.array(self.hf_dataset['Longitude']))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.hf_dataset)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        # Extract data\n",
        "        example = self.hf_dataset[idx]\n",
        "\n",
        "        # Load and process the image\n",
        "        image = example['image']\n",
        "        latitude = example['Latitude']\n",
        "        longitude = example['Longitude']\n",
        "        # image = image.rotate(-90, expand=True)\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "\n",
        "        # Normalize GPS coordinates\n",
        "        latitude = (latitude - self.latitude_mean) / self.latitude_std\n",
        "        longitude = (longitude - self.longitude_mean) / self.longitude_std\n",
        "        gps_coords = torch.tensor([latitude, longitude], dtype=torch.float32)\n",
        "\n",
        "        return image, gps_coords"
      ],
      "metadata": {
        "id": "L9oBXpDVjBg-"
      },
      "execution_count": 48,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Transform for inference without augmentations\n",
        "inference_transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
        "                         std=[0.229, 0.224, 0.225])\n",
        "])\n",
        "\n",
        "\n",
        "# Create the validation dataset and dataloader using mean and std\n",
        "val_dataset = GPSImageDataset(\n",
        "    hf_dataset=dataset_test,\n",
        "    transform=inference_transform,\n",
        "    lat_mean=lat_mean,\n",
        "    lat_std=lat_std,\n",
        "    lon_mean=lon_mean,\n",
        "    lon_std=lon_std\n",
        ")\n",
        "val_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)"
      ],
      "metadata": {
        "id": "mp6Mwfc8dsrI"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(dataset_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WoHEQBHBduf3",
        "outputId": "6be6a7f0-0fbc-473f-ddbf-3e392934c640"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset({\n",
            "    features: ['image', 'Latitude', 'Longitude'],\n",
            "    num_rows: 60\n",
            "})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CdLEWIKhaX_o"
      },
      "source": [
        "# Performing Inference"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "id": "Zgq3Z9zngu6K",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93f3340d-5520-460c-efec-3935a0c1c9f7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-50-23faf52367f9>:11: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  resnet = torch.load(model_path)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "ResNet(\n",
              "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
              "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "  (relu): ReLU(inplace=True)\n",
              "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
              "  (layer1): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer2): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer3): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (layer4): Sequential(\n",
              "    (0): BasicBlock(\n",
              "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (downsample): Sequential(\n",
              "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
              "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      )\n",
              "    )\n",
              "    (1): BasicBlock(\n",
              "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (relu): ReLU(inplace=True)\n",
              "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
              "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "    )\n",
              "  )\n",
              "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
              "  (fc): Linear(in_features=512, out_features=2, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ],
      "source": [
        "# Specify the repository and the filename of the model you want to load\n",
        "repo_id = \"Imagetogps/ImageToGPSproject_base_resnet18\"  # Replace with your repo name\n",
        "filename = \"resnet_gps_regressor_complete.pth\"\n",
        "\n",
        "model_path = hf_hub_download(repo_id=repo_id, filename=filename)\n",
        "\n",
        "# Load the model using torch\n",
        "resnet = torch.load(model_path)\n",
        "resnet.eval()  # Set the model to evaluation mode"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6AdRxPfkWy2n",
        "outputId": "6885d123-34b8-43db-a6b7-b1d5640a4197"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n",
            "Mean Absolute Error: 0.00045855838106945157\n",
            "Root Mean Squared Error: 0.0005641035968437791\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n",
            "  warnings.warn(\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import mean_absolute_error, mean_squared_error\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f'Using device: {device}')\n",
        "resnet = resnet.to(device)\n",
        "\n",
        "# Initialize lists to store predictions and actual values\n",
        "all_preds = []\n",
        "all_actuals = []\n",
        "\n",
        "resnet.eval()\n",
        "with torch.no_grad():\n",
        "    for images, gps_coords in val_dataloader:\n",
        "        images, gps_coords = images.to(device), gps_coords.to(device)\n",
        "\n",
        "        outputs = resnet(images)\n",
        "\n",
        "        # Denormalize predictions and actual values\n",
        "        preds = outputs.cpu() * torch.tensor([lat_std, lon_std]) + torch.tensor([lat_mean, lon_mean])\n",
        "        actuals = gps_coords.cpu() * torch.tensor([lat_std, lon_std]) + torch.tensor([lat_mean, lon_mean])\n",
        "\n",
        "        all_preds.append(preds)\n",
        "        all_actuals.append(actuals)\n",
        "\n",
        "# Concatenate all batches\n",
        "all_preds = torch.cat(all_preds).numpy()\n",
        "all_actuals = torch.cat(all_actuals).numpy()\n",
        "\n",
        "# Compute error metrics\n",
        "mae = mean_absolute_error(all_actuals, all_preds)\n",
        "rmse = mean_squared_error(all_actuals, all_preds, squared=False)\n",
        "\n",
        "print(f'Mean Absolute Error: {mae}')\n",
        "print(f'Root Mean Squared Error: {rmse}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "12BMgT0CXVu7",
        "outputId": "d840eb29-2412-47de-d7c3-f7dd26208758"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Denormalize predictions and actual values\n",
        "all_preds_denorm = all_preds * np.array([lat_std, lon_std]) + np.array([lat_mean, lon_mean])\n",
        "all_actuals_denorm = all_actuals * np.array([lat_std, lon_std]) + np.array([lat_mean, lon_mean])\n",
        "\n",
        "plt.figure(figsize=(10, 5))\n",
        "\n",
        "# Plot actual points\n",
        "plt.scatter(all_actuals_denorm[:, 1], all_actuals_denorm[:, 0], label='Actual', color='blue', alpha=0.6)\n",
        "\n",
        "# Plot predicted points\n",
        "plt.scatter(all_preds_denorm[:, 1], all_preds_denorm[:, 0], label='Predicted', color='red', alpha=0.6)\n",
        "\n",
        "# Draw lines connecting actual and predicted points\n",
        "for i in range(len(all_actuals_denorm)):\n",
        "    plt.plot(\n",
        "        [all_actuals_denorm[i, 1], all_preds_denorm[i, 1]],\n",
        "        [all_actuals_denorm[i, 0], all_preds_denorm[i, 0]],\n",
        "        color='gray', linewidth=0.5\n",
        "    )\n",
        "\n",
        "plt.legend()\n",
        "plt.xlabel('Longitude')\n",
        "plt.ylabel('Latitude')\n",
        "plt.title('Actual vs. Predicted GPS Coordinates with Error Lines')\n",
        "plt.show()"
      ]
    }
  ]
}