Update README.md

README.md

@@ -6,4 +6,197 @@ tags:
 
 This model has been pushed to the Hub using the [PytorchModelHubMixin](https://huggingface.co/docs/huggingface_hub/package_reference/mixins#huggingface_hub.PyTorchModelHubMixin) integration:
 - Library: [More Information Needed]
-- Docs: [More Information Needed]
+- Docs: [More Information Needed]
+
+---
+dataset_info:
+  features:
+  - name: image
+    dtype: image
+  - name: label
+    dtype:
+      class_label:
+        names:
+          '0': test
+          '1': train
+          '2': validation
+  splits:
+  - name: train
+    num_bytes: 7260686.0
+    num_examples: 560
+  - name: validation
+    num_bytes: 182280987.0
+    num_examples: 78
+  - name: test
+    num_bytes: 2290972.0
+    num_examples: 147
+  download_size: 172987254
+  dataset_size: 191832645.0
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*
+  - split: validation
+    path: data/validation-*
+  - split: test
+    path: data/test-*
+---
+Model inference:
+# model
+
+import os
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+from PIL import Image
+from torchvision import transforms
+import pandas as pd
+from huggingface_hub import PyTorchModelHubMixin
+
+# Define the custom dataset
+class GPSImageDataset(Dataset):
+    def __init__(self, hf_dataset, transform=None, lat_mean=None, lat_std=None, lon_mean=None, lon_std=None):
+        self.hf_dataset = hf_dataset
+        self.transform = transform
+
+        # Compute mean and std from the dataframe if not provided
+        self.latitude_mean = lat_mean if lat_mean is not None else np.mean(np.array(self.hf_dataset['Latitude']))
+        self.latitude_std = lat_std if lat_std is not None else np.std(np.array(self.hf_dataset['Latitude']))
+        self.longitude_mean = lon_mean if lon_mean is not None else np.mean(np.array(self.hf_dataset['Longitude']))
+        self.longitude_std = lon_std if lon_std is not None else np.std(np.array(self.hf_dataset['Longitude']))
+
+    def __len__(self):
+        return len(self.hf_dataset)
+
+    def __getitem__(self, idx):
+        # Extract data
+        example = self.hf_dataset[idx]
+
+        # Load and process the image
+        image = example['image']
+        latitude = example['Latitude']
+        longitude = example['Longitude']
+        # image = image.rotate(-90, expand=True)
+        if self.transform:
+            image = self.transform(image)
+
+        # Normalize GPS coordinates
+        latitude = (latitude - self.latitude_mean) / self.latitude_std
+        longitude = (longitude - self.longitude_mean) / self.longitude_std
+        gps_coords = torch.tensor([latitude, longitude], dtype=torch.float32)
+
+        return image, gps_coords
+
+
+# Define the CNN model
+class CustomCNNModel(nn.Module, PyTorchModelHubMixin):
+    def __init__(self, num_classes=2):
+        super(CustomCNNModel, self).__init__()
+
+        # Define the CNN architecture (4 convolutional layers followed by fully connected layers)
+        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
+        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
+        self.conv4 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
+
+        self.pool = nn.MaxPool2d(2, 2)
+
+        # Define the fully connected layers after flattening
+        self.fc1 = nn.Linear(256 * 14 * 14, 512)  # Output size after pooling (assuming input image is 224x224)
+        self.fc2 = nn.Linear(512, 256)
+        self.fc3 = nn.Linear(256, num_classes)  # Output layer (2 values: latitude and longitude)
+
+        # Activation functions
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        # Pass through convolutional layers
+        x = self.relu(self.conv1(x))
+        x = self.pool(x)
+        x = self.relu(self.conv2(x))
+        x = self.pool(x)
+        x = self.relu(self.conv3(x))
+        x = self.pool(x)
+        x = self.relu(self.conv4(x))
+        x = self.pool(x)
+
+        # Flatten the tensor before passing it to the fully connected layers
+        x = x.view(-1, 256 * 14 * 14)
+
+        # Pass through fully connected layers
+        x = self.relu(self.fc1(x))
+        x = self.relu(self.fc2(x))
+        x = self.fc3(x)
+
+        return x
+
+
+# Define transformations for images
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),  # Resize to match the input size of the model
+    transforms.ToTensor(),  # Convert image to tensor
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Optional normalization
+])
+
+from datasets import load_dataset
+
+# loading in data
+ds = load_dataset("gydou/released_img", split = "train")
+
+# pulling in weights from hugging face
+model=CustomCNNModel.from_pretrained("CIS-5190-Project-1/model")
+
+lat_mean = 35
+lat_std = 8
+lon_mean = 70
+lon_std = 6
+# Optionally, you can create a separate transform for inference without augmentations
+inference_transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225])
+])
+
+val_dataset = GPSImageDataset(
+    hf_dataset=ds,
+    transform=inference_transform,
+    lat_mean=lat_mean,
+    lat_std=lat_std,
+    lon_mean=lon_mean,
+    lon_std=lon_std
+)
+val_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)
+
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+# Initialize lists to store predictions and actual values
+all_preds = []
+all_actuals = []
+
+model.eval()
+with torch.no_grad():
+    for images, gps_coords in val_dataloader:
+        images, gps_coords = images.to("cpu"), gps_coords.to("cpu")
+
+        outputs = model(images)
+
+        # Denormalize predictions and actual values
+        preds = outputs.cpu() * torch.tensor([lat_std, lon_std]) + torch.tensor([lat_mean, lon_mean])
+        actuals = gps_coords.cpu() * torch.tensor([lat_std, lon_std]) + torch.tensor([lat_mean, lon_mean])
+
+        all_preds.append(preds)
+        all_actuals.append(actuals)
+        break
+
+# Concatenate all batches
+all_preds = torch.cat(all_preds).numpy()
+all_actuals = torch.cat(all_actuals).numpy()
+
+# Compute error metrics
+mae = mean_absolute_error(all_actuals, all_preds)
+rmse = mean_squared_error(all_actuals, all_preds, squared=False)
+
+print(f'Mean Absolute Error: {mae}')
+print(f'Root Mean Squared Error: {rmse}')