Push model using huggingface_hub.

README.md

@@ -6,197 +6,4 @@ 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]
-
----
-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}')
+- Docs: [More Information Needed]

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3735f36627d59781bbc387f8ff3f467e6c76a78a2dee1db07691369f0e5f4701
+oid sha256:e18815fdf160d33cd21265e42d5f9bf3c4f9623c237789ae2ed9805a87d6ef65
 size 104844624