Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,24 @@
+data/
+tests/
+*.jpg
+
+# Ignore version control system directories
+.git/
+.gitignore
+
+# Ignore Python cache and environment files
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.env
+
+# Ignore IDE and editor files
+.vscode/
+*.swp
+.idea/
+
+# Ignore logs and temporary files
+*.log
+*.tmp
+*.bak

.gitignore

@@ -0,0 +1,29 @@
+# IntelliJ project files
+.idea
+*.iml
+out
+gen
+
+# Data files
+/original
+/raw_data
+/cropped_data
+/data/highres
+
+#Python cache
+*.pyc
+__pycache__
+
+#Jupyter checkpoint
+.ipynb_checkpoints
+
+# Model weights
+*.pth
+*.h5
+*.pkl
+
+# Logs
+logs
+
+# gradio flag
+flagged

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

Dockerfile

@@ -0,0 +1,21 @@
+# Use an official PyTorch image with CUDA support or Python base image
+FROM python:3.10-slim
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the contents of your project to /app in the container
+COPY . .
+
+# Set the PYTHONPATH to include the src directory
+ENV PYTHONPATH=/app
+
+# Install Python dependencies
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Expose the port Gradio will run on (default: 7860)
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "./src/main.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Auxiliary.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,44 @@
 ---
-title: Da Detection
-emoji: 💻
-colorFrom: blue
-colorTo: yellow
+title: da_detection
+app_file: src/main.py
 sdk: gradio
-sdk_version: 5.6.0
-app_file: app.py
-pinned: false
+sdk_version: 5.3.0
 ---
