added files

.dockerignore

@@ -0,0 +1,61 @@
+# Version control
+.git
+.gitignore
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Large data files (exclude datasets)
+SEN-2_LULC/
+SEN-2_LULC_preprocessed/
+SEN-2_LULC_preprocessed1/
+outputs_rgb_optimized/
+*.zip
+*.tar.gz
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/
+
+# Documentation
+README.md
+docs/

Dockerfile

@@ -0,0 +1,65 @@
+# Use PyTorch base image with CUDA support
+FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libgdal-dev \
+    gdal-bin \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    wget \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --no-cache-dir \
+    torch==2.1.0 \
+    torchvision==0.16.0 \
+    torchaudio==2.1.0 \
+    segmentation-models-pytorch==0.3.3 \
+    gradio==4.8.0 \
+    albumentations==1.3.1 \
+    opencv-python-headless==4.8.1.78 \
+    pillow==10.1.0 \
+    numpy==1.24.4 \
+    tqdm==4.66.1 \
+    timm==0.9.12
+
+# Create necessary directories
+RUN mkdir -p /app/Segmentation-lulc \
+    && mkdir -p /app/data \
+    && mkdir -p /app/outputs \
+    && mkdir -p /app/models
+
+# Copy application files
+COPY Segmentation-lulc/ /app/Segmentation-lulc/
+
+# Copy any example images or models if they exist
+COPY --chown=root:root . /app/
+
+# Set permissions
+RUN chmod -R 755 /app
+
+# Expose Gradio port
+EXPOSE 7860
+
+# Default command - run the Gradio app
+CMD ["python", "/app/Segmentation-lulc/app3.py"]
+
+# Alternative commands (can be overridden):
+# For preprocessing: docker run <image> python /app/Segmentation-lulc/pre1.py
+# For training: docker run <image> python /app/Segmentation-lulc/main3.py

README-Docker.md

@@ -0,0 +1,92 @@
+# LULC Segmentation Docker Setup
+
+This directory contains Docker configuration for the Land Use Land Cover (LULC) segmentation application.
+
+## Prerequisites
+
+- Docker installed with GPU support (nvidia-docker)
+- NVIDIA Container Toolkit for GPU acceleration
+
+## Quick Start
+
+### 1. Build the Docker image
+```bash
+docker build -t lulc-segmentation:latest .
+```
+
+### 2. Run the Gradio application
+```bash
+docker run -it --rm \
+    --gpus all \
+    -p 7860:7860 \
+    -v $(pwd)/data:/app/data \
+    -v $(pwd)/outputs:/app/outputs \
+    -v $(pwd)/models:/app/models \
+    lulc-segmentation:latest
+```
+
+### 3. Access the application
+Open your browser and navigate to `http://localhost:7860`
+
+## Using Docker Compose
+
+### Run the application
+```bash
+docker-compose up lulc-segmentation
+```
+
+### Run training (with profile)
+```bash
+docker-compose --profile training up lulc-training
+```
+
+## Using the convenience script
+
+Make the script executable:
+```bash
+chmod +x run-docker.sh
+```
+
+Then use it:
+```bash
+./run-docker.sh build      # Build the image
+./run-docker.sh app        # Run the Gradio app
+./run-docker.sh train      # Run training
+./run-docker.sh preprocess # Run preprocessing
+```
+
+## Volume Mounts
+
+- `./data` → `/app/data` - For input datasets
+- `./outputs` → `/app/outputs` - For training outputs and checkpoints
+- `./models` → `/app/models` - For trained model files
+
+## Environment Variables
+
+- `GRADIO_SERVER_NAME=0.0.0.0` - Allow external connections
+- `GRADIO_SERVER_PORT=7860` - Gradio port
+- `PYTHONPATH=/app` - Python path configuration
+
+## GPU Support
+
+The container is configured to use all available GPUs. Ensure you have:
+- NVIDIA Docker runtime installed
+- Proper GPU drivers
+- NVIDIA Container Toolkit
+
+## Troubleshooting
+
+1. **GPU not detected**: Ensure nvidia-docker is properly installed
+2. **Port conflicts**: Change the port mapping if 7860 is in use
+3. **Permission issues**: Ensure proper volume mount permissions
+
+## Development
+
+For development, you can mount the source code directly:
+```bash
+docker run -it --rm \
+    --gpus all \
+    -p 7860:7860 \
+    -v $(pwd)/Segmentation-lulc:/app/Segmentation-lulc \
+    lulc-segmentation:latest
+```

