Upload 4 files

app.py

@@ -0,0 +1,48 @@
+import gradio as gr
+import torch
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+from arch import SegFormerUNet
+from albumentations import Compose, Resize, Normalize
+from albumentations.pytorch import ToTensorV2
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = SegFormerUNet().to(device)
+checkpoint_path = "model/segformer_unet_focal_loss_97_63.pth"
+checkpoint = torch.load(checkpoint_path, map_location=device)
+model.load_state_dict(checkpoint)
+model.eval()
+print("Model weights loaded successfully!")
+
+# Image Transformation
+transform = Compose([
+    Resize(256, 256),
+    Normalize(mean=[0.5], std=[0.5]),
+    ToTensorV2()
+])
+
+def process_image(image):
+    """Process uploaded image, perform segmentation, and compute energy output."""
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    transformed = transform(image=image)['image'].unsqueeze(0).to(device)
+    
+    with torch.no_grad():
+        output = model(transformed)
+        pred_mask = torch.sigmoid(output).squeeze().cpu().numpy()
+        pred_mask = (pred_mask > 0.5).astype(np.uint8)
+    
+    area_m2 = np.sum(pred_mask) * (0.125 ** 2)
+    energy_kwh = area_m2 * 0.19 * 1676.2 * 0.935 / 1000
+    
+    return pred_mask * 255, f"Estimated Solar Panel Area: {area_m2:.2f} m²", f"Estimated Energy Output: {energy_kwh:.2f} MWh per year"
+
+demo = gr.Interface(
+    fn=process_image,
+    inputs=gr.Image(type="numpy"),
+    outputs=[gr.Image(type="numpy"), gr.Text(), gr.Text()],
+    title="Solar Panel Segmentation",
+    description="Upload an image to detect solar panels and estimate energy output.",
+)
+
+demo.launch()

arch.py

@@ -0,0 +1,39 @@
+import torch
+import torch.nn as nn
+from transformers import SegformerForSemanticSegmentation
+
+class SegFormerUNet(nn.Module):
+    def __init__(self, model_name="nvidia/segformer-b2-finetuned-ade-512-512", num_classes=1):
+        super(SegFormerUNet, self).__init__()
+
+        # Load Pretrained SegFormer
+        self.segformer = SegformerForSemanticSegmentation.from_pretrained(model_name)
+
+        # Extract Encoder
+        self.encoder = self.segformer.segformer.encoder  # Correct way to get encoder
+
+        # U-Net Style Decoder (Upsampling to match input size)
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose2d(512, 256, kernel_size=2, stride=2),  # 16x16 -> 32x32
+            nn.ReLU(),
+            nn.ConvTranspose2d(256, 128, kernel_size=2, stride=2),  # 32x32 -> 64x64
+            nn.ReLU(),
+            nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2),   # 64x64 -> 128x128
+            nn.ReLU(),
+            nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2),    # 128x128 -> 256x256
+            nn.ReLU(),
+            nn.ConvTranspose2d(32, num_classes, kernel_size=2, stride=2)  # 256x256 -> 512x512
+        )
+
+    def forward(self, x):
+        retained_input = x  # Keep input image
+
+        # Encoder processing
+        encoder_output = self.encoder(x)  # Extract encoder features
+        encoder_output = encoder_output.last_hidden_state.permute(0, 1, 2, 3)  # (B, C, H, W)
+        # print("Encoder Output Shape:", encoder_output.shape)  # Should be (B, 512, 16, 16)
+
+        # Decoder (Upsample back to input size)
+        output = self.decoder(encoder_output)  # (B, num_classes, 512, 512)
+
+        return output  # return segmentation mask

full_inference.py

