Upload 14 files

ensemble/ft_g_1dpwdeeplabv3.json

@@ -42,7 +42,7 @@
   "properties": {
     "datetime": "2025-10-27T09:09:20Z",
     "created": "2025-10-27T09:09:20Z",
-    "updated": "2025-11-06T14:39:28.632388Z",
+    "updated": "2025-11-09T18:20:25.792758Z",
     "description": "DeepLabV3 + PixelWise MLP architecture fine-tuned for cloud detection in VGT-1, VGT-2, and PROBA-V satellite imagery from the FDR4VGT harmonized dataset.",
     "title": "1DPWDEEPLABV3 Cloud Detection Model - VGT1/VGT2/Proba-V (Fine-tuned)",
     "mlm:name": "1dpwdeeplabv3_fdr4vgt_cloudmask_ft",
@@ -131,7 +131,9 @@
             "color_hint": "FFFF00"
           }
         ],
-        "post_processing_function": "Apply threshold >= 0.5 for binary mask (adjustable: conservative=0.3, aggressive=0.7)",
+        "post_processing_function": "Apply threshold to get binary mask. Standard threshold: 0.5. Recommended (balanced) threshold: 0.4.",
+        "standard_threshold": 0.5,
+        "recommended_threshold": 0.4,
         "value_range": [
           0.0,
           1.0
@@ -163,7 +165,7 @@
     "custom:export_format": "torch.export.pt2",
     "custom:has_sigmoid": true,
     "custom:sigmoid_location": "built-in wrapper",
-    "custom:export_datetime": "2025-11-06T14:39:28.632388Z",
+    "custom:export_datetime": "2025-11-09T18:20:25.792758Z",
     "custom:training_datetime": "2025-10-27T09:09:20Z",
     "custom:training_stage": "fine-tuning",
     "custom:base_model_source": "global_cloudmask",

ensemble/ft_g_1dpwdeeplabv3.pt2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ba9af2a9393f46a19a87efe9279d6b298ddf3c1a26ff919c95f85da043483a5a
+oid sha256:eb1a97144e6404ac8b197c5dc3bfaf91b00abe53a80563986a69f6cb39f8361a
 size 55868251

ensemble/ft_g_1dpwseg.json

@@ -42,7 +42,7 @@
   "properties": {
     "datetime": "2025-10-27T10:10:41Z",
     "created": "2025-10-27T10:10:41Z",
-    "updated": "2025-11-06T14:39:31.359344Z",
+    "updated": "2025-11-09T18:20:30.990281Z",
     "description": "SegFormer + PixelWise MLP architecture fine-tuned for cloud detection in VGT-1, VGT-2, and PROBA-V satellite imagery from the FDR4VGT harmonized dataset.",
     "title": "1DPWSEG Cloud Detection Model - VGT1/VGT2/Proba-V (Fine-tuned)",
     "mlm:name": "1dpwseg_fdr4vgt_cloudmask_ft",
@@ -131,7 +131,9 @@
             "color_hint": "FFFF00"
           }
         ],
