File size: 7,092 Bytes
fab54be 7db73fd fab54be 7db73fd fab54be 7db73fd fab54be 7db73fd fab54be | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 | """
Model service for loading and running PyTorch Lightning inference.
Implements thread-safe model loading and prediction with torch.no_grad() optimization.
"""
import os
import torch
import pytorch_lightning as pl
import segmentation_models_pytorch as smp
import numpy as np
from src import config
# Global model instance
_model = None
class DynamicEvalModel(pl.LightningModule):
"""
PyTorch Lightning model wrapper for U-Net++ segmentation.
Used for water/cloud segmentation tasks.
"""
def __init__(self, **kwargs):
super().__init__()
self.save_hyperparameters()
self.model_params = kwargs.get('model_params', {
'model_type': 'unetplusplus',
'encoder_name': 'resnet34',
'in_channels': 6,
'out_classes': 2
})
self._build_model()
def _build_model(self):
"""Build the U-Net++ segmentation model."""
self.model = smp.UnetPlusPlus(
encoder_name=self.model_params.get('encoder_name', 'resnet34'),
encoder_weights=None,
in_channels=self.model_params.get('in_channels', 6),
classes=self.model_params.get('out_classes', 2),
activation=None
)
def forward(self, x):
return self.model(x)
def initialize_model():
"""
Load the PyTorch Lightning model from checkpoint.
Model is placed on the configured device (GPU/CPU) and set to eval mode.
"""
global _model
config.logger.info("⏳ Loading model...")
if not os.path.exists(config.CHECKPOINT_PATH):
config.logger.error(f"❌ Model Checkpoint Not Found: {config.CHECKPOINT_PATH}")
_model = None
return None
try:
_model = DynamicEvalModel.load_from_checkpoint(
config.CHECKPOINT_PATH,
strict=False
)
_model.to(config.DEVICE)
_model.eval()
config.logger.info("✅ Model Loaded Successfully!")
return _model
except Exception as e:
config.logger.error(f"❌ Model Load Failed: {e}")
_model = None
return None
def get_model():
"""Retrieve the loaded model instance."""
return _model
def predict_water_mask(tiff_path):
"""
Run inference on a TIFF image to predict water and cloud masks.
Args:
tiff_path: Path to the input TIFF file (6-channel optical image)
Returns:
Clean water mask (numpy array, uint8) or None on failure
"""
import tifffile as tiff
import cv2
from src.services.cv2 import (
apply_hanning_window, apply_cloud_detection,
apply_water_detection, apply_morphological_cleanup,
filter_small_contours
)
if _model is None or not os.path.exists(tiff_path):
return None
# Load and prepare image
image = tiff.imread(tiff_path).astype(np.float32)
if image.ndim == 3 and image.shape[2] == 6:
image_tensor = np.transpose(image, (2, 0, 1))
else:
image_tensor = image.copy()
# Normalize to [0, 1]
scaled_tensor = np.clip(image_tensor / config.OPTICAL_NORMALIZATION_FACTOR, 0, 1)
# Tiling parameters
tile_size = config.TILE_SIZE
overlap_ratio = config.TILE_OVERLAP_RATIO
stride = int(tile_size * (1 - overlap_ratio))
c, h, w = scaled_tensor.shape
# Padding for tile overlap
pad_h = (tile_size - (h % stride)) % stride + (tile_size - stride) if h % stride != 0 else 0
pad_w = (tile_size - (w % stride)) % stride + (tile_size - stride) if w % stride != 0 else 0
image_padded = np.pad(scaled_tensor, ((0, 0), (0, pad_h), (0, pad_w)), mode='reflect')
padded_h, padded_w = image_padded.shape[1], image_padded.shape[2]
# Initialize output maps
prob_map_cloud = np.zeros((padded_h, padded_w), dtype=np.float32)
prob_map_water = np.zeros((padded_h, padded_w), dtype=np.float32)
count_map = np.zeros((padded_h, padded_w), dtype=np.float32)
# Generate tile coordinates
y_steps = list(range(0, padded_h - tile_size + 1, stride))
x_steps = list(range(0, padded_w - tile_size + 1, stride))
# Hanning window for smooth blending
window_1d = np.hanning(tile_size)
window_2d = np.outer(window_1d, window_1d).astype(np.float32)
# Process tiles in batches
tiles_batch = []
coords_batch = []
with torch.no_grad(): # Disable gradients for inference
for y in y_steps:
for x in x_steps:
tile = image_padded[:, y:y+tile_size, x:x+tile_size]
tiles_batch.append(tile)
coords_batch.append((x, y))
# Process batch when full or at end
if len(tiles_batch) == config.BATCH_SIZE or (y == y_steps[-1] and x == x_steps[-1]):
batch_tensor = torch.from_numpy(np.stack(tiles_batch)).to(config.DEVICE)
logits = _model(batch_tensor)
probs = torch.sigmoid(logits).cpu().numpy()
# Accumulate predictions
for i, (bx, by) in enumerate(coords_batch):
prob_cloud = probs[i, 0, :, :] * window_2d
prob_water = probs[i, 1, :, :] * window_2d
prob_map_cloud[by:by+tile_size, bx:bx+tile_size] += prob_cloud
prob_map_water[by:by+tile_size, bx:bx+tile_size] += prob_water
count_map[by:by+tile_size, bx:bx+tile_size] += window_2d
tiles_batch = []
coords_batch = []
# Normalize by count map
final_cloud_prob = (prob_map_cloud / (count_map + 1e-7))[:h, :w]
final_water_prob = (prob_map_water / (count_map + 1e-7))[:h, :w]
# Extract optical bands for cloud/water detection
b2 = scaled_tensor[0, :h, :w]
b3 = scaled_tensor[1, :h, :w]
b4 = scaled_tensor[2, :h, :w]
b8 = scaled_tensor[3, :h, :w]
# Calculate brightness and NDWI
brightness = np.sqrt(b2**2 + b3**2 + b4**2)
ndwi = (b3 - b8) / (b3 + b8 + 1e-5)
# Apply cloud detection
base_cloud_mask = ((final_cloud_prob > config.CLOUD_DETECTION_THRESHOLD) &
(brightness > config.BRIGHTNESS_THRESHOLD)).astype(np.uint8)
# Dilate cloud mask for shadow buffering
cloud_buffer_kernel = np.ones(config.CLOUD_BUFFER_KERNEL_SIZE, np.uint8)
cloud_and_shadow_mask = cv2.dilate(base_cloud_mask, cloud_buffer_kernel, iterations=1)
# Apply water detection
raw_water_mask = (final_water_prob > config.NDWI_WATER_THRESHOLD) | (ndwi > config.NDWI_CLOUD_THRESHOLD)
water_mask = raw_water_mask & (cloud_and_shadow_mask == 0) & (ndwi > config.NDWI_MIN_THRESHOLD)
clean_mask = water_mask.astype(np.uint8)
# Morphological cleanup
clean_mask = apply_morphological_cleanup(clean_mask)
# Remove small contours
clean_mask = filter_small_contours(clean_mask)
return clean_mask * 255 |