+# Beirut Disadvantaged Areas Mapping
+![image](cover.jpg)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+![alt text](https://img.shields.io/badge/Status-Under%20Development-red)
+![alt text](https://img.shields.io/badge/Version-0.1.0-blue)
+![alt text](https://img.shields.io/badge/License-MIT-green)
+![alt text](https://img.shields.io/badge/Institution-UN%20Habitat-blue)
+
+## Description
+This project aims to map the disadvantaged areas in Beirut, Lebanon. The deployed model will be able to detect urban disadvantaged areas through HR and LR satellite imagery. The project is still under development.
+
+## Installation
+First, clone the repository using the following command:
+```bash
+git clone https://github.com/auxiliary-ai/DA_detector.git
+```
+Then, create and activate your conda environment using the following commands (refer to the miniconda documentation https://docs.anaconda.com/free/miniconda/miniconda-install/):
+```bash
+conda create -n DA_env python=3.10
+conda activate DA_env
+```
+Finally, install the required packages using the following command:
+```bash
+cd DA_detector
+pip install -r requirements.txt
+```
+Remember to replace the path to the repository with the correct path on your machine.
+
+## Usage
+To run the application, use the following command:
+```bash
+python main.py
+```
+
+## TODO
+
+- [ ] Train model on data with different resolutions.
+- [ ] Add a low resolution model. 

data/download_data.py

@@ -0,0 +1,69 @@
+import msal
+import requests
+
+# TODO: Need to purchase sharepoint license to access files. For now use below link:
+#link: https://onedrive.live.com/?id=388473CC408C5CF1%21sa863b43cc1ce49f0a092e21d2d0514e7&cid=388473CC408C5CF1
+
+'''This script demonstrates how to authenticate with Microsoft Graph API using the MSAL library and list files in a 
+specified OneDrive folder. The script uses the client credentials flow to obtain an access token for the Microsoft 
+Graph API. The access token is then used to make a request to list files in a specified folder. This can be used to 
+download files from OneDrive or perform other operations on files and folders.'''
+
+# Microsoft App credentials
+client_id = '671ad178-15a3-4c2d-ae73-3e0efa00b91f'
+client_secret = 'GfY8Q~c-IwupL_Q5qefWRKS2.F.LXVk5GSSc8chA'
+tenant_id = 'e168e317-9725-4890-a65d-05a8925848ca'
+
+# Authority URL for authentication
+authority = f"https://login.microsoftonline.com/{tenant_id}"
+
+# Initialize MSAL ConfidentialClientApplication
+app = msal.ConfidentialClientApplication(
+    client_id,
+    authority=authority,
+    client_credential=client_secret,
+)
+
+# Acquire token for Microsoft Graph API
+token_response = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
+
+# Check if token is obtained
+if 'access_token' in token_response:
+    access_token = token_response['access_token']
+    print("Access token obtained successfully.")
+else:
+    print("Failed to obtain access token.")
+    print(token_response)
+    exit()  # Exit the script if the token isn't obtained
+
+# Function to list files in a specified OneDrive folder
+def list_files(folder_id, drive_id, access_token):
+    url = f"https://graph.microsoft.com/v1.0/drives/{drive_id}/items/{folder_id}/children"
+    headers = {
+        'Authorization': f'Bearer {access_token}'
+    }
+    response = requests.get(url, headers=headers)
+
+    # Check if the request was successful
+    if response.status_code == 200:
+        files = response.json()
+        print(files)  # Inspect the structure of the response
+        return files
+    else:
+        print(f"Error: {response.status_code}")
+        print(response.text)
+        return None
+
+# Example usage:
+# From your shared link: https://onedrive.live.com/?id=388473CC408C5CF1%21sa863b43cc1ce49f0a092e21d2d0514e7&cid=388473CC408C5CF1
+drive_id = '388473CC408C5CF1'  # Extracted from the URL as the drive ID
+folder_id = 'sa863b43cc1ce49f0a092e21d2d0514e7'  # Extracted from the URL as the item ID
+
+# List files in the specified folder
+files = list_files(folder_id, drive_id, access_token)
+
+if files and 'value' in files:
+    for file in files['value']:
+        print(f"File Name: {file['name']} | File ID: {file['id']}")
+else:
+    print("No files found or 'value' key is missing in the response.")

requirements.txt

@@ -0,0 +1,12 @@
+numpy~=2.1.0
+pillow~=10.4.0
+torch
+torchvision
+scikit-learn~=1.5.1
+matplotlib~=3.8.4
+tqdm~=4.66.4
+requests~=2.32.3
+msal
+parameterized
+gradio
+imagehash

src/data_preperation.py

@@ -0,0 +1,57 @@
+from src import utils
+import numpy as np
+import os
+
+
+def main(in_dir: str, out_dir: str, size: tuple, stride: tuple, classes: list):
+    # Read all files in the in_dir
+    files = os.listdir(in_dir)
+
+    # Create the out_dir if it does not exist
+    if not os.path.exists(out_dir):
+        os.makedirs(out_dir)
+
+    dataset = []
+    # Loop through all files in the in_dir
+    for file in files:
+        # apply the sliding window method to each file
+        imgs = os.listdir(in_dir + file)
+        for img in imgs:
+            path = in_dir + file + "/" + img
+            data, _ = utils.sliding_window(path, window_size=size, stride=stride)
+
+            for x in data:
+                dataset.append((np.array(x[0]), classes.index(file)))
+
+    # Split the dataset into training, validation, and test sets
+    train, val, test = utils.split_data(dataset, 0.7, 0.1, 0.2)
+    utils.plot_distribution(
+        train, val, test, classes, title="Data Distribution Before Balancing"
+    )
+
+    # Balance the dataset
+    train, excess_data = utils.balance_data(train)
+    test += excess_data
+    utils.plot_distribution(
+        train, val, test, classes, title="Data Distribution After Balancing"
+    )
+
+    # Shuffle the data
+    train = utils.shuffle_data(train)
+    val = utils.shuffle_data(val)
+    test = utils.shuffle_data(test)
+
+    # Pickle the data
+    utils.save_to_pickle(train, out_dir + "/train.pkl")
+    utils.save_to_pickle(val, out_dir + "/val.pkl")
+    utils.save_to_pickle(test, out_dir + "/test.pkl")
+
+
+if __name__ == "__main__":
+    main(
+        in_dir="raw_data/high_res/",
+        out_dir="data/high_res/",
+        size=(224, 224),
+        stride=(224, 224),
+        classes=["formal", "informal"],
+    )

src/main.py

@@ -0,0 +1,125 @@
+import torch
+import torch.nn as nn
+from torchvision import transforms, models
+from torchvision.transforms import InterpolationMode
+from torch.utils.data import Dataset, DataLoader
+import gradio as gr
+from src import utils
+from PIL import Image
+import numpy as np
+
+
+def main(window_size: int = 224):
+    # Set the device
+    np.random.seed(0)
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("Running on {}".format(device))
+
+    def predict(inp, stride_size, threshold):
+
+        # Apply sliding window on the image
+        windows, pad_size = utils.sliding_window(
+            inp, (window_size, window_size), (stride_size, stride_size)
+        )
+
+        # Define the transformations to be applied to the images
+        transform = transforms.Compose(
+            [
+                transforms.Resize([256], interpolation=InterpolationMode.BICUBIC),
+                transforms.CenterCrop([224]),
+                transforms.ToTensor(),  # Converts the image to [0.0, 1.0] range
+                transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                ),
+            ]
+        )
+
+        # Custom dataset class
+        class CustomDataset(Dataset):
+            def __init__(self, data, transform=None):
+                self.data = data
+                self.transform = transform
+
+            def __len__(self):
+                return len(self.data)
+
+            def __getitem__(self, idx):
+                image, position = self.data[idx]
+                if self.transform:
+                    image = self.transform(image)
+                return image, position
+
+        # Create custom datasets with transformations
+        dataset = CustomDataset(windows, transform=transform)
+        dataloader = DataLoader(dataset, batch_size=128, shuffle=False)
+
+        # Load a pretrained ResNet model
+        model = models.resnet50().to(device)
+
+        # Modify the output layer directly to match binary classification
+        model.fc = nn.Sequential(
+            nn.Linear(model.fc.in_features, 128),
+            nn.ReLU(inplace=True),
+            nn.Linear(128, 1),
+        ).to(device)
+
+        # load model weights (Ensure map_location points to the correct device)
+        model.load_state_dict(
+            torch.load("./weights/resnet.pth", map_location=device, weights_only=True)
+        )
+        model = model.to(device)
+
+        model.eval()
+
+        heatmap = []
+        for data in dataloader:
+            images, positions = data
+            images = images.to(device)
+            with torch.no_grad():
+                outputs = model(images)
+                for i in range(len(outputs)):
+                    probability = torch.sigmoid(outputs[i]).item()
+                    img = Image.new(
+                        "RGB",
+                        (window_size, window_size),
+                        color=(int(255 * probability), 0, 0),
+                    )
+                    heatmap.append((img, (positions[0][i], positions[1][i])))
+
+        # overlay the heatmap on the original image
+        result, _ = utils.reconstruct_image(
+            heatmap, pad_size, (window_size, window_size)
+        )
+        prob_threshold = round(threshold * 255, 0)
+        result = result.point(
+            lambda p: p * 0 if p < prob_threshold else p
+        )  # set any pixel value less than
+        # threshold to 0
+
+        reconstructed_image, _ = utils.reconstruct_image(
+            windows, pad_size, (window_size, window_size)
+        )
+        result = Image.blend(reconstructed_image, result, alpha=0.5)
+
+        # slice the image to remove the padding
+        # result = result.crop((0, 0, inp.width, inp.height))
+
+        return result
+
+    # Gradio Interface with stride size input slider
+    demo = gr.Interface(
+        fn=predict,
+        inputs=[
+            gr.Image(type="pil"),
+            gr.Slider(minimum=32, maximum=224, step=32, label="Stride Size"),
+            gr.Slider(minimum=0.5, maximum=1.0, step=0.1, label="Threshold"),
+        ],
+        outputs=gr.Image(type="pil"),
+    )
+
+    # launch the interface in a new tab
+    demo.launch(inbrowser=True, share=True, debug=True)
+
+
+if __name__ == "__main__":
+    main()

src/resnet.py

@@ -0,0 +1,273 @@
+import torch
+from torchvision import models
+import torchvision.transforms as transforms
+from torchvision.transforms import InterpolationMode
+from torch.utils.data import Dataset, DataLoader
+import torch.nn as nn
+from sklearn.metrics import confusion_matrix
+import tqdm
+import matplotlib.pyplot as plt
+import numpy as np
+from src import utils
+
+plt.style.use("ggplot")
+plt.rcParams.update({"font.size": 14})
+plt.rcParams.update({"figure.autolayout": True})
+
+
+def main(batch_size=64, epochs=50, classes=("formal", "informal"), train: bool = True):
+    train_transform = transforms.Compose(
+        [
+            transforms.ToPILImage(),
+            transforms.RandomHorizontalFlip(p=0.5),
+            transforms.RandomVerticalFlip(p=0.5),
+            transforms.ColorJitter(
+                brightness=0.3, contrast=0.3, saturation=0.3, hue=0.1
+            ),
+            transforms.RandomRotation(
+                degrees=30, interpolation=InterpolationMode.BICUBIC
+            ),
+            transforms.RandomResizedCrop(
+                size=224, scale=(0.8, 1.0), interpolation=InterpolationMode.BICUBIC
+            ),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ]
+    )
+
+    transform = transforms.Compose(
+        [
+            transforms.ToPILImage(),
+            transforms.Resize([256], interpolation=InterpolationMode.BICUBIC),
+            transforms.CenterCrop([224]),
+            transforms.ToTensor(),  # Converts the image to [0.0, 1.0] range
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ]
+    )
+
+    # Custom dataset class
+    class CustomDataset(Dataset):
+        def __init__(self, data, transform=None):
+            self.data = data
+            self.transform = transform
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, idx):
+            image, label = self.data[idx]
+            if self.transform:
+                image = self.transform(image)
+            return image, label
+
+    # Load the data
+    train_data = utils.load_from_pickle("./data/high_res/train.pkl")
+    val_data = utils.load_from_pickle("./data/high_res/val.pkl")
+    test_data = utils.load_from_pickle("./data/high_res/test.pkl")
+
+    # process the data to keep only three channels
+    train_data = [(image[:, :, :3], label) for image, label in train_data]
+    val_data = [(image[:, :, :3], label) for image, label in val_data]
+    test_data = [(image[:, :, :3], label) for image, label in test_data]
+
+    # Create custom datasets with transformations
+    trainset = CustomDataset(train_data, transform=train_transform)
+    valset = CustomDataset(val_data, transform=transform)
+    testset = CustomDataset(test_data, transform=transform)
+
+    # Create DataLoaders
+    trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True)
+    valloader = DataLoader(valset, batch_size=batch_size, shuffle=False)
+    testloader = DataLoader(testset, batch_size=batch_size, shuffle=False)
+
+    # Set the device
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("Running on {}".format(device))
+
+    # Load a pretrained ResNet model
+    model = models.resnet50(weights="ResNet50_Weights.IMAGENET1K_V1").to(
+        device
+    )  # You can use resnet18, resnet50, etc.
+
+    # Modify the output layer directly to match binary classification
+    model.fc = nn.Sequential(
+        nn.Linear(model.fc.in_features, 128),
+        nn.ReLU(inplace=True),
+        nn.Linear(128, 1),  # 1 output unit for binary classification
+    ).to(
+        device
+    )  # Make sure the head is also on the correct device
+
+    # Print the model architecture
+    print(model)
+
+    if train:
+        # Define loss function and optimizer
+        criterion = nn.BCEWithLogitsLoss()  # Binary classification
+        optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
+        scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.25)
+
+        # Train the model
+        optimal_accuracy = 0
+        patience = 10
+
+        for epoch in tqdm.tqdm(range(epochs)):
+            model.train()
+            running_loss = 0.0
+
+            for i, data in enumerate(trainloader, 0):
+                # Move inputs and labels to the correct device
+                inputs, labels = data
+                inputs, labels = (
+                    inputs.to(device),
+                    labels.to(device).float(),
+                )  # Ensure labels are float for BCEWithLogitsLoss
+
+                # Zero the parameter gradients
+                optimizer.zero_grad()
+
+                # Forward + backward + optimize
+                outputs = model(inputs)
+                loss = criterion(
+                    outputs, labels.unsqueeze(1)
+                )  # Match output shape (N, 1)
+                loss.backward()
+                optimizer.step()
+
+                running_loss += loss.item()
+                if i % 2000 == 1999:
+                    print(f"[{epoch + 1}, {i + 1}] loss: {running_loss / 2000:.3f}")
+                    running_loss = 0.0
+
+            scheduler.step()
+
+            # Validate the model
+            model.eval()
+            correct = 0
+            total = 0
+
+            with torch.no_grad():
+                for data in valloader:
+                    images, labels = data
+                    images, labels = images.to(device), labels.to(device).float()
+                    outputs = model(images)
+                    predicted = (
+                        torch.sigmoid(outputs) > 0.5
+                    ).float()  # Apply sigmoid and threshold at 0.5
+                    total += labels.size(0)
+                    correct += (predicted == labels.unsqueeze(1)).sum().item()
+
+            accuracy = 100 * correct / total
+            print(f"Validation accuracy: {accuracy:.2f}%")
+
+            # early stopping
+            if accuracy > optimal_accuracy:
+                optimal_accuracy = accuracy
+                optimal_model = model.state_dict()
+                patience = 10
+            else:
+                patience -= 1
+
+            if patience == 0:
+                print("Early stopping")
+                break
+
+        print("Finished Training")
+
+        # Save the model
+        torch.save(optimal_model, "./weights/ResNet50.pth")
+        print("Model saved")
+
+    # Load the model and move it to the correct device
+    model.load_state_dict(
+        torch.load("./weights/ResNet50.pth", map_location=device, weights_only=True)
+    )
+    model.to(device)
+
+    # Test the model
+    model.eval()
+    correct = 0
+    total = 0
+    y_pred = []
+    y_true = []
+
+    with torch.no_grad():
+        for data in tqdm.tqdm(testloader):
+            images, labels = data
+            images, labels = images.to(device), labels.to(device).float()
+            outputs = model(images)
+            predicted = (
+                torch.sigmoid(outputs) > 0.5
+            ).float()  # Apply sigmoid and threshold at 0.5
+
+            # store predictions for CM
+            y_pred.extend(predicted.cpu().numpy())
+            y_true.extend(labels.cpu().numpy())
+
+            total += labels.size(0)
+            correct += (predicted == labels.unsqueeze(1)).sum().item()
+
+    accuracy = 100 * correct / total
+    print(f"Test accuracy: {accuracy:.2f}%")
+
+    print("Finished Testing")
+
+    # Confusion matrix
+    cm = confusion_matrix(y_true, y_pred, normalize="true")
+    plt.figure(figsize=(8, 8))
+    plt.imshow(cm, interpolation="nearest", cmap=plt.cm.Blues)
+    plt.title("Confusion Matrix")
+    plt.colorbar()
+    tick_marks = np.arange(len(classes))
+    plt.xticks(tick_marks, classes, rotation=45)
+    plt.yticks(tick_marks, classes)
+    plt.xlabel("Predicted")
+    plt.ylabel("True")
+    plt.savefig("confusion_matrix.pdf", format="pdf")
+    plt.show()
+
+    # Show test images with predicted label and actual label
+    def imshow(img, title=None):
+        """This function plots a tensor"""
+        img = img / 2 + 0.5  # unnormalize
+        npimg = img.cpu().numpy()  # convert to numpy for display
+        plt.imshow(np.transpose(npimg, (1, 2, 0)))  # reshape to (H, W, C)
+        if title is not None:
+            plt.title(title)
+        plt.show()
+
+    def show_predictions(model, dataloader, device, classes):
+        """Function to show images with predicted and actual labels."""
+        model.eval()
+
+        with torch.no_grad():
+            for i, data in enumerate(dataloader):
+                images, labels = data
+                images, labels = images.to(device), labels.to(device).float()
+
+                # Forward pass to get predictions
+                outputs = model(images)
+                outputs = outputs.squeeze(dim=1)  # Ensure shape is [batch_size]
+                predicted = (torch.sigmoid(outputs) > 0.5).float()
+
+                # Plot each image with its predicted and actual labels
+                for j in range(images.size(0)):
+                    imshow(images[j].cpu())  # Unnormalize and plot image
+
+                    # Convert predictions and labels to text (formal/informal)
+                    pred_label = classes[int(predicted[j].item())]
+                    actual_label = classes[int(labels[j].item())]
+
+                    # Display the predicted and actual labels
+                    print(f"Predicted: {pred_label}, Actual: {actual_label}")
+
+                    # Optionally, stop after displaying N images
+                    if i * len(images) + j >= 20:  # Show 5 images, adjust as needed
+                        return
+
+    # Call the function to display images along with predictions
+    # show_predictions(model, testloader, device, classes)
+
+
+if __name__ == "__main__":
+    main()

src/utils.py

@@ -0,0 +1,430 @@
+import numpy as np
+from PIL import Image, ImageOps
+import os
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+import pickle
+from collections import Counter
+import random
+
+
+class utils:
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def calculate_padding(
+        image_height: int, image_width: int, window_size: tuple, stride: tuple
+    ):
+        """
+        Calculate padding needed for height and width
+
+        :param image_height:
+        :param image_width:
+        :param window_size:
+        :param stride:
+        :return: pad_height, pad_width
+        """
+
+        # Calculate padding needed for height and width
+        if (image_height - window_size[0]) // stride[0] != (
+            image_height - window_size[0]
+        ) / stride[0]:
+            if window_size[0] == stride[0]:
+                pad_height = window_size[0] - (image_height % stride[0])
+            else:
+                pad_height = image_height - (
+                    ((image_height - window_size[0]) // stride[0]) * stride[0]
+                    + window_size[0]
+                )
+        else:
+            pad_height = 0
+        if (image_width - window_size[1]) // stride[1] != (
+            image_width - window_size[1]
+        ) / stride[1]:
+            if window_size[1] == stride[1]:
+                pad_width = window_size[1] - (image_width % stride[1])
+            else:
+                pad_width = image_width - (
+                    ((image_width - window_size[1]) // stride[1]) * stride[1]
+                    + window_size[1]
+                )
+        else:
+            pad_width = 0
+
+        return pad_height, pad_width
+
+    @staticmethod
+    def sliding_window(
+        image_dir: str, window_size: tuple, stride: tuple, padding_value: int = 0
+    ):
+        """
+        Slide a window across the image and extract patches.
+        :param image_dir: Path to the image file.
+        :param window_size: Tuple (height, width) of the window.
+        :param stride: Tuple (height, width) of the stride.
+        :param padding_value: Value to use for padding.
+
+        :return: List of tuples (window, (y, x)) and the size of the padded image.
+        """
+        # Open the image
+        if isinstance(image_dir, str):
+            image = Image.open(image_dir)
+        else:
+            image = image_dir
+        # Convert image to a numpy array
+        image_np = np.array(image)
+
+        # Get image dimensions
+        image_height, image_width = image_np.shape[:2]
+
+        # if window_size[0] > image_height or window_size[1] > image_width:
+        #     raise ValueError("Window size should be smaller than the image size.")
+        # if stride[0] > window_size[0] or stride[1] > window_size[1]:
+        #     raise ValueError("Stride should be smaller than the window size.")
+
+        # Calculate padding needed for height and width
+        pad_height, pad_width = utils.calculate_padding(
+            image_height, image_width, window_size, stride
+        )
+
+        # Pad the image using Pillow (symmetric padding)
+        padded_image = ImageOps.expand(
+            image, border=(0, 0, pad_width, pad_height), fill=padding_value
+        )
+
+        # Convert padded image back to a numpy array
+        padded_image_np = np.array(padded_image)
+
+        # Get padded image dimensions
+        padded_height, padded_width = padded_image_np.shape[:2]
+
+        # List to store cropped windows and their positions
+        windows = []
+
+        # Slide the window across the padded image
+        for y in range(0, padded_height - window_size[0] + 1, stride[0]):
+            for x in range(0, padded_width - window_size[1] + 1, stride[1]):
+                # Crop the window from the image
+                window = padded_image_np[y : y + window_size[0], x : x + window_size[1]]
+                # Append the window and its position to the list
+                windows.append((Image.fromarray(window), (y, x)))
+
+        return windows, padded_image.size  # Return windows and padded image size
+
+    @staticmethod
+    def save_windows(windows: list, out_dir: str):
+        """
+        Save the cropped windows to the output directory.
+
+        Args:
+            windows: List of tuples (window, (y, x)) from the sliding_window function.
+            out_dir: Path to the output directory.
+        """
+        # Create the output directory if it doesn't exist
+        if not os.path.exists(out_dir):
+            os.makedirs(out_dir)
+
+        # Save each window to the output directory
+        for i, (window, _) in enumerate(windows):
+            window.save(os.path.join(out_dir, f"window_{i}.png"))
+
+    @staticmethod
+    def reconstruct_image(windows: list, padded_size: tuple, window_size: tuple):
+        """
+        Reconstruct the original image from the sliding window patches. Strides are averaged.
+
+        :param windows: List of tuples (window, (y, x)) from the sliding_window function.
+        :param padded_size: Tuple (height, width) of the padded image.
+        :param window_size: Tuple (height, width) of the window.
+
+        :return: Reconstructed image and count map.
+        """
+        # Initialize an empty numpy array for the reconstructed image
+        num_channels = 4 if windows[0][0].mode == "RGBA" else 3
+        reconstructed_image = np.zeros(
+            (padded_size[1], padded_size[0], num_channels), dtype=np.float32
+        )
+
+        # Initialize an array to count the number of overlapping windows
+        count_map = np.zeros(
+            (padded_size[1], padded_size[0], num_channels), dtype=np.float32
+        )
+
+        # Place each window back into the reconstructed image
+        for window, (y, x) in windows:
+            window_np = np.array(window, dtype=np.float32)
+
+            # Add the window to the corresponding position in the reconstructed image
+            reconstructed_image[
+                y : y + window_size[1], x : x + window_size[0], :
+            ] += window_np
+
+            # Increment the count map to handle overlaps
+            count_map[y : y + window_size[1], x : x + window_size[0], :] += 1
+
+        # Divide by the count map to average overlapping areas
+        reconstructed_image = np.divide(
+            reconstructed_image, count_map, where=count_map != 0
+        )
+
+        # Clip and convert to 8-bit image
+        reconstructed_image = np.clip(reconstructed_image, 0, 255).astype(np.uint8)
+        mode = "RGBA" if num_channels == 4 else "RGB"
+        reconstructed_image = Image.fromarray(reconstructed_image, mode=mode)
+
+        return reconstructed_image, count_map
+
+    @staticmethod
+    def zip_images(directory: str, label: int):
+        """
+        This function reads images from a directory and returns them as a list of tuples (image, label).
+        :param directory: The directory containing images
+        :param label: The label to assign to all images in the directory
+        :return: List of tuples where each tuple is (image, label)
+        """
+        data = []
+
+        range_dir = os.listdir(directory)
+        for file_name in tqdm(range_dir):
+            img_path = os.path.join(directory, file_name)
+            img = Image.open(img_path).convert("RGB")  # Open image and convert to RGB
+            img_array = np.array(img)  # Convert image to a numpy array
+            data.append((img_array, label))  # Append tuple (image, label) to the list
+
+        return data
+
+    @staticmethod
+    def unzip_images(data: list, base_directory: str):
+        """
+        Unzips a list of tuples (image, label) and saves the images into directories named after their labels.
+        :param data: List of tuples (image, label)
+        :param base_directory: Base directory where the images will be saved
+        """
+        for i, (img_array, label) in enumerate(data):
+            label_directory = os.path.join(base_directory, str(label))
+
+            # Create the label directory if it doesn't exist
+            if not os.path.exists(label_directory):
+                os.makedirs(label_directory)
+
+            # Define the image path (e.g., "label_directory/image_0.png")
+            img_path = os.path.join(label_directory, f"image_{i}.png")
+
+            # Convert the numpy array back to an image and save it
+            img = Image.fromarray(img_array)
+            img.save(img_path)
+
+    @staticmethod
+    def plot_image(image: np.array, title: str = None):
+        """
+        This function plots an image using matplotlib.
+        :param image: Numpy array representing the image.
+        :param title: Title of the plot.
+        :return: None
+        """
+        plt.imshow(image)
+        plt.axis("off")
+        if title:
+            plt.title(title)
+        plt.show()
+
+    @staticmethod
+    def plot_images(images: list, titles: list):
+        """
+        This function plots multiple images side by side.
+        :param images: List of numpy arrays representing the images.
+        :param titles: List of titles for each image.
+        :return: None
+        """
+        fig, axes = plt.subplots(1, len(images), figsize=(20, 20))
+        for i, (image, title) in enumerate(zip(images, titles)):
+            axes[i].imshow(image)
+            axes[i].axis("off")
+            axes[i].set_title(title)
+        plt.show()
+
+    @staticmethod
+    def split_data(
+        data,
+        train_size: float,
+        val_size: float,
+        test_size: float,
+        random_state: int = None,
+    ):
+        """
+        This function splits the dataset into training, validation, and test sets.
+
+        :param data: List of tuples where each tuple is (image, label)
+        :param train_size: Proportion of the dataset to include in the training set
+        :param val_size: Proportion of the dataset to include in the validation set
+        :param test_size: Proportion of the dataset to include in the test set
+        :param random_state: Controls the shuffling applied to the data before applying the split
+        :return: Tuple of (train_data, val_data, test_data) where each is a list of (image, label)
+        """
+        # Ensure the split sizes add up to 1
+        assert np.isclose(
+            train_size + val_size + test_size, 1.0
+        ), "Split sizes must add up to 1"
+
+        # First split: Train + (Val + Test)
+        train_data, temp_data = train_test_split(
+            data, train_size=train_size, random_state=random_state
+        )
+
+        # Second split: Val + Test
+        val_ratio = val_size / (
+            val_size + test_size
+        )  # Adjust val_size to be relative to the size of temp_data
+        val_data, test_data = train_test_split(
+            temp_data, train_size=val_ratio, random_state=random_state
+        )
+
+        return train_data, val_data, test_data
+
+    @staticmethod
+    def save_to_pickle(data: list, file_path: str):
+        """
+        This function saves data to a pickle file.
+        :param data: Data to save.
+        :param file_path: Path to save the pickle file.
+        :return: None
+        """
+        with open(file_path, "wb") as f:
+            pickle.dump(data, f)
+
+    @staticmethod
+    def load_from_pickle(file_path: str):
+        """
+        This function loads data from a pickle file.
+        :param file_path: Path to the pickle file.
+        :return: Loaded data.
+        """
+        with open(file_path, "rb") as f:
+            return pickle.load(f)
+
+    @staticmethod
+    def plot_distribution(
+        train_data,
+        val_data,
+        test_data,
+        class_names,
+        title: str = "Split Data Distribution",
+    ):
+        """
+        Plots the distribution of data after splitting into training, validation, and test sets.
+        :param train_data: List of tuples (image, label) for the training set
+        :param val_data: List of tuples (image, label) for the validation set
+        :param test_data: List of tuples (image, label) for the test set
+        :param class_names: List of class names corresponding to the label
+        :param title: Title of the plot
+        :return: None
+        """
+        # Count the number of samples for each label in each dataset
+        train_labels = [label for _, label in train_data]
+        val_labels = [label for _, label in val_data]
+        test_labels = [label for _, label in test_data]
+
+        train_counter = Counter(train_labels)
+        val_counter = Counter(val_labels)
+        test_counter = Counter(test_labels)
+
+        # Prepare the data for plotting
+        labels = sorted(set(train_labels + val_labels + test_labels))
+        train_counts = [train_counter[label] for label in labels]
+        val_counts = [val_counter[label] for label in labels]
+        test_counts = [test_counter[label] for label in labels]
+
+        # Plot the distribution
+        x = range(len(labels))
+        width = 0.25  # Width of the bars
+
+        plt.figure(figsize=(10, 6))
+
+        plt.bar(
+            x, train_counts, width=width, label="Train", color="blue", align="center"
+        )
+        plt.bar(
+            [p + width for p in x],
+            val_counts,
+            width=width,
+            label="Validation",
+            color="orange",
+            align="center",
+        )
+        plt.bar(
+            [p + width * 2 for p in x],
+            test_counts,
+            width=width,
+            label="Test",
+            color="green",
+            align="center",
+        )
+
+        plt.xlabel("Classes")
+        plt.ylabel("Number of Samples")
+        plt.title(title)
+        plt.xticks([p + width for p in x], [class_names[label] for label in labels])
+        plt.legend()
+        plt.show()
+
+    @staticmethod
+    def balance_data(train_data: list, random_state=None):
+        """
+        This function balances the data by randomly selecting samples from the majority class to match the number of
+        samples in the minority class.
+        :param train_data: List of tuples (image, label)
+        :param random_state: int, random seed for reproducibility
+        :return: List of tuples (image, label)
+        with balanced classes and a list of tuples (image, label) with the excess data
+        """
+
+        # get all labels from the train data
+        labels = [sample[1] for sample in train_data]
+
+        # count the number of samples for each label
+        counter = Counter(labels)
+
+        # find the label with the fewest samples
+        min_samples = min(counter.values())
+
+        # create a list to store the balanced data
+        balanced_data = []
+
+        # create a list to store the excess data
+        excess_data = []
+
+        # get how many classes we have
+        num_classes = len(set(labels))
+
+        # for each class
+        for i in range(num_classes):
+            # get all the samples for that class
+            samples = [sample for sample in train_data if sample[1] == i]
+
+            # shuffle the samples
+            random.seed(random_state)
+
+            random.shuffle(samples)
+
+            # add the first min_samples samples to the balanced data
+            balanced_data += samples[:min_samples]
+
+            # add the remaining samples to the excess data
+            excess_data += samples[min_samples:]
+
+        return balanced_data, excess_data
+
+    @staticmethod
+    def shuffle_data(data: list, random_state=None):
+        """
+        This function shuffles the data.
+        :param data: List of tuples (image, label)
+        :param random_state: int, random seed for reproducibility
+        :return: List of tuples (image, label) with shuffled data
+        """
+        random.seed(random_state)
+        random.shuffle(data)
+        return data

tests/test_reconstruct_image.py

@@ -0,0 +1,152 @@
+from src.utils import utils
+import unittest
+from PIL import Image, ImageOps, ImageDraw
+import imagehash
+import numpy as np
+import os
+import random
+from parameterized import parameterized
+
+
+class TestReconstructImageFunction(unittest.TestCase):
+    """
+    Unit tests for the reconstruct image function from the utils module.
+    The test compares original images with reconstructed images
+    Stride can't be larger than image size or else there'll be loss of information
+    """
+
+    def setUp(self):
+        """Prepare the test images and their paths before each test."""
+        self.prepare_test_images()
+
+    def tearDown(self):
+        """Clean up the test images after each test."""
+        self.clean_up_images()
+
+    @staticmethod
+    def create_random_test_image(width, height):
+        """
+           Create a complex image with various shapes and colors, randomly generated.
+
+           Args:
+               width: defining the width of the image.
+               height: defining the height of the image.
+
+           Returns:
+               A PIL Image object.
+        """
+        size = (width, height)
+        # Create a white image
+        image = Image.new('RGB', size, color='white')
+        draw = ImageDraw.Draw(image)
+
+        # Randomly generate shape parameters
+        num_shapes = random.randint(5, 10)
+        shape_colors = [random.choice(['red', 'blue', 'green', 'yellow', 'purple', 'cyan']) for _ in range(num_shapes)]
+        # shape_coords = [(random.randint(0, size[0]), random.randint(0, size[1]), random.randint(0, size[0]),
+        # random.randint(0, size[1])) for _ in range(num_shapes)]
+        shape_coords = []
+        shape_types = [random.choice(['rectangle', 'ellipse', 'line', 'polygon']) for _ in range(num_shapes)]
+        # Generate valid coordinates for shapes
+        for _ in range(num_shapes):
+            x0, y0 = random.randint(0, size[0]), random.randint(0, size[1])
+            x1, y1 = random.randint(x0, size[0]), random.randint(y0, size[1])
+            shape_coords.append((x0, y0, x1, y1))
+        # Draw random shapes
+        for i in range(num_shapes):
+            if shape_types[i] == 'rectangle':
+                draw.rectangle(shape_coords[i], outline=shape_colors[i],
+                               fill=random.choice(['red', 'blue', 'green', 'yellow', 'purple', 'cyan']))
+            elif shape_types[i] == 'ellipse':
+                draw.ellipse(shape_coords[i], outline=shape_colors[i],
+                             fill=random.choice(['red', 'blue', 'green', 'yellow', 'purple', 'cyan']))
+            elif shape_types[i] == 'line':
+                draw.line([shape_coords[i][0], shape_coords[i][1], shape_coords[i][2], shape_coords[i][3]],
+                          fill=shape_colors[i], width=random.randint(1, 5))
+            elif shape_types[i] == 'polygon':
+                draw.polygon([shape_coords[i][0], shape_coords[i][1], shape_coords[i][2], shape_coords[i][3]],
+                             outline=shape_colors[i],
+                             fill=random.choice(['red', 'blue', 'green', 'yellow', 'purple', 'cyan']))
+
+        # Add random text
+        draw.text((random.randint(0, size[0]), random.randint(0, size[1])),
+                  random.choice(['Sample Image', 'Random Art', 'Generated Artwork']),
+                  fill=random.choice(['black', 'white']))
+
+        return image
+
+    def prepare_test_images(self):
+        """
+        Create and save test images of various sizes for testing.
+        """
+        self.test_images = {
+            'image_1x1': self.create_random_test_image(1, 1),
+            'image_10x10': self.create_random_test_image(10, 10),
+            'image_11x11': self.create_random_test_image(11, 11),
+            'image_7x5': self.create_random_test_image(7, 5),
+            'image_15x15': self.create_random_test_image(15, 15),
+            'image_512x512': self.create_random_test_image(512, 512),
+            'image_1024x1024': self.create_random_test_image(1024, 1024),
+            'image_2048x2048': self.create_random_test_image(2048, 2048),
+        }
+
+        self.image_dirs = {}
+        for name, img in self.test_images.items():
+            img_dir = f'{name}.png'
+            img.save(img_dir)
+            self.image_dirs[name] = img_dir
+
+    def clean_up_images(self):
+        """
+        Remove the image files created for testing.
+        """
+        for img_dir in self.image_dirs.values():
+            if os.path.exists(img_dir):
+                os.remove(img_dir)
+
+    @staticmethod
+    def compare_images(original_image, reconstructed_image):
+        # reconstructed_image = Image.open(reconstructed_image_dir)
+        hash0 = imagehash.average_hash(original_image)
+        hash1 = imagehash.average_hash(reconstructed_image)
+        hashDiff = hash0 - hash1  # Finds the distance between the hashes of images
+        if abs(hashDiff) < 10e-10:  # added a tolerance of 10e-10
+            return "Identical"
+        else:
+            return "Non Identical"
+
+    @parameterized.expand([
+        # Parameters: (image_name, window_size, stride)
+        ('image_11x11', (3, 3), (3, 3)),
+        ('image_1x1', (1, 1), (1, 1)),
+        ('image_10x10', (3, 3), (3, 3)),
+        ('image_7x5', (3, 3), (2, 2)),
+        ('image_15x15', (5, 5), (5, 5)),
+        ('image_10x10', (10, 10), (1, 1)),  # Large window
+        ('image_15x15', (7, 7), (5, 5)),  # Window larger but within bounds
+        ('image_10x10', (3, 3), (3, 3)),  # Stride equal to window size
+        ('image_10x10', (3, 3), (2, 2)),  # Stride smaller than window size
+        ('image_7x5', (2, 2), (1, 1)),  # Small stride
+        ('image_15x15', (3, 3), (3, 3)),  # Regular case
+        ('image_512x512', (50, 50), (50, 50)),
+        ('image_1024x1024', (100, 100), (100, 100)),
+        ('image_2048x2048', (200, 200), (200, 200)),
+    ])
+    def test_images(self, image_name, window_size, stride):
+
+        image_dir = self.image_dirs[image_name]
+        windows, padded_size = utils.sliding_window(image_dir, window_size, stride)
+        reconstructed_image, count_map = utils.reconstruct_image(windows, padded_size, window_size)
+
+        #Add padding to original image
+        original_image = Image.open(image_dir)
+        image_np = np.array(original_image)
+        image_height, image_width = image_np.shape[:2]
+        pad_height, pad_width = utils.calculate_padding(image_height, image_width, window_size, stride)
+        original_image = ImageOps.expand(original_image, border=(0, 0, pad_width, pad_height), fill=0)
+        comparison = self.compare_images(original_image, reconstructed_image)
+        self.assertEqual(comparison, "Identical")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_sliding_window.py

@@ -0,0 +1,186 @@
+from src.utils import utils
+import unittest
+from PIL import Image
+import numpy as np
+import os
+from parameterized import parameterized
+
+
+# TODO: remove test cases where stride>window & window>image
+class TestSlidingWindowFunction(unittest.TestCase):
+    """
+    Unit tests for the sliding window function from the utils module.
+    The test does not dummy-proof the function:
+    windows_size <= 0, strides <=0, image_size = 0, invalid image format, invalid image path, etc.
+    were not taken into consideration in this test.
+    Window size can't be larger than image size
+    Stride can't be larger than window size
+    """
+
+    def setUp(self):
+        """Prepare the test images and their paths before each test."""
+        self.prepare_test_images()
+
+    def tearDown(self):
+        """Clean up the test images after each test."""
+        self.clean_up_images()
+
+    @staticmethod
+    def create_test_image(width, height):
+        """
+        Helper function to create a test image with pixel values increasing row-wise.
+
+        Args:
+            width (int): The width of the image.
+            height (int): The height of the image.
+
+        Returns:
+            Image: A PIL Image object.
+        """
+        return Image.fromarray(np.arange(width * height).reshape(height, width).astype(np.uint8))
+
+    def prepare_test_images(self):
+        """
+        Create and save test images of various sizes for testing.
+        """
+        self.test_images = {
+            'image_1x1': self.create_test_image(1, 1),
+            'image_10x10': self.create_test_image(10, 10),
+            'image_11x11': self.create_test_image(11, 11),
+            'image_7x5': self.create_test_image(7, 5),
+            'image_15x15': self.create_test_image(15, 15),
+            'image_512x512': self.create_test_image(512, 512),
+            'image_1024x1024': self.create_test_image(1024, 1024),
+            'image_2048x2048': self.create_test_image(2048, 2048),
+        }
+
+        self.image_dirs = {}
+        for name, img in self.test_images.items():
+            img_dir = f'{name}.png'
+            img.save(img_dir)
+            self.image_dirs[name] = img_dir
+
+    def clean_up_images(self):
+        """
+        Remove the image files created for testing.
+        """
+        for img_dir in self.image_dirs.values():
+            if os.path.exists(img_dir):
+                os.remove(img_dir)
+
+    @staticmethod
+    def calculate_expected_number_of_windows(padded_size: tuple, window_size: tuple, stride: tuple):
+        """
+        Calculate the expected number of windows that can be extracted from a padded image.
+
+        Args:
+            padded_size (tuple): The size of the padded image (height, width).
+            window_size (tuple): The size of the sliding window (height, width).
+            stride (tuple): The stride of the sliding window (height, width).
+
+        Returns:
+            int: The number of windows that can be extracted.
+        """
+        number_of_positions_height = (padded_size[0] - window_size[0]) // stride[0] + 1
+        number_of_positions_width = (padded_size[1] - window_size[1]) // stride[1] + 1
+        return number_of_positions_height * number_of_positions_width
+
+    @staticmethod
+    def calculate_expected_padding(image_dir: str, window_size: tuple, stride: tuple):
+        """
+        Calculate the expected dimensions of the padded image based on the stride.
+
+        Args:
+            image_dir (str): The path to the image file.
+            window_size (tuple): The size of the sliding window (height, width).
+            stride (tuple): The stride of the sliding window (height, width).
+        Returns:
+            tuple: The expected padded size (height, width).
+        """
+        with (Image.open(image_dir) as image):
+            image_np = np.array(image)
+            image_height, image_width = image_np.shape[:2]
+            expected_padded_height, expected_padded_width = utils.calculate_padding(image_height, image_width,
+                                                                                    window_size, stride)
+
+            return image_height + expected_padded_height, image_width + expected_padded_width
+
+    @parameterized.expand([
+        # Parameters: (image_name, window_size, stride)
+        ('image_11x11', (3, 3), (3, 3)),
+        ('image_1x1', (1, 1), (1, 1)),
+        ('image_10x10', (3, 3), (3, 3)),
+        ('image_7x5', (3, 3), (2, 2)),
+        ('image_15x15', (5, 5), (5, 5)),
+        ('image_10x10', (1, 1), (3, 3)),  # Small window
+        ('image_10x10', (10, 10), (1, 1)),  # Large window
+        ('image_7x5', (8, 8), (2, 2)),  # Window larger than image
+        ('image_15x15', (7, 7), (5, 5)),  # Window larger but within bounds
+        ('image_10x10', (3, 3), (3, 3)),  # Stride equal to window size
+        ('image_10x10', (3, 3), (4, 4)),  # Stride larger than window size
+        ('image_10x10', (3, 3), (2, 2)),  # Stride smaller than window size
+        ('image_7x5', (2, 2), (1, 1)),  # Small stride
+        ('image_7x5', (1, 1), (2, 2)),  # Small window on larger image
+        ('image_10x10', (1, 1), (5, 5)),  # Large stride, small window
+        ('image_15x15', (3, 3), (3, 3)),  # Regular case
+        ('image_10x10', (3, 3), (10, 10)),  # Stride equals image size
+        ('image_512x512', (50, 50), (50, 50)),
+        ('image_1024x1024', (100, 100), (100, 100)),
+        ('image_2048x2048', (200, 200), (200, 200)),
+    ])
+    def test_padded_size(self, image_name, window_size, stride):
+        """
+        Test that the image is correctly padded to the expected size.
+
+        Args:
+            image_name (str): The name of the test image.
+            window_size (tuple): The size of the sliding window (height, width).
+            stride (tuple): The stride of the sliding window (height, width).
+        """
+        image_dir = self.image_dirs[image_name]
+        windows, padded_size = utils.sliding_window(image_dir, window_size, stride)
+        expected_padded_height, expected_padded_width = self.calculate_expected_padding(image_dir, window_size, stride)
+        self.assertEqual(padded_size, (expected_padded_width, expected_padded_height))
+
+    @parameterized.expand([
+        # Parameters: (image_name, window_size, stride)
+        ('image_512x512', (500, 500), (50, 50)),
+        ('image_1x1', (1, 1), (1, 1)),
+        ('image_1x1', (2, 2), (1, 1)),
+        ('image_10x10', (3, 3), (3, 3)),
+        ('image_11x11', (3, 3), (3, 3)),
+        ('image_7x5', (3, 3), (2, 2)),
+        ('image_15x15', (5, 5), (5, 5)),
+        ('image_10x10', (1, 1), (3, 3)),  # Small window
+        ('image_10x10', (10, 10), (1, 1)),  # Large window
+        ('image_7x5', (8, 8), (2, 2)),  # Window larger than image
+        ('image_15x15', (7, 7), (5, 5)),  # Window larger but within bounds
+        ('image_10x10', (3, 3), (3, 3)),  # Stride equal to window size
+        ('image_10x10', (3, 3), (4, 4)),  # Stride larger than window size
+        ('image_10x10', (3, 3), (2, 2)),  # Stride smaller than window size
+        ('image_7x5', (2, 2), (1, 1)),  # Small stride
+        ('image_7x5', (1, 1), (2, 2)),  # Small window on larger image
+        ('image_10x10', (1, 1), (5, 5)),  # Large stride, small window
+        ('image_15x15', (3, 3), (3, 3)),  # Regular case
+        ('image_10x10', (3, 3), (10, 10)),  # Stride equals image size
+        ('image_512x512', (50, 50), (50, 50)),
+        ('image_1024x1024', (100, 100), (100, 100)),
+        ('image_2048x2048', (200, 200), (200, 200)),
+    ])
+    def test_number_of_windows(self, image_name, window_size, stride):
+        """
+        Test that the number of windows generated matches the expected count.
+
+        Args:
+            image_name (str): The name of the test image.
+            window_size (tuple): The size of the sliding window (height, width).
+            stride (tuple): The stride of the sliding window (height, width).
+        """
+        image_dir = self.image_dirs[image_name]
+        windows, padded_size = utils.sliding_window(image_dir, window_size, stride)
+        expected_number_of_windows = self.calculate_expected_number_of_windows(padded_size, window_size, stride)
+        self.assertEqual(len(windows), expected_number_of_windows)
+
+
+if __name__ == '__main__':
+    unittest.main()

weights/download_weights.py

@@ -0,0 +1,4 @@
+"""
+This script downloads the weights of the ResNet model from the following link:
+"""
+# TODO: Add the link to the weights