-        "post_processing_function": "Apply threshold >= 0.5 for binary mask (adjustable: conservative=0.3, aggressive=0.7)",
+        "post_processing_function": "Apply threshold to get binary mask. Standard threshold: 0.5. Recommended (balanced) threshold: 0.4.",
+        "standard_threshold": 0.5,
+        "recommended_threshold": 0.4,
         "value_range": [
           0.0,
           1.0
@@ -163,7 +165,7 @@
     "custom:export_format": "torch.export.pt2",
     "custom:has_sigmoid": true,
     "custom:sigmoid_location": "built-in wrapper",
-    "custom:export_datetime": "2025-11-06T14:39:31.359344Z",
+    "custom:export_datetime": "2025-11-09T18:20:30.990281Z",
     "custom:training_datetime": "2025-10-27T10:10:41Z",
     "custom:training_stage": "fine-tuning",
     "custom:base_model_source": "global_cloudmask",

ensemble/ft_g_1dpwseg.pt2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cd554de116acb3ff75f602ec6c2aaeb08a44661d2ff1fabf9c325e62cd56b3f7
+oid sha256:5fd1141ad3f77704948e9adf7ebe5edfdd2e1e1aad483fe42aa8616b7c0416da
 size 16934922

ensemble/ft_g_1dpwunet.json

@@ -42,7 +42,7 @@
   "properties": {
     "datetime": "2025-10-27T10:31:37Z",
     "created": "2025-10-27T10:31:37Z",
-    "updated": "2025-11-06T14:39:23.087913Z",
+    "updated": "2025-11-09T18:20:14.166827Z",
     "description": "UNet + PixelWise MLP architecture fine-tuned for cloud detection in VGT-1, VGT-2, and PROBA-V satellite imagery from the FDR4VGT harmonized dataset.",
     "title": "1DPWUNET Cloud Detection Model - VGT1/VGT2/Proba-V (Fine-tuned)",
     "mlm:name": "1dpwunet_fdr4vgt_cloudmask_ft",
@@ -131,7 +131,9 @@
             "color_hint": "FFFF00"
           }
         ],
-        "post_processing_function": "Apply threshold >= 0.5 for binary mask (adjustable: conservative=0.3, aggressive=0.7)",
+        "post_processing_function": "Apply threshold to get binary mask. Standard threshold: 0.5. Recommended (balanced) threshold: 0.4.",
+        "standard_threshold": 0.5,
+        "recommended_threshold": 0.4,
         "value_range": [
           0.0,
           1.0
@@ -163,7 +165,7 @@
     "custom:export_format": "torch.export.pt2",
     "custom:has_sigmoid": true,
     "custom:sigmoid_location": "built-in wrapper",
-    "custom:export_datetime": "2025-11-06T14:39:23.087913Z",
+    "custom:export_datetime": "2025-11-09T18:20:14.166827Z",
     "custom:training_datetime": "2025-10-27T10:31:37Z",
     "custom:training_stage": "fine-tuning",
     "custom:base_model_source": "global_cloudmask",

ensemble/ft_g_1dpwunet.pt2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f7dff64617de9f8c6b543cb2096cb9d447a1a1effffb1e4a8dffff9a7254dfc0
+oid sha256:b7fcaee1a0722d51acd9eb7f01d465fa32860865825f33e1531c835f216e71a9
 size 31813924

ensemble/ft_g_1dpwunetpp.json

@@ -42,7 +42,7 @@
   "properties": {
     "datetime": "2025-10-27T09:45:39Z",
     "created": "2025-10-27T09:45:39Z",
-    "updated": "2025-11-06T14:39:20.164134Z",
+    "updated": "2025-11-09T18:20:07.449926Z",
     "description": "UNet++ + PixelWise MLP architecture fine-tuned for cloud detection in VGT-1, VGT-2, and PROBA-V satellite imagery from the FDR4VGT harmonized dataset.",
     "title": "1DPWUNETPP Cloud Detection Model - VGT1/VGT2/Proba-V (Fine-tuned)",
     "mlm:name": "1dpwunetpp_fdr4vgt_cloudmask_ft",
@@ -131,7 +131,9 @@
             "color_hint": "FFFF00"
           }
         ],
