Update the seamless FIM evaluation methods within FIMserv (#32)

* added seamless mapping using BLE synthtic flows for evaluation

* update the final check for tagged metadata for FIM

* update high water marks based FIM generation and evaluation module

* greatly added and enhanced the evaluation module using fimeval and fimbench

Author: supathdhitalGEO

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fimserve"
-version = "0.1.93"
+version = "0.1.94"
 description = "Framework which is developed with the purpose of quickly generating Flood Inundation Maps (FIM) for emergency response and risk assessment. It is developed under Surface Dynamics Modeling Lab (SDML)."
 authors = [{ name = "Supath Dhital", email = "sdhital@crimson.ua.edu" }]
 maintainers = [{ name = "Supath Dhital", email = "sdhital@crimson.ua.edu" }]
@@ -34,7 +34,8 @@ dependencies = [
     "notebook>=6.5.7",
     "geocube<=0.7.1",
     "geopandas>=0.14.3",
-    "fimeval>=0.1.59"
+    "fimeval>=0.1.59",
+    "setuptools>=82.0.0",
 ]
 
 [project.optional-dependencies]
@@ -73,4 +74,4 @@ exclude = ["tests*"]
 [tool.pytest.ini_options]
 minversion = "6.0"
 addopts = "-ra -q"
-testpaths = ["tests"]
+testpaths = ["tests"]

src/fimserve/__init__.py

@@ -27,34 +27,39 @@
 # Fim visualization
 from .vizualizationFIM import vizualizeFIM
 
-
 # Statistics
 from .statistics.calculatestatistics import CalculateStatistics
 
 # For intersected HUC8 boundary
 from .intersectedHUC import getIntersectedHUC8ID
 
-
 # evaluation of FIM
 from .fimevaluation.fims_setup import FIMService, fim_lookup
 from .fimevaluation.run_fimeval import run_evaluation
 
 
-#Enhancement using surrogate models [Importing those only if they are called]
+# Enhancement using surrogate models [Importing those only if they are called]
 def prepare_FORCINGs(*args, **kwargs):
     from .enhancement_withSM.preprocessFIM import prepare_FORCINGs as _impl
+
     return _impl(*args, **kwargs)
 
+
 def enhanceFIM(*args, **kwargs):
     from .enhancement_withSM.SM_prediction import enhanceFIM as _impl
+
     return _impl(*args, **kwargs)
 
+
 def getbuilding_exposure(*args, **kwargs):
     from .enhancement_withSM.building_exposure import getbuilding_exposure as _impl
+
     return _impl(*args, **kwargs)
 
+
 def getpopulation_exposure(*args, **kwargs):
     from .enhancement_withSM.pop_exposure import getpopulation_exposure as _impl
+
     return _impl(*args, **kwargs)
 
 

src/fimserve/enhancement_withSM/SM_prediction.py

@@ -8,22 +8,22 @@
 from .surrogate_model import *
 from .utlis import *
 from .preprocessFIM import *
-        
+
 
 # MODEL LOADING
 def load_model(model):
     """Downloads and loads the model checkpoint."""
     fs = s3fs.S3FileSystem(anon=True)
     bucket_path = "sdmlab/SM_dataset/trained_model/SM_trainedmodel.ckpt"
 
-    with fs.open(bucket_path, 'rb') as s3file:
+    with fs.open(bucket_path, "rb") as s3file:
         with tempfile.NamedTemporaryFile(suffix=".ckpt", delete=False) as tmp_ckpt:
             tmp_ckpt.write(s3file.read())
             tmp_ckpt_path = tmp_ckpt.name
 
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     checkpoint = torch.load(tmp_ckpt_path, map_location=device)
-    model.load_state_dict(checkpoint['state_dict'])
+    model.load_state_dict(checkpoint["state_dict"])
     model.to(device)
     model.eval()
 
@@ -39,42 +39,54 @@ def create_weight_map(M: int, N: int, device):
 
     # Vectorized calculation
     Y, X = np.ogrid[:M, :N]
-    dist_sq = (X - center_y)**2 + (Y - center_x)**2
-    weight_map = np.exp(-dist_sq / (2 * (min(M, N) / 2)**2))
+    dist_sq = (X - center_y) ** 2 + (Y - center_x) ** 2
+    weight_map = np.exp(-dist_sq / (2 * (min(M, N) / 2) ** 2))
 
     # FIX: Only unsqueeze once to get shape (1, M, N)
     return torch.from_numpy(weight_map).float().unsqueeze(0).to(device)
 
+
 def save_image(image: torch.Tensor, path: Path, reference_tif: str):
     """Saves the prediction tensor as a GeoTIFF."""
-    image_np = image.squeeze().cpu().numpy().astype('float32')
+    image_np = image.squeeze().cpu().numpy().astype("float32")
     with rasterio.open(reference_tif) as ref:
         meta = ref.meta.copy()
-        meta.update({
-            "driver": "GTiff",
-            "height": image_np.shape[0],
-            "width": image_np.shape[1],
-            "count": 1,
-            "dtype": 'float32'
-        })
-
-        with rasterio.open(path, 'w', **meta) as dst:
+        meta.update(
+            {
+                "driver": "GTiff",
+                "height": image_np.shape[0],
+                "width": image_np.shape[1],
+                "count": 1,
+                "dtype": "float32",
+            }
+        )
+
+        with rasterio.open(path, "w", **meta) as dst:
             dst.write(image_np, 1)
 
         # Apply water body mask
         mask_with_PWB(path, path)
 
         # Binarize and compress
-        with rasterio.open(path, 'r+') as dst:
+        with rasterio.open(path, "r+") as dst:
             data = dst.read(1)
             binary_data = np.where(data > 0, 1, 0).astype(np.uint8)
             dst.write(binary_data, 1)
 
         compress_tif_lzw(path)
 
+
 # REDICTION
-def predict_optimized(dataset, model, shape: torch.Tensor, M: int = 256, N: int = 256,
-                      stride: int = 128, device=None, batch_size=32):
+def predict_optimized(
+    dataset,
+    model,
+    shape: torch.Tensor,
+    M: int = 256,
+    N: int = 256,
+    stride: int = 128,
+    device=None,
+    batch_size=32,
+):
     """
     Highly optimized prediction loop.
     - Uses VIEWs instead of COPIES for memory efficiency.
@@ -88,16 +100,20 @@ def predict_optimized(dataset, model, shape: torch.Tensor, M: int = 256, N: int
     elif sorted(dataset.x_feature_index) == list(range(shape.shape[0])):
         X = shape[:]
     else:
-        print("Warning: Creating tensor copy for non-contiguous indices (High RAM usage)")
+        print(
+            "Warning: Creating tensor copy for non-contiguous indices (High RAM usage)"
+        )
         X = shape[dataset.x_feature_index]
 
     y = shape[dataset.y_feature_index]
 
     img_channels, img_rows, img_cols = X.shape
 
     # SETUP OUTPUT ACCUMULATORS (On CPU)
-    weighted_prediction_sum = torch.zeros((1, img_rows, img_cols), dtype=torch.float32, device='cpu')
-    weight_sum = torch.zeros((1, img_rows, img_cols), dtype=torch.float32, device='cpu')
+    weighted_prediction_sum = torch.zeros(
+        (1, img_rows, img_cols), dtype=torch.float32, device="cpu"
+    )
+    weight_sum = torch.zeros((1, img_rows, img_cols), dtype=torch.float32, device="cpu")
 
     # Weight map: Shape (1, M, N)
     weight_map_gpu = create_weight_map(M, N, device)
@@ -127,7 +143,7 @@ def predict_optimized(dataset, model, shape: torch.Tensor, M: int = 256, N: int
             if h_valid < M or w_valid < N:
                 pad_h = M - h_valid
                 pad_w = N - w_valid
-                patch = F.pad(patch, (0, pad_w, 0, pad_h), mode='constant', value=0)
+                patch = F.pad(patch, (0, pad_w, 0, pad_h), mode="constant", value=0)
 
             batch_patches.append(patch)
             batch_coords.append((r, r_end, c, c_end, h_valid, w_valid))
@@ -144,18 +160,23 @@ def predict_optimized(dataset, model, shape: torch.Tensor, M: int = 256, N: int
                     pred_valid = preds[k, :, :h_val, :w_val]
                     weight_valid = weight_map_cpu[:, :h_val, :w_val]
 
-                    weighted_prediction_sum[:, r0:r1, c0:c1] += pred_valid * weight_valid
+                    weighted_prediction_sum[:, r0:r1, c0:c1] += (
+                        pred_valid * weight_valid
+                    )
                     weight_sum[:, r0:r1, c0:c1] += weight_valid
 
                 processed_steps += len(batch_patches)
-                print(f"   Progress: {processed_steps}/{total_steps} ({100*processed_steps/total_steps:.1f}%)", end='\r')
+                print(
+                    f"   Progress: {processed_steps}/{total_steps} ({100*processed_steps/total_steps:.1f}%)",
+                    end="\r",
+                )
 
                 batch_patches = []
                 batch_coords = []
                 del batch_tensor, preds
 
                 if processed_steps % (batch_size * 10) == 0:
-                     torch.cuda.empty_cache()
+                    torch.cuda.empty_cache()
 
     # Process remaining patches
     if batch_patches:
@@ -178,21 +199,24 @@ def predict_optimized(dataset, model, shape: torch.Tensor, M: int = 256, N: int
 
     lf_idx = dataset.lf_index
     if isinstance(shape, torch.Tensor):
-         lf = shape[lf_idx].unsqueeze(0)
+        lf = shape[lf_idx].unsqueeze(0)
     else:
-         lf = None
+        lf = None
 
     return final_prediction, y, lf
 
+
 # MAIN FUNCTION
 def enhanceFIM(huc_id, patch_size=(256, 256), batch_size=32):
 
-    device_type = 'cuda' if torch.cuda.is_available() else 'cpu'
+    device_type = "cuda" if torch.cuda.is_available() else "cpu"
     print(f"\n{'='*60}\nSYSTEM: {device_type.upper()}\n{'='*60}")
 
-    data_dir = Path(f'./HUC{huc_id}_forcings/')
+    data_dir = Path(f"./HUC{huc_id}_forcings/")
     model = AttentionUNet(channel=8)
-    preprocessor = InferenceDataPreprocessor(data_dir=Path(data_dir), patch_size=patch_size, verbose=True)
+    preprocessor = InferenceDataPreprocessor(
+        data_dir=Path(data_dir), patch_size=patch_size, verbose=True
+    )
 
     print("Loading model...")
     model, device = load_model(model)
@@ -204,7 +228,7 @@ def enhanceFIM(huc_id, patch_size=(256, 256), batch_size=32):
         print(f"\nProcessing [{idx}/{len(lf_files)}]: {lf_filename}")
 
         static_stack = preprocessor.get_static_stack(huc_id)
-        lf_tensor = preprocessor.tif_to_tensor(lf_path, feature_name='low_fidelity')
+        lf_tensor = preprocessor.tif_to_tensor(lf_path, feature_name="low_fidelity")
 
         print("Merging tensors...")
         area_tensor = torch.cat([static_stack, lf_tensor], dim=0)
@@ -213,7 +237,9 @@ def enhanceFIM(huc_id, patch_size=(256, 256), batch_size=32):
         del lf_tensor
         gc.collect()
 
-        print(f"Tensor Shape: {area_tensor.shape} | Memory: {area_tensor.element_size() * area_tensor.nelement() / 1e9:.2f} GB")
+        print(
+            f"Tensor Shape: {area_tensor.shape} | Memory: {area_tensor.element_size() * area_tensor.nelement() / 1e9:.2f} GB"
+        )
 
         class Dummy:
             x_feature_index = slice(None)
@@ -229,7 +255,7 @@ class Dummy:
                 N=patch_size[1],
                 stride=patch_size[0] // 2,
                 device=device,
-                batch_size=batch_size
+                batch_size=batch_size,
             )
 
         except RuntimeError as e:
@@ -238,15 +264,21 @@ class Dummy:
                 torch.cuda.empty_cache()
                 gc.collect()
                 x, y, lf = predict_optimized(
-                    Dummy, model, area_tensor, M=patch_size[0], N=patch_size[1],
-                    stride=patch_size[0] // 2, device=device, batch_size=4
+                    Dummy,
+                    model,
+                    area_tensor,
+                    M=patch_size[0],
+                    N=patch_size[1],
+                    stride=patch_size[0] // 2,
+                    device=device,
+                    batch_size=4,
                 )
             else:
                 raise e
 
         del area_tensor
         gc.collect()
-        if device.type == 'cuda':
+        if device.type == "cuda":
             torch.cuda.empty_cache()
 
         pred_dir = Path(f"./Results/HUC{huc_id}/")
@@ -256,4 +288,4 @@ class Dummy:
         save_image(x, pred_path, str(lf_path))
         print(f"✓ Saved: {pred_path}")
 
-    print(f"\n{'='*60}\nCOMPLETED\n{'='*60}")
+    print(f"\n{'='*60}\nCOMPLETED\n{'='*60}")