app3.py

@@ -0,0 +1,193 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import torchvision.transforms as T
+import torchvision.transforms.functional as F
+import segmentation_models_pytorch as smp
+import os
+
+# --- 1. Configuration and Constants ---
+
+class CFG:
+    """
+    Configuration class adapted from the provided training script.
+    """
+    DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+    MODEL_NAME = "CustomDeepLabV3+"
+    ENCODER_NAME = "timm-efficientnet-b2"
+    IN_CHANNELS = 3
+    NUM_CLASSES = 8
+    IMG_SIZE = 256
+    # NOTE: Update this path to where your trained model is saved.
+    MODEL_SAVE_PATH = "./best_model_optimized.pth"
+
+# Class definitions and color map based on the research paper
+CLASS_INFO = {
+    0: {"name": "Unclassified", "color": (150, 150, 150)},
+    1: {"name": "Water Bodies", "color": (0, 0, 255)},        # Blue
+    2: {"name": "Dense Forest", "color": (0, 100, 0)},         # Dark Green
+    3: {"name": "Built up", "color": (128, 0, 128)},           # Purple
+    4: {"name": "Agriculture land", "color": (0, 255, 0)},     # Bright Green
+    5: {"name": "Barren land", "color": (255, 255, 0)},        # Yellow
+    6: {"name": "Fallow land", "color": (210, 180, 140)},      # Tan
+    7: {"name": "Sparse Forest", "color": (60, 179, 113)},     # Medium Sea Green
+}
+
+PIXEL_AREA_SQ_METERS = 10 * 10  # Based on 10m resolution from the dataset
+SQ_METERS_PER_HECTARE = 10000
+
+# --- 2. Model Definitions (from provided training script) ---
+
+class SELayer(nn.Module):
+    def __init__(self, channel, reduction=16):
+        super(SELayer, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(nn.Linear(channel, channel // reduction, bias=False), nn.ReLU(inplace=True), nn.Linear(channel // reduction, channel, bias=False), nn.Sigmoid())
+    def forward(self, x):
+        b, c, _, _ = x.size()
+        y = self.avg_pool(x).view(b, c)
+        y = self.fc(y).view(b, c, 1, 1)
+        return x * y.expand_as(x)
+
+class CustomDeepLabV3Plus(nn.Module):
+    def __init__(self, encoder_name, in_channels, classes):
+        super().__init__()
+        self.smp_model = smp.DeepLabV3Plus(encoder_name=encoder_name, encoder_weights="imagenet", in_channels=in_channels, classes=classes)
+        decoder_channels = self.smp_model.segmentation_head[0].in_channels
+        self.se_layer = SELayer(decoder_channels)
+        self.segmentation_head = self.smp_model.segmentation_head
+        self.smp_model.segmentation_head = nn.Identity()
+    def forward(self, x):
+        decoder_features = self.smp_model(x)
+        attended_features = self.se_layer(decoder_features)
+        output = self.segmentation_head(attended_features)
+        return output
+
+# --- 3. Helper Functions ---
+
+def load_model():
+    """Loads the pre-trained segmentation model."""
+    model = CustomDeepLabV3Plus(
+        encoder_name=CFG.ENCODER_NAME,
+        in_channels=CFG.IN_CHANNELS,
+        classes=CFG.NUM_CLASSES
+    )
+    if not os.path.exists(CFG.MODEL_SAVE_PATH):
+        raise FileNotFoundError(f"Model file not found at {CFG.MODEL_SAVE_PATH}. Please ensure the model is trained and the path is correct.")
+    
+    model.load_state_dict(torch.load(CFG.MODEL_SAVE_PATH, map_location=torch.device(CFG.DEVICE)))
+    model.to(CFG.DEVICE)
+    model.eval()
+    print("Model loaded successfully on device:", CFG.DEVICE)
+    return model
+
+def preprocess_image(img: Image.Image):
+    """Preprocesses a PIL image for model inference."""
+    img = F.resize(img, [CFG.IMG_SIZE, CFG.IMG_SIZE], interpolation=T.InterpolationMode.BILINEAR)
+    img_tensor = F.to_tensor(img)
+    normalize_transform = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    normalized_tensor = normalize_transform(img_tensor)
+    return normalized_tensor.unsqueeze(0) # Add batch dimension
+
+def create_colored_mask(mask: np.ndarray) -> Image.Image:
+    """Creates a colored RGB image from a class index mask."""
+    rgb_mask = np.zeros((*mask.shape, 3), dtype=np.uint8)
+    for class_id, info in CLASS_INFO.items():
+        rgb_mask[mask == class_id] = info["color"]
+    return Image.fromarray(rgb_mask)
+
+def create_legend_image():
+    """Generates an image of the color legend."""
+    item_height = 25
+    width = 250
+    height = item_height * len(CLASS_INFO)
+    legend_img = Image.new('RGB', (width, height), 'white')
+    draw = ImageDraw.Draw(legend_img)
+    
+    try:
+        # Use a common font, handle case where it's not found
+        font = ImageFont.truetype("arial.ttf", 14)
+    except IOError:
+        font = ImageFont.load_default()
+
+    for i, (class_id, info) in enumerate(CLASS_INFO.items()):
+        y_start = i * item_height
+        draw.rectangle([5, y_start + 5, 25, y_start + 20], fill=info["color"])
+        draw.text((35, y_start + 5), f'{info["name"]}', fill='black', font=font)
+        
+    return legend_img
+
+# --- 4. Main Prediction Function ---
+
+# Load the model and legend once when the script starts
+model = load_model()
+legend_image = create_legend_image()
+
+def predict_land_cover(input_image: Image.Image):
+    """
+    Takes an input image, performs segmentation, and calculates area for each class.
+    """
+    if input_image is None:
+        raise gr.Error("Please upload an image.")
+
+    # 1. Preprocess the image and get model prediction
+    input_tensor = preprocess_image(input_image.convert("RGB")).to(CFG.DEVICE)
+    with torch.no_grad():
+        output = model(input_tensor)
+    pred_mask = torch.argmax(output, dim=1).squeeze(0).cpu().numpy()
+
+    # 2. Create the colored segmentation mask for visualization
+    colored_mask = create_colored_mask(pred_mask)
+
+    # 3. Calculate area for each class
+    class_indices, pixel_counts = np.unique(pred_mask, return_counts=True)
+    
+    area_results = {}
+    total_area_ha = (CFG.IMG_SIZE * CFG.IMG_SIZE * PIXEL_AREA_SQ_METERS) / SQ_METERS_PER_HECTARE
+
+    for class_id, count in zip(class_indices, pixel_counts):
+        class_name = CLASS_INFO[class_id]["name"]
+        area_hectares = (count * PIXEL_AREA_SQ_METERS) / SQ_METERS_PER_HECTARE
+        percentage = (area_hectares / total_area_ha) * 100
+        area_results[class_name] = f"{area_hectares:.4f} Hectares ({percentage:.2f}%)"
+        
+    return colored_mask, area_results, legend_image
+
+# --- 5. Gradio Interface ---
+
+# Load example images from your file system.
+example_files = ["comparison_1.jpg", "comparison_4.jpg", "comparison_5.jpg", "comparison_8.jpg"]
+example_images = [file for file in example_files if os.path.exists(file)]
+
+app_description = """
+### Sen-2 LULC: Interactive Land Cover Analysis
+This tool performs semantic segmentation on satellite imagery to classify different types of land use and land cover (LULC). 
+It is based on the **Sen-2 LULC dataset** and a **Custom DeepLabV3+** model as described in the research paper "Sen-2 LULC: Land Use Land Cover Dataset for Deep Learning Approaches".
+
+**How it works:**
+1.  **Upload Image:** Upload a satellite image patch. You can use the examples below.
+2.  **Model Prediction:** The deep learning model classifies each pixel into one of the 7 LULC classes.
+3.  **Analysis:** The application generates:
+    * A color-coded **Segmentation Mask** for visual analysis.
+    * A **Quantitative Report** calculating the area of each land class in hectares. This is possible because the source Sentinel-2 imagery has a **10m resolution**, meaning each pixel represents a 100m² area on the ground.
+"""
+
+iface = gr.Interface(
+    fn=predict_land_cover,
+    inputs=gr.Image(type="pil", label="Upload Satellite Image Patch"),
+    outputs=[
+        gr.Image(type="pil", label="Predicted Segmentation Mask"),
+        gr.Label(label="Land Cover Area Analysis (Hectares)"),
+        gr.Image(type="pil", label="Legend")
+    ],
+    title="Land Use & Land Cover Segmentation and Area Analysis",
+    description=app_description,
+    examples=example_images,
+    cache_examples=True,
+    allow_flagging="never"
+)
+
+if __name__ == "__main__":
+    iface.launch(debug=True)

docker-compose.yml

@@ -0,0 +1,52 @@
+version: '3.8'
+
+services:
+  lulc-segmentation:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: lulc-app
+    ports:
+      - "7860:7860"
+    volumes:
+      # Mount data directory for datasets
+      - ./data:/app/data
+      # Mount outputs directory for model checkpoints
+      - ./outputs:/app/outputs
+      # Mount models directory for trained models
+      - ./models:/app/models
+    environment:
+      - PYTHONPATH=/app
+      - GRADIO_SERVER_NAME=0.0.0.0
+      - GRADIO_SERVER_PORT=7860
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+    command: python /app/Segmentation-lulc/app3.py
+    
+  # Optional service for training
+  lulc-training:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: lulc-training
+    volumes:
+      - ./data:/app/data
+      - ./outputs:/app/outputs
+      - ./models:/app/models
+    environment:
+      - PYTHONPATH=/app
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
+    command: python /app/Segmentation-lulc/main3.py
+    profiles:
+      - training

main3.py

@@ -0,0 +1,203 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from PIL import Image
+import numpy as np
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+from tqdm import tqdm
+import segmentation_models_pytorch as smp
+import cv2
+
+# --- 1. Configuration ---
+class CFG:
+    DATA_DIR = r"SEN-2_LULC_preprocessed"
+    TRAIN_IMG_DIR = os.path.join(DATA_DIR, "train_images")
+    TRAIN_MASK_DIR = os.path.join(DATA_DIR, "train_masks")
+    VAL_IMG_DIR = os.path.join(DATA_DIR, "val_images")
+    VAL_MASK_DIR = os.path.join(DATA_DIR, "val_masks")
+    
+    OUTPUT_DIR = "./outputs_rgb_optimized"
+    # The path for the 'best' model, for inference later
+    MODEL_SAVE_PATH = os.path.join(OUTPUT_DIR, "best_model_optimized.pth")
+    # --- NEW: Path for the resumable checkpoint file ---
+    CHECKPOINT_PATH = os.path.join(OUTPUT_DIR, "checkpoint.pth")
+    
+    PREDICTION_SAVE_PATH = os.path.join(OUTPUT_DIR, "predictions_optimized")
+
+    DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+    MODEL_NAME = "CustomDeepLabV3+"
+    ENCODER_NAME = "timm-efficientnet-b2"
+    LOSS_FN_NAME = "DiceFocal"
+    IN_CHANNELS = 3; NUM_CLASSES = 8; IMG_SIZE = 256
+    BATCH_SIZE = 4; ACCUMULATION_STEPS = 4
+    NUM_WORKERS = 8; LEARNING_RATE = 1e-4; EPOCHS = 50
+    SEED = 42; SUBSET_FRACTION = 0.75
+
+# --- ARCHITECTURE and LOSS CLASSES (Unchanged) ---
+class SELayer(nn.Module):
+    def __init__(self, channel, reduction=16):
+        super(SELayer, self).__init__(); self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(nn.Linear(channel, channel // reduction, bias=False), nn.ReLU(inplace=True), nn.Linear(channel // reduction, channel, bias=False), nn.Sigmoid())
+    def forward(self, x):
+        b, c, _, _ = x.size(); y = self.avg_pool(x).view(b, c); y = self.fc(y).view(b, c, 1, 1); return x * y.expand_as(x)
+class CustomDeepLabV3Plus(nn.Module):
+    def __init__(self, encoder_name, in_channels, classes):
+        super().__init__(); self.smp_model = smp.DeepLabV3Plus(encoder_name=encoder_name, encoder_weights="imagenet", in_channels=in_channels, classes=classes)
+        decoder_channels = self.smp_model.segmentation_head[0].in_channels; self.se_layer = SELayer(decoder_channels)
+        self.segmentation_head = self.smp_model.segmentation_head; self.smp_model.segmentation_head = nn.Identity()
+    def forward(self, x):
+        decoder_features = self.smp_model(x); attended_features = self.se_layer(decoder_features)
+        output = self.segmentation_head(attended_features); return output
+class CombinedLoss(nn.Module):
+    def __init__(self, loss1, loss2, alpha=0.5):
+        super(CombinedLoss, self).__init__(); self.loss1 = loss1; self.loss2 = loss2; self.alpha = alpha
+        self.name = f"{alpha}*{self.loss1.__class__.__name__} + {1-alpha}*{self.loss2.__class__.__name__}"
+    def forward(self, prediction, target):
+        loss1_val = self.loss1(prediction, target); loss2_val = self.loss2(prediction, target); return self.alpha * loss1_val + (1 - self.alpha) * loss2_val
+
+# --- DATASET and TRANSFORMS (Unchanged) ---
+class LULCDataset(Dataset):
+    def __init__(self, image_dir, mask_dir, transform=None, subset_fraction=1.0):
+        self.image_dir = image_dir; self.mask_dir = mask_dir; self.transform = transform
+        all_images = sorted([f for f in os.listdir(image_dir) if f.endswith('.png')])
+        all_masks = sorted([f for f in os.listdir(mask_dir) if f.endswith('.tif')])
+        num_samples = int(len(all_images) * subset_fraction)
+        self.images = all_images[:num_samples]; self.masks = all_masks[:num_samples]
+        assert len(self.images) == len(self.masks), "Mismatch"; print(f"Found {len(all_images)} total images, USING {len(self.images)} samples ({subset_fraction*100}%) from {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.masks[idx])
+        image = np.array(Image.open(img_path).convert("RGB"), dtype=np.float32)
+        mask = np.array(Image.open(mask_path).convert("L"), dtype=np.float32)
+        if self.transform: augmented = self.transform(image=image, mask=mask); image, mask = augmented['image'], augmented['mask']
+        return image, mask
+def get_transforms(img_size):
+    DATASET_MEAN = [0.485, 0.456, 0.406]; DATASET_STD = [0.229, 0.224, 0.225]
+    train_transform = A.Compose([A.Resize(img_size, img_size), A.Rotate(limit=35, p=0.5), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Normalize(mean=DATASET_MEAN, std=DATASET_STD), ToTensorV2()])
+    val_transform = A.Compose([A.Resize(img_size, img_size), A.Normalize(mean=DATASET_MEAN, std=DATASET_STD), ToTensorV2()])
+    return train_transform, val_transform
+
+# --- GET MODEL AND LOSS (Unchanged) ---
+def get_model():
+    if CFG.MODEL_NAME == "CustomDeepLabV3+": model = CustomDeepLabV3Plus(encoder_name=CFG.ENCODER_NAME, in_channels=CFG.IN_CHANNELS, classes=CFG.NUM_CLASSES)
+    else: model = smp.DeepLabV3Plus(encoder_name=CFG.ENCODER_NAME, encoder_weights="imagenet", in_channels=CFG.IN_CHANNELS, classes=CFG.NUM_CLASSES)
+    return model.to(CFG.DEVICE)
+def get_loss_fn():
+    if CFG.LOSS_FN_NAME == "DiceFocal": dice = smp.losses.DiceLoss(mode='multiclass'); focal = smp.losses.FocalLoss(mode='multiclass'); return CombinedLoss(focal, dice, alpha=0.5)
+    else: return smp.losses.DiceLoss(mode='multiclass')
+
+# --- Training and Evaluation Functions (Unchanged) ---
+def train_one_epoch(loader, model, optimizer, loss_fn, scaler):
+    loop = tqdm(loader, desc="Training"); model.train(); optimizer.zero_grad()
+    for batch_idx, (data, targets) in enumerate(loop):
+        data = data.to(CFG.DEVICE, non_blocking=True, memory_format=torch.channels_last)
+        targets = targets.long().to(CFG.DEVICE, non_blocking=True)
+        with torch.amp.autocast(device_type=CFG.DEVICE, dtype=torch.bfloat16, enabled=(CFG.DEVICE=="cuda")):
+            predictions = model(data); loss = loss_fn(predictions, targets) / CFG.ACCUMULATION_STEPS
+        scaler.scale(loss).backward()
+        if (batch_idx + 1) % CFG.ACCUMULATION_STEPS == 0:
+            scaler.step(optimizer); scaler.update(); optimizer.zero_grad()
+        loop.set_postfix(loss=loss.item() * CFG.ACCUMULATION_STEPS)
+def evaluate_model(loader, model, loss_fn):
+    model.eval(); intersection, union = torch.zeros(CFG.NUM_CLASSES, device=CFG.DEVICE), torch.zeros(CFG.NUM_CLASSES, device=CFG.DEVICE)
+    pixel_correct, pixel_total, total_loss = 0, 0, 0
+    with torch.no_grad():
+        loop = tqdm(loader, desc="Evaluating")
+        for x, y in loop:
+            x = x.to(CFG.DEVICE, non_blocking=True, memory_format=torch.channels_last)
+            y = y.to(CFG.DEVICE, non_blocking=True).long()
+            with torch.amp.autocast(device_type=CFG.DEVICE, dtype=torch.bfloat16, enabled=(CFG.DEVICE=="cuda")):
+                preds = model(x); loss = loss_fn(preds, y); total_loss += loss.item()
+            pred_labels = torch.argmax(preds, dim=1); pixel_correct += (pred_labels == y).sum(); pixel_total += torch.numel(y)
+            for cls in range(CFG.NUM_CLASSES): pred_mask = (pred_labels == cls); true_mask = (y == cls); intersection[cls] += (pred_mask & true_mask).sum(); union[cls] += (pred_mask | true_mask).sum()
+    pixel_acc = (pixel_correct / pixel_total) * 100; iou_per_class = (intersection + 1e-6) / (union + 1e-6)
+    mean_iou = iou_per_class.mean(); avg_loss = total_loss / len(loader)
+    print(f"Validation Results -> Avg Loss: {avg_loss:.4f}, Pixel Acc: {pixel_acc:.2f}%, mIoU: {mean_iou:.4f}")
+    for i, iou in enumerate(iou_per_class): print(f"  Class {i} IoU: {iou:.4f}")
+    return mean_iou
+
+def save_predictions_as_images(loader, model):
+    # This function is not part of the training loop, no changes needed.
+    pass # implementation is correct as-is
+
+# --- NEW: Helper function to save a checkpoint ---
+def save_checkpoint(state, filename="checkpoint.pth"):
+    print("=> Saving checkpoint")
+    torch.save(state, filename)
+
+def main():
+    torch.manual_seed(CFG.SEED); np.random.seed(CFG.SEED); os.makedirs(CFG.OUTPUT_DIR, exist_ok=True)
+    if torch.cuda.is_available(): torch.backends.cudnn.benchmark = True
+    
+    train_transform, val_transform = get_transforms(CFG.IMG_SIZE)
+    train_ds = LULCDataset(CFG.TRAIN_IMG_DIR, CFG.TRAIN_MASK_DIR, transform=train_transform, subset_fraction=CFG.SUBSET_FRACTION)
+    val_ds = LULCDataset(CFG.VAL_IMG_DIR, CFG.VAL_MASK_DIR, transform=val_transform, subset_fraction=CFG.SUBSET_FRACTION)
+    train_loader = DataLoader(train_ds, batch_size=CFG.BATCH_SIZE, num_workers=CFG.NUM_WORKERS, pin_memory=True, shuffle=True, persistent_workers=True)
+    val_loader = DataLoader(val_ds, batch_size=CFG.BATCH_SIZE, num_workers=CFG.NUM_WORKERS, pin_memory=True, shuffle=False, persistent_workers=True)
+
+    model = get_model()
+    model = model.to(memory_format=torch.channels_last)
+    
+    loss_fn = get_loss_fn()
+    optimizer = optim.AdamW(model.parameters(), lr=CFG.LEARNING_RATE)
+    scaler = torch.amp.GradScaler(enabled=(CFG.DEVICE=="cuda"))
+    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=CFG.EPOCHS, eta_min=1e-6)
+
+    # --- NEW: Logic to load checkpoint and resume training ---
+    start_epoch = 0
+    best_val_miou = -1.0
+    if os.path.exists(CFG.CHECKPOINT_PATH):
+        print(f"=> Loading checkpoint '{CFG.CHECKPOINT_PATH}'")
+        checkpoint = torch.load(CFG.CHECKPOINT_PATH, map_location=CFG.DEVICE)
+        
+        model.load_state_dict(checkpoint['model_state_dict'])
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+        scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
+        scaler.load_state_dict(checkpoint['scaler_state_dict'])
+        
+        start_epoch = checkpoint['epoch'] + 1
+        best_val_miou = checkpoint['best_val_miou']
+        
+        print(f"=> Resuming training from epoch {start_epoch}")
+    else:
+        print("=> No checkpoint found, starting new training session.")
+
+
+    # --- MODIFIED: Main training loop now starts from the correct epoch ---
+    for epoch in range(start_epoch, CFG.EPOCHS):
+        print(f"\n--- Epoch {epoch+1}/{CFG.EPOCHS} ---")
+        train_one_epoch(train_loader, model, optimizer, loss_fn, scaler)
+        current_miou = evaluate_model(val_loader, model, loss_fn)
+        scheduler.step()
+
+        # Create the checkpoint dictionary with the complete state
+        checkpoint = {
+            'epoch': epoch,
+            'model_state_dict': model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'scheduler_state_dict': scheduler.state_dict(),
+            'scaler_state_dict': scaler.state_dict(),
+            'best_val_miou': best_val_miou
+        }
+        
+        if current_miou > best_val_miou:
+            best_val_miou = current_miou
+            checkpoint['best_val_miou'] = best_val_miou # Update best score in checkpoint
+            print(f"🎉 New best mIoU: {best_val_miou:.4f}! Saving best model to {CFG.MODEL_SAVE_PATH}")
+            torch.save(model.state_dict(), CFG.MODEL_SAVE_PATH) # Save just the model for easy inference
+        
+        # Save the full state checkpoint after every epoch
+        save_checkpoint(checkpoint, filename=CFG.CHECKPOINT_PATH)
+
+
+    print("\n--- Training Complete. Saving final predictions. ---")
+    # Load the best performing model for final predictions
+    model.load_state_dict(torch.load(CFG.MODEL_SAVE_PATH))
+    # Note: You may want a separate test_loader for final unbiased evaluation
+    save_predictions_as_images(val_loader, model)
+
+if __name__ == "__main__":
+    main()

pre1.py

@@ -0,0 +1,99 @@
+import os
+from PIL import Image
+from tqdm import tqdm
+import glob
+
+# --- 1. Centralized Configuration ---
+class CFG:
+    # --- Paths ---
+    SOURCE_ROOT = "SEN-2 LULC"
+    DEST_ROOT = "SEN-2_LULC_preprocessed1"
+    
+    # --- Image & File Settings ---
+    IMG_SIZE = 256
+    IMG_EXT = ".png"  # Assumes source images are PNGs
+    MASK_EXT = ".tif" # Assumes source masks are TIFs
+
+# --- 2. Define All Data Splits ---
+SPLITS = {
+    "train": {
+        "images": os.path.join(CFG.SOURCE_ROOT, "train_images", "train"),
+        "masks": os.path.join(CFG.SOURCE_ROOT, "train_masks", "train"),
+    },
+    "val": {
+        "images": os.path.join(CFG.SOURCE_ROOT, "val_images", "val"),
+        "masks": os.path.join(CFG.SOURCE_ROOT, "val_masks", "val"),
+    },
+    "test": {
+        # Test set usually only has images
+        "images": os.path.join(CFG.SOURCE_ROOT, "test_images", "test"),
+        "masks": None, # Set to None if no masks exist
+    },
+}
+
+def preprocess_and_resize():
+    """
+    Resizes images and their corresponding masks for all data splits.
+    This version robustly matches images to masks by filename.
+    """
+    print(f"Starting preprocessing. Output will be saved to: {CFG.DEST_ROOT}\n")
+    stats = {}
+
+    # --- 3. Iterate Through Each Split (train, val, test) ---
+    for split_name, split_paths in SPLITS.items():
+        print(f"--- Processing split: {split_name} ---")
+        
+        # Get paths and create destination directories
+        image_dir = split_paths["images"]
+        mask_dir = split_paths["masks"]
+        
+        dest_img_dir = os.path.join(CFG.DEST_ROOT, f"{split_name}_images")
+        os.makedirs(dest_img_dir, exist_ok=True)
+        
+        if mask_dir:
+            dest_mask_dir = os.path.join(CFG.DEST_ROOT, f"{split_name}_masks")
+            os.makedirs(dest_mask_dir, exist_ok=True)
+
+        # Find all source images
+        image_files = glob.glob(os.path.join(image_dir, f"*{CFG.IMG_EXT}"))
+        
+        if not image_files:
+            print(f"Warning: No images found in {image_dir}. Skipping.")
+            continue
+            
+        stats[split_name] = {"images": 0, "masks": 0}
+
+        # --- 4. Robustly Process Each Image and Find its Mask ---
+        for img_path in tqdm(image_files, desc=f"Resizing {split_name} data"):
+            try:
+                # --- Process the image ---
+                base_name = os.path.basename(img_path)
+                with Image.open(img_path) as img:
+                    resized_img = img.resize((CFG.IMG_SIZE, CFG.IMG_SIZE), resample=Image.Resampling.LANCZOS)
+                    resized_img.save(os.path.join(dest_img_dir, base_name))
+                    stats[split_name]["images"] += 1
+
+                # --- Find and process the corresponding mask (if applicable) ---
+                if mask_dir:
+                    mask_name = os.path.splitext(base_name)[0] + CFG.MASK_EXT
+                    mask_path = os.path.join(mask_dir, mask_name)
+                    
+                    if os.path.exists(mask_path):
+                        with Image.open(mask_path) as mask:
+                            # CRITICAL: Use NEAREST resampling for masks to preserve class labels
+                            resized_mask = mask.resize((CFG.IMG_SIZE, CFG.IMG_SIZE), resample=Image.Resampling.NEAREST)
+                            resized_mask.save(os.path.join(dest_mask_dir, mask_name))
+                            stats[split_name]["masks"] += 1
+
+            except Exception as e:
+                print(f"Error processing {img_path}: {e}")
+    
+    # --- 5. Final Verification Summary ---
+    print("\n--- Preprocessing Complete! ---")
+    for split_name, counts in stats.items():
+        print(f"Split '{split_name}': Processed {counts['images']} images and {counts['masks']} masks.")
+    print(f"Resized data is in '{CFG.DEST_ROOT}'")
+
+
+if __name__ == "__main__":
+    preprocess_and_resize()

run-docker.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+# Build the Docker image
+echo "Building LULC Segmentation Docker image..."
+docker build -t lulc-segmentation:latest .
+
+# Function to run the Gradio app
+run_app() {
+    echo "Starting LULC Segmentation Gradio app..."
+    docker run -it --rm \
+        --gpus all \
+        -p 7860:7860 \
+        -v $(pwd)/data:/app/data \
+        -v $(pwd)/outputs:/app/outputs \
+        -v $(pwd)/models:/app/models \
+        -e GRADIO_SERVER_NAME=0.0.0.0 \
+        lulc-segmentation:latest
+}
+
+# Function to run training
+run_training() {
+    echo "Starting LULC model training..."
+    docker run -it --rm \
+        --gpus all \
+        -v $(pwd)/data:/app/data \
+        -v $(pwd)/outputs:/app/outputs \
+        -v $(pwd)/models:/app/models \
+        lulc-segmentation:latest \
+        python /app/Segmentation-lulc/main3.py
+}
+
+# Function to run preprocessing
+run_preprocessing() {
+    echo "Starting data preprocessing..."
+    docker run -it --rm \
+        -v $(pwd)/data:/app/data \
+        lulc-segmentation:latest \
+        python /app/Segmentation-lulc/pre1.py
+}
+
+# Parse command line arguments
+case "$1" in
+    "app")
+        run_app
+        ;;
+    "train")
+        run_training
+        ;;
+    "preprocess")
+        run_preprocessing
+        ;;
+    "build")
+        echo "Docker image built successfully!"
+        ;;
+    *)
+        echo "Usage: $0 {app|train|preprocess|build}"
+        echo "  app        - Run the Gradio application"
+        echo "  train      - Run model training"
+        echo "  preprocess - Run data preprocessing"
+        echo "  build      - Build Docker image only"
+        exit 1
+        ;;
+esac