-        "post_processing_function": "Apply threshold >= 0.5 for binary mask (adjustable: conservative=0.3, aggressive=0.7)",
+        "post_processing_function": "Apply threshold to get binary mask. Standard threshold: 0.5. Recommended (balanced) threshold: 0.4.",
+        "standard_threshold": 0.5,
+        "recommended_threshold": 0.4,
         "value_range": [
           0.0,
           1.0
@@ -163,7 +165,7 @@
     "custom:export_format": "torch.export.pt2",
     "custom:has_sigmoid": true,
     "custom:sigmoid_location": "built-in wrapper",
-    "custom:export_datetime": "2025-11-06T14:39:20.164134Z",
+    "custom:export_datetime": "2025-11-09T18:20:07.449926Z",
     "custom:training_datetime": "2025-10-27T09:45:39Z",
     "custom:training_stage": "fine-tuning",
     "custom:base_model_source": "global_cloudmask",

ensemble/ft_g_1dpwunetpp.pt2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9f0a35ceb55200bd5b6786fdd6bffc879fc7cab20e534ae544b774a46227093b
+oid sha256:c6bf4096004d9af6e2a954295e970d6a713ed0ba582cb0511752fe1855ac32a0
 size 32840445

ensemble/ft_g_deeplabv3.json

@@ -42,7 +42,7 @@
   "properties": {
     "datetime": "2025-10-27T11:37:50Z",
     "created": "2025-10-27T11:37:50Z",
-    "updated": "2025-11-06T14:39:40.356235Z",
+    "updated": "2025-11-09T18:20:45.623530Z",
     "description": "DeepLabV3 architecture fine-tuned for cloud detection in VGT-1, VGT-2, and PROBA-V satellite imagery from the FDR4VGT harmonized dataset.",
     "title": "DEEPLABV3 Cloud Detection Model - VGT1/VGT2/Proba-V (Fine-tuned)",
     "mlm:name": "deeplabv3_fdr4vgt_cloudmask_ft",
@@ -131,7 +131,9 @@
             "color_hint": "FFFF00"
           }
         ],
-        "post_processing_function": "Apply threshold >= 0.5 for binary mask (adjustable: conservative=0.3, aggressive=0.7)",
+        "post_processing_function": "Apply threshold to get binary mask. Standard threshold: 0.5. Recommended (balanced) threshold: 0.4.",
+        "standard_threshold": 0.5,
+        "recommended_threshold": 0.4,
         "value_range": [
           0.0,
           1.0
@@ -163,7 +165,7 @@
     "custom:export_format": "torch.export.pt2",
     "custom:has_sigmoid": true,
     "custom:sigmoid_location": "built-in wrapper",
-    "custom:export_datetime": "2025-11-06T14:39:40.356235Z",
+    "custom:export_datetime": "2025-11-09T18:20:45.623530Z",
     "custom:training_datetime": "2025-10-27T11:37:50Z",
     "custom:training_stage": "fine-tuning",
     "custom:base_model_source": "global_cloudmask",

ensemble/ft_g_deeplabv3.pt2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:035fd5da25035ee4ae7f95f5f1f6ef806a9450e081ab145fe0a0e2db6a63f4d4
+oid sha256:d20aea4a3537a852de8b32ca2fa1fcec6d79578e6dc0b981f28a6061d6532fe6
 size 55758820

ensemble/ft_g_segformer.json

@@ -42,7 +42,7 @@
   "properties": {
     "datetime": "2025-10-27T10:55:12Z",
     "created": "2025-10-27T10:55:12Z",
-    "updated": "2025-11-06T14:39:25.707855Z",
+    "updated": "2025-11-09T18:20:20.306738Z",
     "description": "SegFormer architecture fine-tuned for cloud detection in VGT-1, VGT-2, and PROBA-V satellite imagery from the FDR4VGT harmonized dataset.",
     "title": "SEGFORMER Cloud Detection Model - VGT1/VGT2/Proba-V (Fine-tuned)",
     "mlm:name": "segformer_fdr4vgt_cloudmask_ft",
@@ -131,7 +131,9 @@
             "color_hint": "FFFF00"
           }
         ],