@@ -0,0 +1,190 @@
+from arch import SegFormerUNet
+import torch
+import torch.nn as nn
+import numpy as np 
+import cv2
+import matplotlib.pyplot as plt
+import os
+import cv2
+import torch
+from torch.utils.data import Dataset, DataLoader
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+# Define Transformations
+# transform = A.Compose([
+#     A.Resize(256, 256),  # Resize to SegFormer input size
+#     A.HorizontalFlip(p=0.5),
+#     A.RandomBrightnessContrast(p=0.2),
+#     A.Normalize(mean=[0.5], std=[0.5]),
+#     ToTensorV2()
+# ])
+transform = A.Compose([
+    A.Resize(256, 256),  # Resize to SegFormer input size
+    A.HorizontalFlip(p=0.5),  # Randomly flip horizontally
+    A.VerticalFlip(p=0.2),  # Randomly flip vertically
+    A.RandomBrightnessContrast(p=0.2),  # Adjust brightness and contrast
+    A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=20, p=0.5),  # Small shifts, scaling, rotation
+    A.GaussianBlur(blur_limit=(3, 5), p=0.2),  # Slight blurring for robustness
+    # A.GaussNoise(var_limit=(10.0, 50.0), p=0.3),  # Add slight Gaussian noise
+    A.GridDistortion(num_steps=5, distort_limit=0.3, p=0.2),  # Slight grid distortion
+    A.Normalize(mean=[0.5], std=[0.5]),  # Normalize
+    ToTensorV2()  # Convert to tensor
+])
+
+# Custom Dataset Class
+class SolarPanelDataset(Dataset):
+    def __init__(self, image_dir, mask_dir, transform=None):
+        self.image_dir = image_dir
+        self.mask_dir = mask_dir
+        self.transform = transform
+        self.images = sorted(os.listdir(image_dir))
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        img_path = os.path.join(self.image_dir, self.images[idx])
+        mask_path = os.path.join(self.mask_dir, self.images[idx].replace(".bmp", "_label.bmp"))
+
+        # Load Image & Mask
+        image = cv2.imread(img_path)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE)
+        mask = (mask > 0).astype("uint8")  # Convert to binary mask
+        # Apply Transformations
+        if self.transform:
+            augmented = self.transform(image=image, mask=mask)
+            image = augmented["image"]
+            mask = augmented["mask"]
+
+        return image, mask.unsqueeze(0)  # Add channel dimension
+
+# Load Dataset
+val_dataset = SolarPanelDataset("dataset/val/images", "dataset/val/labels", transform=transform)
+
+def compute_solar_area(mask, PTM=0.125, OPTA=34):
+    """
+    Compute solar panel area from a binary segmentation mask.
+    """
+    if isinstance(mask, torch.Tensor):
+        mask = mask.cpu().detach().numpy()  # Convert to NumPy if Tensor
+    if mask.ndim == 3:
+        mask = mask.squeeze(0)  # Remove extra channel
+
+    mask = (mask > 0.5).astype(np.float32)  # Ensure binary mask
+    panel_pixels = mask.sum()  # Count solar panel pixels
+    area_m2 = (panel_pixels * (PTM ** 2)) / np.cos(np.radians(OPTA))  # Convert to m²
+    return area_m2
+
+def compute_accuracy_metrics(segmented_mask, actual_mask, PTM=0.125):
+    """
+    Compute accuracy of segmented area vs. actual area using MAPE and IoU.
+    """
+    # Compute solar panel areas
+    segmented_area = compute_solar_area(segmented_mask, PTM)
+    actual_area = compute_solar_area(actual_mask, PTM)
+
+    # Compute Mean Absolute Percentage Error (MAPE)
+    mape_error = np.abs((segmented_area - actual_area) / actual_area) * 100 if actual_area != 0 else 0
+
+    # Compute Intersection over Union (IoU)
+    intersection = ((segmented_mask > 0.5) & (actual_mask > 0.5)).sum()
+    union = ((segmented_mask > 0.5) | (actual_mask > 0.5)).sum()
+    iou_score = intersection / union if union != 0 else 0
+
+    return {
+        "Segmented Area (m²)": segmented_area,
+        "Actual Area (m²)": actual_area,
+        "MAPE (%)": mape_error,
+        "IoU Score": iou_score
+    }
+
+
+def compute_energy_output(area_m2, efficiency=0.19, GTI=1676.2, PR=0.935):
+    """
+    Compute estimated solar energy output.
+    """
+    return area_m2 * efficiency * GTI * PR
+
+def Calculate_solar_energy(val_dataset, model, idx=0):
+    model.eval()
+
+    # Load image and mask from validation set
+    image, mask = val_dataset[idx]
+    orig_image = np.moveaxis(image.numpy(), 0, -1)  # Convert from (C, H, W) to (H, W, C)
+
+    # Move image to GPU
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    image = image.unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        output = model(image)  # Get raw logits
+        pred_mask = torch.sigmoid(output).squeeze().cpu().numpy()  # Convert logits to probabilities
+        pred_mask = (pred_mask > 0.5).astype(np.uint8)  # Convert to binary mask
+
+    # Resize ground truth mask for plotting
+    mask = mask.squeeze().numpy()
+
+    difference = np.sum(mask != pred_mask)
+    print(f"Number of different pixels: {difference}")
+
+    print("-"*20)
+    # Compute area in m²
+    area_m2 = compute_solar_area(mask)
+    print("ORIGINAL MASK ENERGY OUTPUT")
+    print(f"Estimated Solar Panel Area: {area_m2:.2f} m²")
+
+    # Compute energy output in kWh
+    energy_kwh = compute_energy_output(area_m2)
+    print(f"Estimated Energy Output: {(energy_kwh/1000):.2f} MWh per year")
+    print("-"*20)
+
+    print("-"*20)
+    # Compute area in m²
+    area_m2 = compute_solar_area(pred_mask)
+    print("PREDICTED MASK ENERGY OUTPUT")
+    print(f"Estimated Solar Panel Area: {area_m2:.2f} m²")
+
+    # Compute energy output in kWh
+    energy_kwh = compute_energy_output(area_m2)
+    print(f"Estimated Energy Output: {(energy_kwh/1000):.2f} MWh per year")
+    print("-"*20)
+
+    # Plot the results
+    plt.figure(figsize=(15, 5))
+
+    plt.subplot(1, 3, 1)
+    plt.imshow(orig_image)
+    plt.title("Original Image")
+    plt.axis("off")
+
+    plt.subplot(1, 3, 2)
+    plt.imshow(mask, cmap="gray")
+    plt.title("Ground Truth Mask")
+    plt.axis("off")
+
+    plt.subplot(1, 3, 3)
+    plt.imshow(pred_mask, cmap="gray")
+    plt.title("Predicted Mask")
+    plt.axis("off")
+
+    plt.show()
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# sample_input = torch.randn(1, 3, 512, 512).to(device)
+model = SegFormerUNet().to(device)
+model.eval()
+checkpoint_path = "model/segformer_unet_focal_loss_97_63.pth"
+checkpoint = torch.load(checkpoint_path, map_location=device)
+
+# Load model state dict
+model.load_state_dict(checkpoint)
+
+print("Model weights loaded successfully!")
+
+# with torch.no_grad():
+#     output = model(sample_input)
+
+# Run visualization for a random validation sample
+Calculate_solar_energy(val_dataset, model, idx=21)

