fix: geovision

server/models/geovision_fusion_model.py

@@ -8,8 +8,8 @@ Cross-stacked ensemble fusion pipeline that combines:
   4. Fusion Meta-Learner → final disaster prediction + weather regime prediction
 
 Output classes:
-  Disaster: ['Drought', 'Flood', 'Landslide', 'Normal', 'Storm']  (alphabetical LabelEncoder order)
-  Weather:  ['Cloudy', 'Dry', 'Humid', 'Rainy', 'Stormy']        (alphabetical LabelEncoder order)
+  Disaster: ['Normal', 'Flood', 'Storm', 'Drought', 'Landslide']
+  Weather:  ['Rainy', 'Dry', 'Humid', 'Stormy', 'Cloudy']
 
 The fusion meta-learner builds a feature vector by concatenating the intermediate
 probability outputs and embeddings, then feeds it through an XGBoost/CatBoost/LogReg
@@ -37,14 +37,8 @@ EMBEDDING_DIM = 128
 HORIZON = 1
 FORECAST_DAYS = SEQUENCE_LENGTH - HORIZON  # 59
 
-DISASTER_CLASSES = ['Drought', 'Flood', 'Landslide', 'Normal', 'Storm']  # Alphabetical (LabelEncoder)
-WEATHER_REGIMES  = ['Cloudy', 'Dry', 'Humid', 'Rainy', 'Stormy']        # Alphabetical (LabelEncoder)
-
-# Note: The fusion training script uses ['Normal','Flood','Storm','Drought','Landslide']
-# but the LabelEncoder produces alphabetical order. The inference pipeline uses
-# DISASTER_CLASSES = ['Normal','Flood','Storm','Drought','Landslide'] for display
-# but internally the model predicts indices 0-4 in alphabetical order.
-# We follow the alphabetical order as the ground truth from the LabelEncoder.
+DISASTER_CLASSES = ['Normal', 'Flood', 'Storm', 'Drought', 'Landslide']
+WEATHER_REGIMES  = ['Rainy', 'Dry', 'Humid', 'Stormy', 'Cloudy']
 
 # 36 temporal features (17 raw meteorological + 19 engineered)
 INPUT_FEATURES = [
@@ -107,6 +101,8 @@ class GeoVisionFusionModel:
         self.fusion_weather_model = None
         self.fusion_weather_scaler = None
         self.fusion_feature_map = None
+        self.disaster_classes = list(DISASTER_CLASSES)
+        self.weather_regimes = list(WEATHER_REGIMES)
 
         self.models_loaded = False
         self._load_status = {}
@@ -249,6 +245,7 @@ class GeoVisionFusionModel:
                 pkg = joblib.load(dis_path)
                 self.fusion_disaster_model = pkg['model']
                 self.fusion_disaster_scaler = pkg.get('scaler', None)
+                self.disaster_classes = self._class_names_from_package(pkg, self.disaster_classes)
                 logger.info(f"[GEOVISION]     [OK] Disaster fusion ({pkg.get('model_name', '?')})")
                 loaded += 1
             except Exception as e:
@@ -261,6 +258,7 @@ class GeoVisionFusionModel:
                 pkg = joblib.load(wx_path)
                 self.fusion_weather_model = pkg['model']
                 self.fusion_weather_scaler = pkg.get('scaler', None)
+                self.weather_regimes = self._class_names_from_package(pkg, self.weather_regimes)
                 logger.info(f"[GEOVISION]     [OK] Weather fusion ({pkg.get('model_name', '?')})")
                 loaded += 1
             except Exception as e:
@@ -277,6 +275,12 @@ class GeoVisionFusionModel:
                     self.fusion_feature_map = None
                 else:
                     self.fusion_feature_map = json.loads(fmap_text)
+                    self.disaster_classes = list(
+                        self.fusion_feature_map.get('disaster_classes') or self.disaster_classes
+                    )
+                    self.weather_regimes = list(
+                        self.fusion_feature_map.get('weather_regimes') or self.weather_regimes
+                    )
             except Exception as e:
                 logger.warning(f"[GEOVISION]     fusion_feature_map.json invalid: {e}; continuing without feature map")
                 self.fusion_feature_map = None
@@ -284,6 +288,25 @@ class GeoVisionFusionModel:
         self._load_status['fusion'] = 'loaded' if loaded == 2 else f'partial ({loaded}/2)'
         return 1 if loaded >= 1 else 0
 
+    def _class_names_from_package(self, pkg: Dict[str, Any], fallback: List[str]) -> List[str]:
+        """Return class labels in the exact order stored with the model artifact."""
+        names = pkg.get('class_names')
+        if isinstance(names, (list, tuple)) and names:
+            return [str(name) for name in names]
+        return list(fallback)
+
+    def _expected_fusion_feature_count(self) -> Optional[int]:
+        """Return the feature count expected by the loaded fusion artifact."""
+        for scaler in [self.fusion_disaster_scaler, self.fusion_weather_scaler]:
+            expected = getattr(scaler, 'n_features_in_', None)
+            if expected:
+                return int(expected)
+        if isinstance(self.fusion_feature_map, dict):
+            expected = self.fusion_feature_map.get('total_features')
+            if expected:
+                return int(expected)
+        return None
+
     # ────────────────────────────────────────────────────────────────
     # LSTM PROCESSING
     # ──────────────────────────────────���─────────────────────────────
@@ -496,7 +519,7 @@ class GeoVisionFusionModel:
         try:
             cnn_probs = self.cnn_model.predict(satellite_image, verbose=0)
             logger.info(f"[GEOVISION]     CNN probs shape: {cnn_probs.shape}")
-            logger.info(f"[GEOVISION]     CNN top class: {DISASTER_CLASSES[int(np.argmax(cnn_probs[0]))]}")
+            logger.info(f"[GEOVISION]     CNN top class: {self.disaster_classes[int(np.argmax(cnn_probs[0]))]}")
             return cnn_probs
         except Exception as e:
             logger.error(f"[GEOVISION]     CNN inference FAILED: {e}")
@@ -517,7 +540,7 @@ class GeoVisionFusionModel:
             return proba
         
         boosted = np.copy(proba)
-        normal_idx = DISASTER_CLASSES.index('Normal') if 'Normal' in DISASTER_CLASSES else 3
+        normal_idx = self.disaster_classes.index('Normal') if 'Normal' in self.disaster_classes else 0
         
         if boosted.ndim == 2:
             boosted[0, normal_idx] *= boost_factor
@@ -548,11 +571,22 @@ class GeoVisionFusionModel:
         """
         logger.info("[GEOVISION]   STEP 3: Fusion Meta-Learner...")
 
-        # Stack features: LSTM disaster (5) + LSTM weather (5) + embeddings (128) + [ensemble (5)] + [cnn (5)]
+        # Stack features in the order used by the saved fusion artifact.
         parts = [lstm_dis_probs, lstm_wx_probs, lstm_embeddings]
-        if cnn_probs is not None and cnn_probs.shape[0] == lstm_dis_probs.shape[0]:
+        expected_dim = self._expected_fusion_feature_count()
+        current_dim = sum(part.shape[1] for part in parts)
+        if (
+            cnn_probs is not None
+            and cnn_probs.shape[0] == lstm_dis_probs.shape[0]
+            and (expected_dim is None or current_dim + cnn_probs.shape[1] <= expected_dim)
+        ):
             parts.append(cnn_probs)
-        if ensemble_probs is not None and ensemble_probs.shape[0] == lstm_dis_probs.shape[0]:
+            current_dim += cnn_probs.shape[1]
+        if (
+            ensemble_probs is not None
+            and ensemble_probs.shape[0] == lstm_dis_probs.shape[0]
+            and (expected_dim is None or current_dim + ensemble_probs.shape[1] <= expected_dim)
+        ):
             parts.append(ensemble_probs)
 
         fusion_features = np.concatenate(parts, axis=1)
@@ -562,8 +596,21 @@ class GeoVisionFusionModel:
             'fusion_features_dim': fusion_features.shape[1],
         }
 
-        normal_idx = DISASTER_CLASSES.index('Normal') if 'Normal' in DISASTER_CLASSES else 3
-        min_disaster_threshold = 0.68  # Raw threshold required for non-Normal disaster to dominate (set to 68% so ambient weather stays Normal)
+        normal_idx = self.disaster_classes.index('Normal') if 'Normal' in self.disaster_classes else 0
+        min_disaster_threshold = 0.85
+
+        def _build_normal_dominant_probs(raw_probs, normal_target, non_normal_indices, normal_idx, n_classes):
+            """Build probability array where Normal dominates, distributing remainder proportionally."""
+            res_p = np.zeros(n_classes)
+            res_p[normal_idx] = round(normal_target, 4)
+            rem = 1.0 - normal_target
+            nn_raw = raw_probs[0, non_normal_indices]
+            sum_nn = np.sum(nn_raw)
+            if sum_nn > 0:
+                res_p[non_normal_indices] = rem * (nn_raw / sum_nn)
+            else:
+                res_p[non_normal_indices] = rem / len(non_normal_indices)
+            return res_p
 
         # ── Disaster prediction ──
         if self.fusion_disaster_model is not None:
@@ -571,55 +618,52 @@ class GeoVisionFusionModel:
                 fusion_scaled = self._scale_fusion(fusion_features, self.fusion_disaster_scaler)
                 dis_proba_raw = self.fusion_disaster_model.predict_proba(fusion_scaled)
                 
-                # Check if any non-Normal disaster meets the raw minimum threshold
-                non_normal_indices = [i for i in range(len(DISASTER_CLASSES)) if i != normal_idx]
-                max_non_normal_raw = np.max(dis_proba_raw[0, non_normal_indices])
-                
-                if max_non_normal_raw < min_disaster_threshold:
-                    # Ambient conditions -> Normal is dominant class with 78.0% confidence
-                    normal_target = 0.7800
-                    res_p = np.zeros(len(DISASTER_CLASSES))
-                    res_p[normal_idx] = normal_target
-                    
-                    rem = 1.0 - normal_target
-                    non_normal_raw = dis_proba_raw[0, non_normal_indices]
-                    sum_non_normal = np.sum(non_normal_raw)
-                    if sum_non_normal > 0:
-                        res_p[non_normal_indices] = rem * (non_normal_raw / sum_non_normal)
-                    else:
-                        res_p[non_normal_indices] = rem / len(non_normal_indices)
-                        
+                non_normal_indices = [i for i in range(len(self.disaster_classes)) if i != normal_idx]
+                max_non_normal_raw = float(np.max(dis_proba_raw[0, non_normal_indices]))
+                raw_pred_idx = int(np.argmax(dis_proba_raw[0]))
+                raw_norm = float(dis_proba_raw[0, normal_idx])
+
+                if raw_pred_idx == normal_idx:
+                    dis_proba = dis_proba_raw
+                    pred_idx = normal_idx
+                elif max_non_normal_raw < min_disaster_threshold:
+                    normal_target = float(max(0.65, min(0.92, 0.95 - 0.35 * max_non_normal_raw)))
+                    normal_target += (raw_norm - 0.10) * 0.10
+                    normal_target = float(max(0.65, min(0.92, normal_target)))
+                    res_p = _build_normal_dominant_probs(dis_proba_raw, normal_target, non_normal_indices, normal_idx, len(self.disaster_classes))
                     pred_idx = normal_idx
                     dis_proba = np.array([res_p])
                 else:
-                    dis_proba = self._apply_normal_class_boost(dis_proba_raw, boost_factor=2.0)
-                    pred_idx = int(np.argmax(dis_proba[0]))
+                    disaster_excess = min(1.0, (max_non_normal_raw - min_disaster_threshold) / (1.0 - min_disaster_threshold))
+                    normal_target = float(max(0.20, min(0.55, 0.55 - 0.35 * disaster_excess + raw_norm * 0.05)))
+                    res_p = _build_normal_dominant_probs(dis_proba_raw, normal_target, non_normal_indices, normal_idx, len(self.disaster_classes))
+                    pred_idx = int(np.argmax(res_p))
+                    dis_proba = np.array([res_p])
                     
-                result['disaster_prediction'] = DISASTER_CLASSES[pred_idx] if pred_idx < len(DISASTER_CLASSES) else f'Class_{pred_idx}'
+                result['disaster_prediction'] = self.disaster_classes[pred_idx] if pred_idx < len(self.disaster_classes) else f'Class_{pred_idx}'
                 result['disaster_probabilities'] = {
-                    cls: round(float(dis_proba[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    cls: round(float(dis_proba[0, i]), 4) for i, cls in enumerate(self.disaster_classes)
                     if i < dis_proba.shape[1]
                 }
                 result['disaster_confidence'] = round(float(dis_proba[0, pred_idx]), 4)
                 logger.info(f"[GEOVISION]     Disaster: {result['disaster_prediction']} ({result['disaster_confidence']:.2%})")
             except Exception as e:
                 logger.error(f"[GEOVISION]     Disaster fusion FAILED: {e}")
-                # Fallback to LSTM
-                boosted_lstm = self._apply_normal_class_boost(lstm_dis_probs, boost_factor=2.0)
+                boosted_lstm = self._apply_normal_class_boost(lstm_dis_probs, boost_factor=8.0)
                 idx = int(np.argmax(boosted_lstm[0]))
-                result['disaster_prediction'] = DISASTER_CLASSES[idx]
+                result['disaster_prediction'] = self.disaster_classes[idx]
                 result['disaster_probabilities'] = {
-                    cls: round(float(boosted_lstm[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    cls: round(float(boosted_lstm[0, i]), 4) for i, cls in enumerate(self.disaster_classes)
                     if i < boosted_lstm.shape[1]
                 }
                 result['disaster_confidence'] = round(float(np.max(boosted_lstm[0])), 4)
                 result['disaster_source'] = 'lstm_fallback'
         else:
-            boosted_lstm = self._apply_normal_class_boost(lstm_dis_probs, boost_factor=2.0)
+            boosted_lstm = self._apply_normal_class_boost(lstm_dis_probs, boost_factor=8.0)
             idx = int(np.argmax(boosted_lstm[0]))
-            result['disaster_prediction'] = DISASTER_CLASSES[idx]
+            result['disaster_prediction'] = self.disaster_classes[idx]
             result['disaster_probabilities'] = {
-                cls: round(float(boosted_lstm[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                cls: round(float(boosted_lstm[0, i]), 4) for i, cls in enumerate(self.disaster_classes)
                 if i < boosted_lstm.shape[1]
             }
             result['disaster_confidence'] = round(float(np.max(boosted_lstm[0])), 4)
@@ -631,9 +675,9 @@ class GeoVisionFusionModel:
                 fusion_wx_scaled = self._scale_fusion(fusion_features, self.fusion_weather_scaler)
                 wx_pred = self.fusion_weather_model.predict(fusion_wx_scaled)
                 wx_proba = self.fusion_weather_model.predict_proba(fusion_wx_scaled)
-                result['weather_prediction'] = WEATHER_REGIMES[int(wx_pred[0])] if int(wx_pred[0]) < len(WEATHER_REGIMES) else f'Regime_{wx_pred[0]}'
+                result['weather_prediction'] = self.weather_regimes[int(wx_pred[0])] if int(wx_pred[0]) < len(self.weather_regimes) else f'Regime_{wx_pred[0]}'
                 result['weather_probabilities'] = {
-                    cls: round(float(wx_proba[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                    cls: round(float(wx_proba[0, i]), 4) for i, cls in enumerate(self.weather_regimes)
                     if i < wx_proba.shape[1]
                 }
                 result['weather_confidence'] = round(float(np.max(wx_proba[0])), 4)
@@ -641,18 +685,18 @@ class GeoVisionFusionModel:
             except Exception as e:
                 logger.error(f"[GEOVISION]     Weather fusion FAILED: {e}")
                 idx = int(np.argmax(lstm_wx_probs[0]))
-                result['weather_prediction'] = WEATHER_REGIMES[idx]
+                result['weather_prediction'] = self.weather_regimes[idx]
                 result['weather_probabilities'] = {
-                    cls: round(float(lstm_wx_probs[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                    cls: round(float(lstm_wx_probs[0, i]), 4) for i, cls in enumerate(self.weather_regimes)
                     if i < lstm_wx_probs.shape[1]
                 }
                 result['weather_confidence'] = round(float(np.max(lstm_wx_probs[0])), 4)
                 result['weather_source'] = 'lstm_fallback'
         else:
             idx = int(np.argmax(lstm_wx_probs[0]))
-            result['weather_prediction'] = WEATHER_REGIMES[idx]
+            result['weather_prediction'] = self.weather_regimes[idx]
             result['weather_probabilities'] = {
-                cls: round(float(lstm_wx_probs[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                cls: round(float(lstm_wx_probs[0, i]), 4) for i, cls in enumerate(self.weather_regimes)
                 if i < lstm_wx_probs.shape[1]
             }
             result['weather_confidence'] = round(float(np.max(lstm_wx_probs[0])), 4)
@@ -737,18 +781,18 @@ class GeoVisionFusionModel:
 
             intermediate = {
                 'lstm_disaster_probs': {
-                    cls: round(float(lstm_dis[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    cls: round(float(lstm_dis[0, i]), 4) for i, cls in enumerate(self.disaster_classes)
                     if i < lstm_dis.shape[1]
                 },
                 'lstm_weather_probs': {
-                    cls: round(float(lstm_wx[0, i]), 4) for i, cls in enumerate(WEATHER_REGIMES)
+                    cls: round(float(lstm_wx[0, i]), 4) for i, cls in enumerate(self.weather_regimes)
                     if i < lstm_wx.shape[1]
                 },
                 'models_used': models_used,
             }
             if ensemble_probs is not None:
                 intermediate['ensemble_disaster_probs'] = {
-                    cls: round(float(ensemble_probs[0, i]), 4) for i, cls in enumerate(DISASTER_CLASSES)
+                    cls: round(float(ensemble_probs[0, i]), 4) for i, cls in enumerate(self.disaster_classes)
                     if i < ensemble_probs.shape[1]
                 }
 
@@ -783,8 +827,8 @@ class GeoVisionFusionModel:
         return {
             'models_loaded': self.models_loaded,
             'components': self._load_status,
-            'disaster_classes': DISASTER_CLASSES,
-            'weather_regimes': WEATHER_REGIMES,
+            'disaster_classes': self.disaster_classes,
+            'weather_regimes': self.weather_regimes,
             'features': {
                 'temporal': len(INPUT_FEATURES),
                 'scalar': len(SCALAR_FEATURE_COLUMNS),

server/services/geovision_fusion_service.py

@@ -295,13 +295,7 @@ class GeoVisionFusionService:
         # ── Compute dynamic weather regime if model output is degenerate (e.g. Cloudy 100%) ──
         wx_probs = prediction.get('weather_probabilities', {})
         if not wx_probs or wx_probs.get('Cloudy', 0) >= 0.99 or max(wx_probs.values(), default=0) >= 0.99:
-            precip = float(np.mean(weather_data.get('precipitation_mm', [0.0]))) if weather_data.get('precipitation_mm') else 0.0
-            temp = float(np.mean(weather_data.get('temperature_C', [25.0]))) if weather_data.get('temperature_C') else 25.0
-            humidity = float(np.mean(weather_data.get('humidity_%', [60.0]))) if weather_data.get('humidity_%') else 60.0
-            wind = float(np.mean(weather_data.get('wind_speed_mps', [3.0]))) if weather_data.get('wind_speed_mps') else 3.0
-            cloud = float(np.mean(weather_data.get('cloud_amount_%', [30.0]))) if weather_data.get('cloud_amount_%') else 30.0
-
-            wx_pred, wx_probs_dict, wx_conf = self._compute_dynamic_weather(precip, temp, humidity, wind, cloud)
+            wx_pred, wx_probs_dict, wx_conf = self._compute_dynamic_weather(weather_data)
             prediction['weather_prediction'] = wx_pred
             prediction['weather_probabilities'] = wx_probs_dict
             prediction['weather_confidence'] = wx_conf
@@ -335,21 +329,35 @@ class GeoVisionFusionService:
             'processing_time_seconds': round(processing_time, 2)
         }
 
-    def _compute_dynamic_weather(self, precip: float, temp: float, humidity: float, wind: float, cloud: float) -> Tuple[str, Dict[str, float], float]:
-        """Compute realistic weather regime probabilities from physical meteorological features."""
-        score_rainy = max(0.05, min(0.9, (precip / 15.0) * 0.5 + (humidity / 100.0) * 0.3))
-        score_dry = max(0.05, min(0.9, max(0, 1.0 - precip / 5.0) * 0.5 + (temp / 35.0) * 0.4))
-        score_humid = max(0.05, min(0.9, (humidity / 100.0) * 0.7 + (temp / 35.0) * 0.2))
-        score_stormy = max(0.02, min(0.85, (wind / 15.0) * 0.6 + (precip / 20.0) * 0.4))
-        score_cloudy = max(0.05, min(0.8, (cloud / 100.0) * 0.6 + (humidity / 100.0) * 0.3))
+    def _compute_dynamic_weather(self, weather_data: Dict[str, Any], T: float = 0.35) -> Tuple[str, Dict[str, float], float]:
+        """Compute realistic weather regime probabilities from physical 60-day meteorological time series."""
+        precip_arr = np.array(weather_data.get('precipitation_mm', [0.0]))
+        temp_arr = np.array(weather_data.get('temperature_C', [25.0]))
+        hum_arr = np.array(weather_data.get('humidity_%', [60.0]))
+        wind_arr = np.array(weather_data.get('wind_speed_mps', [3.0]))
+        cloud_arr = np.array(weather_data.get('cloud_amount_%', [30.0]))
+
+        p_7d_mean = np.mean(precip_arr[-7:]) if len(precip_arr) >= 7 else np.mean(precip_arr)
+        p_7d_max = np.max(precip_arr[-7:]) if len(precip_arr) >= 7 else np.max(precip_arr)
+        t_7d_mean = np.mean(temp_arr[-7:]) if len(temp_arr) >= 7 else np.mean(temp_arr)
+        h_7d_mean = np.mean(hum_arr[-7:]) if len(hum_arr) >= 7 else np.mean(hum_arr)
+        w_7d_max = np.max(wind_arr[-7:]) if len(wind_arr) >= 7 else np.max(wind_arr)
+        c_7d_mean = np.mean(cloud_arr[-7:]) if len(cloud_arr) >= 7 else np.mean(cloud_arr)
+
+        score_rainy = max(0.05, min(0.95, (p_7d_mean / 10.0) * 0.5 + (p_7d_max / 25.0) * 0.3 + (h_7d_mean / 100.0) * 0.2))
+        score_dry = max(0.05, min(0.95, max(0.0, 1.0 - p_7d_mean / 3.0) * 0.5 + max(0.0, (t_7d_mean - 20.0) / 15.0) * 0.3 + max(0.0, 1.0 - h_7d_mean / 75.0) * 0.2))
+        score_humid = max(0.05, min(0.95, (h_7d_mean / 100.0) * 0.6 + (t_7d_mean / 35.0) * 0.25 + max(0.0, 1.0 - w_7d_max / 12.0) * 0.15))
+        score_stormy = max(0.02, min(0.90, (w_7d_max / 15.0) * 0.55 + (p_7d_max / 30.0) * 0.45))
+        score_cloudy = max(0.05, min(0.90, (c_7d_mean / 100.0) * 0.6 + max(0.0, 1.0 - p_7d_mean / 10.0) * 0.25 + (h_7d_mean / 100.0) * 0.15))
 
         scores = np.array([score_cloudy, score_dry, score_humid, score_rainy, score_stormy])
-        scores = scores / np.sum(scores)
+        exp_scores = np.exp((scores - np.max(scores)) / T)
+        probs = exp_scores / np.sum(exp_scores)
 
         regimes = ['Cloudy', 'Dry', 'Humid', 'Rainy', 'Stormy']
-        probs_dict = {regimes[i]: round(float(scores[i]), 4) for i in range(5)}
-        best_idx = int(np.argmax(scores))
-        return regimes[best_idx], probs_dict, round(float(scores[best_idx]), 4)
+        probs_dict = {regimes[i]: round(float(probs[i]), 4) for i in range(5)}
+        best_idx = int(np.argmax(probs))
+        return regimes[best_idx], probs_dict, round(float(probs[best_idx]), 4)
 
     # ────────────────────────────────────────────────────────────────
     # STATUS / HEALTH

server/test_geovision_class_order.py

@@ -0,0 +1,119 @@
+import sys
+import unittest
+from pathlib import Path
+
+import numpy as np
+
+
+SERVER_DIR = Path(__file__).resolve().parent
+if str(SERVER_DIR) not in sys.path:
+    sys.path.insert(0, str(SERVER_DIR))
+
+from models.geovision_fusion_model import GeoVisionFusionModel  # noqa: E402
+
+
+class FakeProbabilityModel:
+    def __init__(self, probabilities):
+        self._probabilities = np.array([probabilities], dtype=float)
+
+    def predict(self, _features):
+        return np.array([int(np.argmax(self._probabilities[0]))])
+
+    def predict_proba(self, _features):
+        return self._probabilities
+
+
+class FakeScaler:
+    n_features_in_ = 138
+
+    def transform(self, features):
+        if features.shape[1] != self.n_features_in_:
+            raise AssertionError(f"expected 138 features, got {features.shape[1]}")
+        return features
+
+
+class GeoVisionClassOrderTest(unittest.TestCase):
+    def setUp(self):
+        self.model = GeoVisionFusionModel()
+        self.lstm_disaster = np.array([[0.9, 0.05, 0.02, 0.02, 0.01]])
+        self.lstm_weather = np.array([[0.8, 0.1, 0.05, 0.03, 0.02]])
+        self.embeddings = np.zeros((1, 128))
+
+    def test_fusion_prediction_uses_saved_disaster_class_order(self):
+        self.model.fusion_disaster_model = FakeProbabilityModel([0.91, 0.04, 0.03, 0.01, 0.01])
+
+        result = self.model._stack_and_predict(
+            self.lstm_disaster,
+            self.lstm_weather,
+            self.embeddings,
+        )
+
+        self.assertEqual(result["disaster_prediction"], "Normal")
+        self.assertEqual(result["disaster_probabilities"]["Normal"], 0.91)
+
+    def test_fusion_prediction_uses_saved_weather_regime_order(self):
+        self.model.fusion_weather_model = FakeProbabilityModel([0.82, 0.08, 0.05, 0.03, 0.02])
+
+        result = self.model._stack_and_predict(
+            self.lstm_disaster,
+            self.lstm_weather,
+            self.embeddings,
+        )
+
+        self.assertEqual(result["weather_prediction"], "Rainy")
+        self.assertEqual(result["weather_probabilities"]["Rainy"], 0.82)
+
+    def test_fusion_prediction_does_not_fabricate_normal_confidence(self):
+        self.model.fusion_disaster_model = FakeProbabilityModel([0.3, 0.25, 0.2, 0.15, 0.1])
+
+        result = self.model._stack_and_predict(
+            self.lstm_disaster,
+            self.lstm_weather,
+            self.embeddings,
+        )
+
+        self.assertEqual(result["disaster_prediction"], "Normal")
+        self.assertEqual(result["disaster_probabilities"]["Normal"], 0.3)
+
+    def test_weak_hazard_prediction_is_calibrated_to_normal(self):
+        self.model.fusion_disaster_model = FakeProbabilityModel([0.05, 0.34, 0.26, 0.2, 0.15])
+
+        result = self.model._stack_and_predict(
+            self.lstm_disaster,
+            self.lstm_weather,
+            self.embeddings,
+        )
+
+        self.assertEqual(result["disaster_prediction"], "Normal")
+        self.assertGreater(result["disaster_probabilities"]["Normal"], 0.58)
+        self.assertLess(result["disaster_probabilities"]["Normal"], 0.86)
+
+    def test_strong_hazard_prediction_breaks_through_normal_calibration(self):
+        self.model.fusion_disaster_model = FakeProbabilityModel([0.05, 0.72, 0.1, 0.08, 0.05])
+
+        result = self.model._stack_and_predict(
+            self.lstm_disaster,
+            self.lstm_weather,
+            self.embeddings,
+        )
+
+        self.assertEqual(result["disaster_prediction"], "Flood")
+        self.assertEqual(result["disaster_probabilities"]["Flood"], 0.72)
+
+    def test_fusion_vector_matches_trained_feature_count(self):
+        self.model.fusion_disaster_model = FakeProbabilityModel([0.3, 0.25, 0.2, 0.15, 0.1])
+        self.model.fusion_disaster_scaler = FakeScaler()
+
+        result = self.model._stack_and_predict(
+            self.lstm_disaster,
+            self.lstm_weather,
+            self.embeddings,
+            ensemble_probs=np.zeros((1, 5)),
+            cnn_probs=np.zeros((1, 5)),
+        )
+
+        self.assertEqual(result["fusion_features_dim"], 138)
+
+
+if __name__ == "__main__":
+    unittest.main()