-        "post_processing_function": "Apply threshold >= 0.5 for binary mask (adjustable: conservative=0.3, aggressive=0.7)",
+        "post_processing_function": "Apply threshold to get binary mask. Standard threshold: 0.5. Recommended (balanced) threshold: 0.4.",
+        "standard_threshold": 0.5,
+        "recommended_threshold": 0.4,
         "value_range": [
           0.0,
           1.0
@@ -163,7 +165,7 @@
     "custom:export_format": "torch.export.pt2",
     "custom:has_sigmoid": true,
     "custom:sigmoid_location": "built-in wrapper",
-    "custom:export_datetime": "2025-11-06T14:39:25.707855Z",
+    "custom:export_datetime": "2025-11-09T18:20:20.306738Z",
     "custom:training_datetime": "2025-10-27T10:55:12Z",
     "custom:training_stage": "fine-tuning",
     "custom:base_model_source": "global_cloudmask",

ensemble/ft_g_segformer.pt2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:73ff4399354bbb5144807e03492278e1c2aea57436d7ce524f89c9d193587c2b
+oid sha256:792337973bec27a2a4cd84ccaae35cccd4dee272055b74fef08cdf8882a6c824
 size 16825964

ensemble/load.py

@@ -2,17 +2,12 @@ import torch
 import torch.nn
 import pathlib
 import pystac
-import math
 from typing import Literal
-
-# --- Imports necesarios para la inferencia ---
 import numpy as np
 import itertools
 from tqdm import tqdm
 
-# --- 1. CLASE ENSEMBLE (MEJORADA Y CORREGIDA) ---
-# Esta versión es flexible y compatible con tu 'predict_large_v3'
-# (Solo devuelve probabilidades, no incertidumbre)
+# Ensemble model for combining multiple models' outputs
 class EnsembleModel(torch.nn.Module):
     def __init__(self, *models, mode="max"):
         super(EnsembleModel, self).__init__()
@@ -31,32 +26,20 @@ class EnsembleModel(torch.nn.Module):
             return None
         
         concatenated_outputs = torch.cat(outputs, dim=1)
-
-        # ¡IMPORTANTE! Tu predict_large_v3 espera UNA salida (probabilidades).
-        # Esta lógica ha sido adaptada de tu 'EnsembleModel' original.
+        
         if self.mode == "max":
-            # Usamos keepdim=True para mantener (B, 1, H, W) y ser seguros
+            # Use keepdim=True to maintain (B, 1, H, W) and be safe
             output_probs = torch.max(concatenated_outputs, dim=1, keepdim=True)[0]
         elif self.mode == "mean":
             output_probs = torch.mean(concatenated_outputs, dim=1, keepdim=True)
         elif self.mode == "min":
             output_probs = torch.min(concatenated_outputs, dim=1, keepdim=True)[0]
         elif self.mode == "none":
-            return concatenated_outputs # Devuelve (B, N, H, W)
+            return concatenated_outputs # Returns (B, N, H, W)
         else:
             raise ValueError("Mode must be 'min', 'mean', or 'max'.")
         
-        return output_probs # Devuelve (B, 1, H, W)
-
-
-# --- 2. API DE MLSTAC (FUNCIONES REQUERIDAS) ---
-
-def trainable_model(path: pathlib.Path, stac_item: pystac.Item, *args, **kwargs):
-    """
-    Este modelo de ensemble no soporta re-entrenamiento.
-    """
-    print("El modelo de ensemble no está disponible en modo de entrenamiento.")
-    return None
+        return output_probs # Returns (B, 1, H, W)
 
 def compiled_model(
     path: pathlib.Path, 
@@ -65,37 +48,35 @@ def compiled_model(
     *args, **kwargs
 ) -> EnsembleModel:
     """
-    Carga el ensemble dinámicamente usando el 'stac_item' (el ensemble.json)
-    como la ÚNICA fuente de verdad.
+    Loads the ensemble dynamically using the 'stac_item' (the ensemble.json)
+    as the ONLY source of truth.
     """
-    print("Cargando ensemble dinámicamente desde 'stac_item'...")
+    print("Loading ensemble dynamically from 'stac_item'...")
     
     model_paths = []
     
     for asset_key, asset in stac_item.assets.items():
         if asset.href.endswith(".pt2"):
-            print(f"  > Encontrado asset de modelo: {pathlib.Path(asset.href).name}")
+            print(f"  > Found model asset: {pathlib.Path(asset.href).name}")
             model_paths.append(asset.href) 
 
     if not model_paths:
-        raise ValueError("No se encontraron archivos .pt2 en los assets del STAC item.")
+        raise ValueError("No .pt2 files found in STAC item assets.")
         
-    print(f"Cargando {len(model_paths)} modelos .pt2 (en CPU)...")
+    print(f"Loading {len(model_paths)} .pt2 models (on CPU)...")
 
     model_paths.sort()
     models = [torch.export.load(p).module() for p in model_paths]
 
     cloud_model = EnsembleModel(*models, mode=mode)
     
-    print("Ensemble cargado exitosamente en CPU.")
+    print("Ensemble loaded successfully on CPU.")
     return cloud_model
 
 
-# --- 3. FUNCIONES DE INFERENCIA (HERRAMIENTAS) ---
-
 def define_iteration(dimension: tuple, chunk_size: int, overlap: int = 0):
     """
-    Define la estrategia de iteración para recorrer la imagen con solapamiento.
+    Defines iteration strategy to traverse the image with overlap.
     """
     dimy, dimx = dimension
     if chunk_size > max(dimx, dimy):
@@ -111,7 +92,7 @@ def define_iteration(dimension: tuple, chunk_size: int, overlap: int = 0):
 
 def fix_lastchunk(iterchunks, s2dim, chunk_size):
     """
-    Ajusta los últimos chunks para que no se salgan de los bordes.
+    Adjusts last chunks to prevent them from exceeding boundaries.
     """
     itercontainer = []
     for index_i, index_j in iterchunks:
@@ -120,37 +101,39 @@ def fix_lastchunk(iterchunks, s2dim, chunk_size):
         if index_j + chunk_size > s2dim[1]:
             index_j = max(s2dim[1] - chunk_size, 0)
         itercontainer.append((index_i, index_j))
-    return list(set(itercontainer)) # Devuelve únicos por si acaso
+    return list(set(itercontainer)) # Returns unique values just in case
 
 
-def predict_large_array(
-    image_array: np.ndarray,
-    cloud_model: torch.nn.Module,
+def predict_large(
+    image: np.ndarray,
+    model: torch.nn.Module,
     chunk_size: int = 512,
-    overlap: int = 32,
-    device: str = "cpu"
+    overlap: int = 64,
+    device: str = "cpu",
+    nodata: float = 0.0
 ) -> np.ndarray:
     """
-    Predice un 'image_array' (C, H, W) completo en parches solapados.
+    Predict a full 'image' (C, H, W) using overlapping patches.
     
-    Esta es una versión modificada de 'predict_large_v3' que:
-    1. Acepta un np.ndarray en lugar de paths.
-    2. Devuelve un np.ndarray (máscara de prob) en lugar de guardar en disco.
+    This is a modified version of 'predict_large_v3' that:
+    1. Accepts an np.ndarray instead of file paths.
+    2. Returns an np.ndarray (probability mask) instead of saving to disk.
+    3. Handles tiles smaller than chunk_size via padding.
     
-    Compatible con:
-    - Modelos normales (con .eval())
-    - Modelos exportados (.pt2) y Ensembles (sin .eval())
+    Compatible with:
+    - Normal models (with .eval())
+    - Exported models (.pt2) and Ensembles (without .eval())
     """
     
-    # 1) Validar metadata desde el array
-    if image_array.ndim != 3:
-        raise ValueError(f"Input array debe ser (C, H, W). Se recibió {image_array.shape}")
+    # 1) Validate input array dimensions
+    if image.ndim != 3:
+        raise ValueError(f"Input array must be (C, H, W). Received {image.shape}")
     
-    bands, height, width = image_array.shape
-    print(f"Iniciando predicción en array de shape: {(bands, height, width)}")
+    bands, height, width = image.shape
+    print(f"Starting prediction on array with shape: {(bands, height, width)}")
 
-    # 2) Preparar array de salida (1-band float)
-    output_array = np.zeros((1, height, width), dtype=np.float32)
+    # 2) Initialize output array (1-band float) with nodata values
+    output_array = np.full((1, height, width), nodata, dtype=np.float32)
 
     # 3) Get the list of tile offsets
     coords = define_iteration(
@@ -159,36 +142,59 @@ def predict_large_array(
         overlap=overlap
     )
 
-    # 4) Preparar modelo (lógica de compatibilidad .pt2)
+    # 4) Prepare model (compatibility logic for .pt2 models)
     try:
-        cloud_model.eval()
-        for p in cloud_model.parameters():
+        model.eval()
+        for p in model.parameters():
             p.requires_grad = False
-        cloud_model = cloud_model.to(device)
+        model = model.to(device)
     except (NotImplementedError, AttributeError):
-        # Es modelo exportado (.pt2) o EnsembleModel
-        cloud_model = cloud_model.to(device)
+        # Exported model (.pt2) or EnsembleModel
+        model = model.to(device)
 
-    # 5) Iterar sobre los tiles (solo con numpy)
+    # 5) Iterate over tiles (using numpy only)
     for idx, (row_off, col_off) in enumerate(tqdm(coords, desc="Inference")):
         
-        # (a) Leer chunk (slicing de Numpy)
-        patch = image_array[
+        # (a) Read chunk (numpy slicing)
+        patch = image[
             :,
             row_off : row_off + chunk_size,
             col_off : col_off + chunk_size
         ]
 
-        # (b) Forward pass
+        # (b) Convert to tensor and handle padding if tile is smaller than chunk_size
         patch_tensor = torch.from_numpy(patch).float().unsqueeze(0).to(device)
+        _, _, h_tile, w_tile = patch_tensor.shape
+        
+        # Calculate padding needed
+        pad_h = chunk_size - h_tile
+        pad_w = chunk_size - w_tile
+        
+        # Apply padding if necessary
+        if pad_h > 0 or pad_w > 0:
+            patch_tensor = torch.nn.functional.pad(
+                patch_tensor, (0, pad_w, 0, pad_h), "constant", nodata
+            )
+        
+        # Create mask for nodata areas (all bands are nodata)
+        mask_all = (patch_tensor == nodata).all(dim=1, keepdim=True)
+        
+        # Forward pass
         with torch.no_grad():
-            # Asumimos que el modelo (o ensemble) devuelve probabilidades (B, 1, H, W)
-            probs = cloud_model(patch_tensor)
+            # Assume the model (or ensemble) returns probabilities (B, 1, H, W)
+            probs = model(patch_tensor)
+            
+            # Apply nodata mask to output
+            probs = probs.masked_fill(mask_all, nodata)
+        
+        # Remove batch dimension and ensure (1, H, W)
+        if probs.ndim == 4:
+            probs = probs.squeeze(0)  # (1, H, W)
         
-        # .squeeze(0) -> quita la dimensión de batch (1, H, W)
-        result = probs.squeeze(0).cpu().numpy() 
+        # Convert to numpy
+        result = probs.cpu().numpy()  # (1, H, W)
 
-        # (c-f) Lógica de escritura parcial
+        # (c-f) Logic for partial writing
         if col_off == 0:
             offset_x = 0
         else:
@@ -213,19 +219,26 @@ def predict_large_array(
             length_y = chunk_size - (overlap // 2)
             sub_y_start = overlap // 2 if row_off != 0 else 0
 
+        # Ensure we don't exceed array bounds
+        if offset_y + length_y > height:
+            length_y = height - offset_y
+        if offset_x + length_x > width:
+            length_x = width - offset_x
+
+        # Extract the valid region from the result
         to_write = result[
             :,
             sub_y_start : sub_y_start + length_y,
             sub_x_start : sub_x_start + length_x
         ]
 
-        # Escribir en el array de salida de numpy
+        # Write to the output numpy array
         output_array[
             :,
             offset_y : offset_y + length_y,
             offset_x : offset_x + length_x
         ] = to_write
 
-    print("Predicción completada.")
-    # Devuelve el array de (1, H, W)
+    print("Prediction completed.")
+    # Return the array of shape (1, H, W)
     return output_array