YAML Metadata
Warning:
empty or missing yaml metadata in repo card
(https://huggingface.co/docs/hub/model-cards#model-card-metadata)
atitude_mean: 39.95184413388056 latitude_std: 0.0006308700565432299 longitude_mean: -75.19147985909444 longitude_std: 0.0006379960634765379
To run input tensors to predict_from_model(input_tensor):
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, Dataset
from transformers import AutoImageProcessor, AutoModelForImageClassification
from huggingface_hub import PyTorchModelHubMixin
from PIL import Image
import os
import numpy as np
def predict_from_model(input_tensor):
import torch
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
from geopy.distance import geodesic
from datasets import load_dataset
from huggingface_hub import hf_hub_download
import numpy as np
torch.cuda.empty_cache()
#############
path_map = {"best region models/region_model_lr_0.0002_step_10_gamma_0.1_epochs_15.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="best region models/region_model_lr_0.0002_step_10_gamma_0.1_epochs_15.pth"),
"best region models/region_model_lr_0.00035_step_10_gamma_0.1_epochs_50.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="best region models/region_model_lr_0.00035_step_10_gamma_0.1_epochs_50.pth"),
"best region models/region_model_lr_0.0005_step_10_gamma_0.1_epochs_50.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="best region models/region_model_lr_0.0005_step_10_gamma_0.1_epochs_50.pth"),
"best region models/region_model_lr_0.0005_step_10_gamma_0.1_epochs_60.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="best region models/region_model_lr_0.0005_step_10_gamma_0.1_epochs_60.pth"),
"best region models/region_model_lr_0.002_step_10_gamma_0.1_epochs_100.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="best region models/region_model_lr_0.002_step_10_gamma_0.1_epochs_100.pth"),
"best region models/model_histories.json" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="best region models/model_histories.json"),
"models/location_model_0.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_0.pth"),
"models/location_model_1.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_1.pth"),
"models/location_model_2.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_2.pth"),
"models/location_model_3.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_3.pth"),
"models/location_model_4.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_4.pth"),
"models/location_model_5.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_5.pth"),
"models/location_model_6.pth" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="models/location_model_6.pth"),
"region_ensemble_weights.json" : hf_hub_download(repo_id="IanAndJohn/region_ensemble_model", filename="region_ensemble_weights.json")}
##############
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, Dataset
from transformers import AutoImageProcessor, AutoModelForImageClassification
from huggingface_hub import PyTorchModelHubMixin
from PIL import Image
import os
import numpy as np
class PredictedObject():
def __init__(self, image, lat, lon, region, original_lat=None, original_lon=None):
self.lat = lat
self.lon = lon
self.region = region
self.image = image
if original_lat is None or original_lon is None:
self.original_lat = lat
self.original_lon = lon
else:
self.original_lat = original_lat
self.original_lon = original_lon
self.predicted_region = None
self.predicted_lat = None
self.predicted_lon = None
def __lt__(self, other):
return self.predicted_region < other.predicted_region
def __eq__(self, other):
return self.predicted_region == other.predicted_region
class PredictionObjectDataset(Dataset):
def __init__(self, object_lst, transform=None, lat_mean=None, lat_std=None, lon_mean=None, lon_std=None, useRegions=False, give_originals=False):
self.object_lst = object_lst
self.transform = transform
self.useRegions = useRegions
self.give_originals = give_originals
# Compute mean and std from the dataframe if not provided
if (len(self.object_lst) == 1):
self.latitude_mean = self.object_lst[0].lat
self.latitude_std = 1
self.longitude_mean = self.object_lst[0].lon
self.longitude_std = 1
else:
self.latitude_mean = lat_mean if lat_mean is not None else np.mean(np.array([x.lat for x in self.object_lst]))
self.latitude_std = lat_std if lat_std is not None else np.std(np.array([x.lat for x in self.object_lst]))
self.longitude_mean = lon_mean if lon_mean is not None else np.mean(np.array([x.lon for x in self.object_lst]))
self.longitude_std = lon_std if lon_std is not None else np.std(np.array([x.lon for x in self.object_lst]))
self.normalize()
def normalize(self):
new_object_lst = []
for obj in self.object_lst:
obj.lat = (obj.lat - self.latitude_mean) / self.latitude_std
obj.lon = (obj.lon - self.longitude_mean) / self.longitude_std
new_object_lst.append(obj)
self.object_lst = new_object_lst
def __len__(self):
return len(self.object_lst)
def __getitem__(self, idx):
# Extract data
example = self.object_lst[idx]
# Load and process the image
image = example.image
latitude = example.lat
longitude = example.lon
region = example.region
# image = image.rotate(-90, expand=True)
if self.transform:
image = self.transform(image)
# Normalize GPS coordinates
gps_coords = torch.tensor([latitude, longitude], dtype=torch.float32)
gps_coords_orginal = torch.tensor([example.original_lat, example.original_lon], dtype=torch.float32)
if self.useRegions and self.give_originals:
return image, gps_coords, gps_coords_orginal, region
elif self.useRegions:
return image, gps_coords, region
elif self.give_originals:
return image, gps_coords, gps_coords_orginal
else:
return image, gps_coords
class TensorDataset(Dataset):
def __init__(self, tensors, transform=None, lat_mean=None, lat_std=None, lon_mean=None, lon_std=None, useRegions=False, give_originals=False):
# self.hf_dataset = hf_dataset.map(
self.tensors = tensors
def __len__(self):
return len(self.tensors)
def __getitem__(self, idx):
# Extract data
image = self.tensors[idx]
return image
##################
transform = transforms.Compose([
#transforms.RandomResizedCrop(224), # Random crop and resize to 224x224
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(), # Random horizontal flip
# transforms.RandomRotation(degrees=15), # Random rotation between -15 and 15 degrees
transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1), # Random color jitter
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
# 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])
])
# Create the training dataset and dataloader
train_dataset = TensorDataset(input_tensor)
train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# lat_mean = train_dataset.latitude_mean
# lat_std = train_dataset.latitude_std
# lon_mean = train_dataset.longitude_mean
# lon_std = train_dataset.longitude_std
#####################
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, Dataset
from transformers import AutoImageProcessor, AutoModelForImageClassification
from huggingface_hub import PyTorchModelHubMixin
from PIL import Image
import os
import numpy as np
import json
import torchvision.models as models
##################
import torch.nn.functional as F
class_frequency = torch.zeros(7)
region_one_hot = F.one_hot(torch.tensor([0,1,2,3,4,5,6]), num_classes=7)
# for _, _, region in train_dataset:
# class_frequency += region_one_hot[region]
# print(class_frequency)
# class_weights = torch.full((7,), len(train_dataset)) / class_frequency
# class_weights = class_weights / torch.max(class_weights)
# print(class_weights)
class_weights = [0.2839, 0.4268, 0.5583, 0.3873, 1.0000, 0.6036, 0.6009]
#####################
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# print(f'Using device: {device}')
per_model_weights = []
with open(path_map['region_ensemble_weights.json'], 'r') as file:
per_model_weights = json.load(file)
search_stats = []
with open(path_map['best region models/model_histories.json'], 'r') as file:
search_stats = json.load(file)
my_models = []
for i, (path, _, _, _, _, _, _, _, _) in enumerate(search_stats):
path = path_map[path]
state_dict = torch.load(path)
region_model = models.resnet18(pretrained=False)
num_features = region_model.fc.in_features
region_model.fc = nn.Sequential(nn.Dropout(0.5),
nn.Linear(num_features, 7))
region_model.load_state_dict(state_dict)
region_model.cpu()
my_models.append(region_model)
per_model_weights = torch.tensor(per_model_weights).to(device)
#########
torch.cuda.empty_cache()
##########
predicted_object_lst = []
num_regions = 7
for images in train_dataloader:
images = images.to(device)
# gps_coords_original = gps_coords_original.to(device)
outputs = torch.zeros((images.shape[0], 7)).to(device)
for i, model in enumerate(my_models):
model.eval()
model.to(device)
model_outputs = model(images)
outputs += per_model_weights[i] * model_outputs
model.cpu()
# print(i, len(predicted_object_lst))
outputs /= len(my_models)
_, predicted_regions = torch.max(outputs, 1)
predicted_regions = predicted_regions.cpu().numpy()
images = images.cpu().numpy()
for i in range(len(predicted_regions)):
predicted_object = PredictedObject(images[i], -1, -1, predicted_regions[i])
predicted_object.predicted_region = predicted_regions[i]
predicted_object_lst.append(predicted_object)
torch.cuda.empty_cache()
#################
predicted_object_lst = sorted(predicted_object_lst)
po_predicted_region_lst = [[] for _ in range(7)]
for po in predicted_object_lst:
po.lat = po.original_lat
po.lon = po.original_lon
po_predicted_region_lst[po.predicted_region].append(po)
po_datasets = [PredictionObjectDataset(x, give_originals=True) for x in po_predicted_region_lst]
# print([len(ds) for ds in po_datasets])
po_loaders = [DataLoader(x, batch_size=32, shuffle=False) for x in po_datasets]
# lat_mean_lst = [x.latitude_mean for x in po_datasets]
# lat_std_lst = [x.latitude_std for x in po_datasets]
# lon_mean_lst = [x.longitude_mean for x in po_datasets]
# lon_std_lst = [x.longitude_std for x in po_datasets]
############
from sklearn.metrics import mean_absolute_error, mean_squared_error
import torch.nn.functional as F
# all_preds = []
# all_actuals = []
all_preds_norm = []
# all_actuals_norm = []
# all_regions = []
for i in range(num_regions):
# print(f'region {i}')
# model_all_preds = []
# model_all_actuals = []
model_all_preds_norm = []
# model_all_actuals_norm = []
# model_all_regions = []
val_dataloader = po_loaders[i]
if (len(val_dataloader) == 0):
continue
state_dict = torch.load(path_map[f'models/location_model_{i}.pth'])
model_loction = models.resnet18(pretrained=False)
num_features = model_loction.fc.in_features
model_loction.fc = nn.Linear(num_features, 2)
model_loction.load_state_dict(state_dict)
model_loction.to(device)
model_loction.eval()
with torch.no_grad():
for images, _, _ in val_dataloader:
images = images.to(device)
outputs = model_loction(images)
# Denormalize predictions and actual values
preds_norm = outputs.cpu()
# actuals_norm = gps_coords.cpu()
# preds = outputs.cpu() * torch.tensor([lat_std_lst[i], lon_std_lst[i]]) + torch.tensor([lat_mean_lst[i], lon_mean_lst[i]])
# actuals = gps_coords.cpu() * torch.tensor([lat_std_lst[i], lon_std_lst[i]]) + torch.tensor([lat_mean_lst[i], lon_mean_lst[i]])#gps_coords_original.cpu()
# model_all_preds.append(preds)
# model_all_actuals.append(actuals)
model_all_preds_norm.append(preds_norm)
# model_all_actuals_norm.append(actuals_norm)
# model_all_regions.extend([i for _ in range(len(images))])
# Concatenate all batches
# model_all_preds = torch.cat(model_all_preds)
# model_all_actuals = torch.cat(model_all_actuals)
model_all_preds_norm = torch.cat(model_all_preds_norm)
# model_all_actuals_norm = torch.cat(model_all_actuals_norm)
# Compute error metrics
# rmse = F.mse_loss(model_all_actuals_norm, model_all_preds_norm)
# model_all_preds = model_all_preds.numpy()
# model_all_actuals = model_all_actuals.numpy()
model_all_preds_norm = model_all_preds_norm.numpy()
# model_all_actuals_norm = model_all_actuals_norm.numpy()
# print(model_all_preds[0])
# print(model_all_actuals[0])
# print(model_all_preds_norm[0])
# print(model_all_actuals_norm[0])
# print(f'Mean Squared Error: {rmse}')
# all_preds.append([model_all_preds])
# all_actuals.append([model_all_actuals])
all_preds_norm.append([model_all_preds_norm])
# print("images predicted: ", len(all_preds_norm))
# all_actuals_norm.append([model_all_actuals_norm])
# all_regions.append(model_all_regions)
del model_loction
torch.cuda.empty_cache()
############
# all_preds_denorm = all_preds
# all_actuals_denorm = all_actuals
all_preds = all_preds_norm
# all_actuals = all_actuals_norm
# all_regions = all_regions
def flatten(lst):
newlst = []
for sublst in lst:
for item in sublst:
newlst.append(item)
return newlst
all_preds = flatten(all_preds)
# all_actuals = flatten(all_actuals)
# all_preds_denorm = flatten(all_preds_denorm)
# all_actuals_denorm = flatten(all_actuals_denorm)
# all_regions = list(flatten(all_regions))
#############
# actual_denorm_y = []
# actual_denorm_x = []
# for x in all_actuals_denorm:
# for e in x:
# actual_denorm_x.append(e[0])
# actual_denorm_y.append(e[1])
# # actual_denorm_x.append(x[0])
# # actual_denorm_y.append(x[1])
# pred_denorm_y = []
# pred_denorm_x = []
# for x in all_preds_denorm:
# for e in x:
# pred_denorm_x.append(e[0])
# pred_denorm_y.append(e[1])
# # pred_denorm_x.append(x[0])
# # pred_denorm_y.append(x[1])
# actual_y = []
# actual_x = []
# for x in all_actuals:
# for e in x:
# actual_x.append(e[0])
# actual_y.append(e[1])
# # actual_x.append(x[0])
# # actual_y.append(x[1])
pred_y = []
pred_x = []
for x in all_preds:
for e in x:
pred_x.append(e[0])
pred_y.append(e[1])
############
t = torch.zeros((len(pred_x), 2))
t[:, 0] = torch.tensor(pred_x)
t[:, 1] = torch.tensor(pred_y)
return t
# import matplotlib.pyplot as plt
# from geopy.distance import geodesic
# import seaborn as sns
# print(pred_x)
# print(pred_y)
# print(actual_x)
# print(actual_y)
# print(pred_denorm_x)
# print(pred_denorm_y)
# print(actual_denorm_x)
# print(actual_denorm_y)
# plt.scatter(actual_denorm_y, actual_denorm_x, label='Actual', color='black', alpha=0.5)
# # plt.scatter(all_preds_denorm[:, 1], all_preds_denorm[:, 0], label='Predicted', color='blue', alpha=0.5)
# over100 = 0
# under100 = 0
# under50 = 0
# under25 = 0
# all_over100 = []
# all_under100 = []
# all_under50 = []
# all_under25 = []
# average_dist = 0.0
# dists = []
# for i in range(len(actual_denorm_x)):
# pred_denorm_loc = (pred_denorm_x[i], pred_denorm_y[i])
# actual_denorm_loc = (actual_denorm_x[i], actual_denorm_y[i])
# dist = geodesic(actual_denorm_loc, pred_denorm_loc).meters
# dists.append(dist)
# if dist > 50:
# over100 += 1
# all_over100.append(pred_denorm_loc)
# elif dist > 25:
# under100 += 1
# all_under100.append(pred_denorm_loc)
# elif dist > 10:
# under50 += 1
# all_under50.append(pred_denorm_loc)
# else:
# under25 += 1
# all_under25.append(pred_denorm_loc)
# plt.plot(
# [actual_denorm_y[i], pred_denorm_y[i]],
# [actual_denorm_x[i], pred_denorm_x[i]],
# color='grey',
# alpha=0.5,
# linewidth=0.5
# )
# dists = np.array(dists)
# plt.scatter([y for x,y in all_over100], [x for x,y in all_over100], label=f'over 50m: {over100}', color='red', alpha=0.5)
# plt.scatter([y for x,y in all_under100], [x for x,y in all_under100], label=f'under 50m: {under100}', color='orange', alpha=0.5)
# plt.scatter([y for x,y in all_under50], [x for x,y in all_under50], label=f'under 25m: {under50}', color='green', alpha=0.5)
# plt.scatter([y for x,y in all_under25], [x for x,y in all_under25], label=f'under 10m: {under25}', color='blue', alpha=0.5)
# plt.legend()
# plt.xlabel('Longitude')
# plt.ylabel('Latitude')
# plt.title('Actual vs. Predicted GPS Coordinates with Error Lines')
# plt.show()
# regions_enum = {0 : "fisher bennett",
# 1 : "outer quad",
# 2 : "outside football",
# 3 : "chem building",
# 4 : "top of walk",
# 5 : "bottom of walk",
# 6 : "chem courtyard",
# 7 : "no assigned region"}
# colors = {0:'red',
# 1:'orange',
# 2:'yellow',
# 3:'green',
# 4:'blue',
# 5:'purple',
# 6:'pink',
# 7:'black'}
# for i in range(len(actual_denorm_x)):
# plt.plot(
# [actual_denorm_y[i], pred_denorm_y[i]],
# [actual_denorm_x[i], pred_denorm_x[i]],
# color='grey',
# alpha=0.25,
# linewidth=0.5
# )
# # plt.scatter([p[0] for p in pts], [p[1] for p in pts], s=15, c=[colors[i] for i in all_regions], edgecolors='black')
# colors_lst = [colors[i] for i in all_regions]
# plt.scatter(actual_denorm_y, actual_denorm_x, label='Actual', color=colors_lst, alpha=0.5)
# plt.scatter(pred_denorm_y, pred_denorm_x, label='Predicted', color=colors_lst, alpha=0.5)
# # plt.gca().invert_xaxis()
# plt.show()
# # Plot the distribution
# plt.figure(figsize=(10, 6))
# sns.histplot(dists, bins=30, kde=True, color='blue', alpha=0.7)
# # Add labels and title
# plt.title("Distribution of Geodesic Distances (Accuracy of Guesses)")
# plt.xlabel("Geodesic Distance (meters)")
# plt.ylabel("Frequency")
# # Add mean and median lines for context
# mean_distance = dists.mean()
# median_distance = np.median(dists)
# plt.axvline(mean_distance, color='red', linestyle='--', label=f'Mean: {mean_distance:.2f} meters')
# plt.axvline(median_distance, color='green', linestyle='--', label=f'Median: {median_distance:.2f} meters')
# plt.legend()
# plt.grid(True)
# plt.show()