requirements.txt

@@ -0,0 +1,147 @@
+aiofiles==23.2.1
+albucore==0.0.23
+albumentations==2.0.5
+annotated-types==0.7.0
+anyio==4.8.0
+apturl==0.5.2
+bcrypt==3.2.0
+blinker==1.4
+Brlapi==0.8.3
+certifi==2020.6.20
+chardet==4.0.0
+click==8.0.3
+colorama==0.4.4
+command-not-found==0.3
+contourpy==1.3.1
+cryptography==3.4.8
+cupshelpers==1.0
+cycler==0.12.1
+dbus-python==1.2.18
+defer==1.0.6
+distro==1.7.0
+distro-info==1.1+ubuntu0.2
+duplicity==0.8.21
+exceptiongroup==1.2.2
+fastapi==0.115.11
+fasteners==0.14.1
+ffmpy==0.5.0
+filelock==3.18.0
+fonttools==4.56.0
+fsspec==2025.3.0
+future==0.18.2
+gradio==5.21.0
+gradio_client==1.7.2
+groovy==0.1.2
+gyp==0.1
+h11==0.14.0
+httpcore==1.0.7
+httplib2==0.20.2
+httpx==0.28.1
+huggingface-hub==0.29.3
+idna==3.3
+importlib-metadata==4.6.4
+jeepney==0.7.1
+Jinja2==3.1.6
+keyring==23.5.0
+kiwisolver==1.4.8
+language-selector==0.1
+launchpadlib==1.10.16
+lazr.restfulclient==0.14.4
+lazr.uri==1.0.6
+lockfile==0.12.2
+louis==3.20.0
+macaroonbakery==1.3.1
+Mako==1.1.3
+markdown-it-py==3.0.0
+MarkupSafe==2.0.1
+matplotlib==3.10.1
+mdurl==0.1.2
+monotonic==1.6
+more-itertools==8.10.0
+mpmath==1.3.0
+netifaces==0.11.0
+networkx==3.4.2
+numpy==2.2.3
+nvidia-cublas-cu12==12.4.5.8
+nvidia-cuda-cupti-cu12==12.4.127
+nvidia-cuda-nvrtc-cu12==12.4.127
+nvidia-cuda-runtime-cu12==12.4.127
+nvidia-cudnn-cu12==9.1.0.70
+nvidia-cufft-cu12==11.2.1.3
+nvidia-curand-cu12==10.3.5.147
+nvidia-cusolver-cu12==11.6.1.9
+nvidia-cusparse-cu12==12.3.1.170
+nvidia-cusparselt-cu12==0.6.2
+nvidia-nccl-cu12==2.21.5
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu12==12.4.127
+oauthlib==3.2.0
+olefile==0.46
+opencv-python==4.11.0.86
+opencv-python-headless==4.11.0.86
+orjson==3.10.15
+packaging==24.2
+pandas==2.2.3
+paramiko==2.9.3
+pexpect==4.8.0
+Pillow==9.0.1
+protobuf==3.12.4
+ptyprocess==0.7.0
+pycairo==1.20.1
+pycups==2.0.1
+pydantic==2.10.6
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.19.1
+PyGObject==3.42.1
+PyJWT==2.3.0
+pymacaroons==0.13.0
+PyNaCl==1.5.0
+pyparsing==2.4.7
+pyRFC3339==1.1
+python-apt==2.4.0+ubuntu4
+python-dateutil==2.9.0.post0
+python-debian==0.1.43+ubuntu1.1
+python-multipart==0.0.20
+pytz==2022.1
+pyxdg==0.27
+PyYAML==5.4.1
+regex==2024.11.6
+reportlab==3.6.8
+requests==2.25.1
+rich==13.9.4
+ruff==0.11.0
+safehttpx==0.1.6
+safetensors==0.5.3
+scipy==1.15.2
+SecretStorage==3.3.1
+semantic-version==2.10.0
+shellingham==1.5.4
+simsimd==6.2.1
+six==1.16.0
+sniffio==1.3.1
+starlette==0.46.1
+stringzilla==3.12.3
+sympy==1.13.1
+systemd-python==234
+tokenizers==0.21.1
+tomlkit==0.13.2
+torch==2.6.0
+tqdm==4.67.1
+transformers==4.49.0
+triton==3.2.0
+typer==0.15.2
+typing_extensions==4.12.2
+tzdata==2025.1
+ubuntu-drivers-common==0.0.0
+ubuntu-pro-client==8001
+ufw==0.36.1
+unattended-upgrades==0.1
+urllib3==1.26.5
+usb-creator==0.3.7
+uvicorn==0.34.0
+wadllib==1.3.6
+websockets==15.0.1
+xdg==5
+xkit==0.0.0
+zipp==1.0.0