add readme

README.md

@@ -0,0 +1,556 @@
+latitude_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
+#############
+    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]
+    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]
+
+        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])
+        # 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()
+
+torch.cuda.empty_cache()
+predict_from_model(input)
+```