region_ensemble_model

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()