File size: 4,763 Bytes
5bb4f27 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 |
# LAJ CNN Image-to-GPS Model Iteration 1
This project features a convolutional neural network (CNN) for predicting GPS coordinates (latitude and longitude) from image inputs. Below, you'll find details on loading the model, performing inference, and the architecture of the network.
---
## 1. Loading the Model
To load the model, look at the sampleRun_v2.ipynb and run the same commands.
## 2. Running the Model
To perform inference on our model, just normalize the latitudes and longitudes to our means and standard deviations below.
Then run code similar to the code provided to test code provided below:
```
# Evaluate on Test Set
model.eval()
all_preds, all_actuals = [], []
with torch.no_grad():
for images, gps_coords in val_loader:
images, gps_coords = images.to(device), gps_coords.to(device)
outputs = model(images)
all_preds.append(outputs.cpu())
all_actuals.append(gps_coords.cpu())
all_preds = torch.cat(all_preds).numpy()
all_actuals = torch.cat(all_actuals).numpy()
# Denormalize Predictions
all_preds_denorm = all_preds * np.array([lat_std, lon_std]) + np.array([lat_mean, lon_mean])
all_actuals_denorm = all_actuals * np.array([lat_std, lon_std]) + np.array([lat_mean, lon_mean])
# Compute Error Metrics
mae = mean_absolute_error(all_actuals_denorm, all_preds_denorm)
rmse = mean_squared_error(all_actuals_denorm, all_preds_denorm, squared=False)
print(f"Test Set Mean Absolute Error: {mae:.4f}")
print(f"Test Set Root Mean Squared Error: {rmse:.4f}")
```
## 3. Latitude and Longitude Means and Standard Deviations
The following values represent the **means** and **standard deviations** of the latitude and longitude used in this model:
- **Latitude Mean**: `39.95173729922173`
- **Latitude Standard Deviation**: `0.0006877829213952256`
- **Longitude Mean**: `-75.19138804851796`
- **Longitude Standard Deviation**: `0.0006182574854250925`
These values are used to normalize and denormalize the latitude and longitude predictions during inference.
## 4. CNN Architecture
Finally here is the architecture of the CNN we used:
```
# Model Definition
class CustomGPSModel(nn.Module):
def __init__(self):
super(CustomGPSModel, self).__init__()
# Load EfficientNet-B0 with pretrained weights
self.efficientnet = efficientnet_b0(pretrained=True)
# Modify the final layer for regression (predicting latitude and longitude)
num_features = self.efficientnet.classifier[1].in_features
self.efficientnet.classifier[1] = nn.Linear(num_features, 2) # Output layer has 2 outputs for latitude & longitude
# Freeze earlier layers except the last few
for param in self.efficientnet.features.parameters():
param.requires_grad = True
def forward(self, x):
return self.efficientnet(x) # Forward pass through EfficientNet
```
## 5. Sample Run Code (how to install and run everything)
```
!pip install datasets
!pip install huggingface_hub
!pip install requests
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision.models import efficientnet_b0
from torch.optim.lr_scheduler import CosineAnnealingLR
from torchvision import transforms
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import functional as F
from PIL import Image
import numpy as np
from sklearn.metrics import mean_absolute_error, mean_squared_error
from huggingface_hub import PyTorchModelHubMixin
import os
# Model Definition
class CustomGPSModel(nn.Module):
def __init__(self):
super(CustomGPSModel, self).__init__()
# Load EfficientNet-B0 with pretrained weights
self.efficientnet = efficientnet_b0(pretrained=True)
# Modify the final layer for regression (predicting latitude and longitude)
num_features = self.efficientnet.classifier[1].in_features
self.efficientnet.classifier[1] = nn.Linear(num_features, 2) # Output layer has 2 outputs for latitude & longitude
# Freeze earlier layers except the last few
for param in self.efficientnet.features.parameters():
param.requires_grad = True
def forward(self, x):
return self.efficientnet(x) # Forward pass through EfficientNet
from huggingface_hub import hf_hub_download
import torch
path_name = "efficientnet_gps_regressor_complete.pth"
repo_name = "CustomGPSModel_EfficientNetB0_Run2"
organization_name = "LAJ-519-Image-Project"
# Specify the repository and the filename of the model you want to load
repo_id = f"{organization_name}/{repo_name}"
filename = f"{path_name}"
model_path = hf_hub_download(repo_id=repo_id, filename=filename)
# Load the model using torch
model_test = torch.load(model_path)
model_test.eval()
```
|