Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,500 @@
-import altair as alt
+"""
+GeoAI Explorer - Streamlit App
+================================
+Clasificacion de agua y cobertura del suelo a partir de datos de teledeteccion MODIS.
+ 
+Dataset historico real: nasa-cisto-data-science-group/modis-lake-powell-toy-dataset (HuggingFace)
+- 7 bandas de reflectancia de superficie MODIS (MOD09GA / MOD09GQ)
+- Indices espectrales: NDVI, NDWI1, NDWI2
+- Etiqueta de agua/no-agua derivada del producto MOD44W de la NASA (Lake Powell)
+ 
+Arquitectura: igual a los dashboards anteriores (vuelos, Mundial) -> entrenamiento on-demand
+guardado en st.session_state, sin .joblib persistido en disco.
+"""
+ 
+import warnings
+ 
 import numpy as np
 import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
 import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+ 
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.inspection import permutation_importance
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score,
+    roc_auc_score, roc_curve, confusion_matrix, classification_report, f1_score,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+ 
+warnings.filterwarnings("ignore")
+ 
+st.set_page_config(
+    page_title="GeoAI Explorer - Agua y Cobertura del Suelo",
+    page_icon="\U0001F30D",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+ 
+st.markdown("""
+<style>
+    .main-header { font-size: 2.3rem; font-weight: 800; color: #14532D; margin-bottom: 0.2rem; }
+    .sub-header { font-size: 1rem; color: #555; margin-bottom: 1.5rem; }
+    .section-title {
+        font-size: 1.3rem; font-weight: 700; color: #1B3A4B;
+        border-bottom: 2px solid #2E86AB; padding-bottom: 4px; margin-bottom: 1rem;
+    }
+    .info-box {
+        background: #EAF4FB; border: 1px solid #AED6F1; border-radius: 6px;
+        padding: 0.8rem 1rem; margin-bottom: 1rem; font-size: 0.9rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+ 
+RANDOM_STATE = 42
+DATASET_URL = "nasa-cisto-data-science-group/modis-lake-powell-toy-dataset"
+LABEL_WATER = "water"
+LABEL_LC = "land_cover"
+ 
+BAND_COLS = [
+    "sur_refl_b01_1", "sur_refl_b02_1", "sur_refl_b03_1", "sur_refl_b04_1",
+    "sur_refl_b05_1", "sur_refl_b06_1", "sur_refl_b07_1",
+]
+INDEX_COLS = ["ndvi", "ndwi1", "ndwi2"]
+BASE_FEATURE_COLS = BAND_COLS + INDEX_COLS
+COLS_TO_DROP = ["x_offset", "y_offset", "year", "julian_day"]
+ 
+LC_PALETTE = {
+    "Agua": "#1B6CA8", "Vegetacion densa": "#2E7D32",
+    "Vegetacion escasa": "#9CCC65", "Suelo desnudo / Urbano": "#A9744F",
+}
+ 
+ 
+# ----------------------------------------------------------------------------
+# Carga de datos: real (HuggingFace) con respaldo sintetico de mismo esquema
+# ----------------------------------------------------------------------------
+@st.cache_data(show_spinner=False)
+def load_modis_data(file_bytes=None):
+    if file_bytes is not None:
+        import io
+        df = pd.read_csv(io.BytesIO(file_bytes))
+        return df, "CSV subido por el usuario"
+ 
+    try:
+        import datasets
+        ds = datasets.load_dataset(DATASET_URL, split="train")
+        df = pd.DataFrame(ds)
+        return df, "HuggingFace (datos reales MODIS Lake Powell)"
+    except Exception:
+        return generate_synthetic_modis(), "Generador sintetico de respaldo (mismo esquema MODIS)"
+ 
+ 
+def generate_synthetic_modis(n_samples=6000, seed=RANDOM_STATE):
+    """Respaldo sin conexion: simula pixeles MODIS con la misma fisica espectral
+    documentada para el dataset real (agua = baja reflectancia NIR/SWIR, NDVI bajo,
+    NDWI alto; tierra/vegetacion = lo opuesto)."""
+    rng = np.random.default_rng(seed)
+    water = rng.binomial(1, 0.30, n_samples)
+ 
+    def band(mean_water, mean_land, sd):
+        base = np.where(water == 1, mean_water, mean_land)
+        return np.clip(rng.normal(base, sd, n_samples), -100, 16000).astype(np.int16)
+ 
+    sur_refl_b01_1 = band(900, 1800, 300)
+    sur_refl_b02_1 = band(1100, 3200, 500)
+    sur_refl_b03_1 = band(950, 1500, 250)
+    sur_refl_b04_1 = band(1000, 1700, 280)
+    sur_refl_b05_1 = band(700, 2600, 450)
+    sur_refl_b06_1 = band(500, 2200, 400)
+    sur_refl_b07_1 = band(400, 1500, 300)
+ 
+    ndvi = np.where(water == 1, rng.normal(-1500, 1200, n_samples), rng.normal(4500, 2000, n_samples)).clip(-20000, 20000).astype(np.int16)
+    ndwi1 = np.where(water == 1, rng.normal(6000, 1500, n_samples), rng.normal(-2000, 1800, n_samples)).clip(-20000, 20000).astype(np.int16)
+    ndwi2 = np.where(water == 1, rng.normal(5000, 1600, n_samples), rng.normal(-2500, 1700, n_samples)).clip(-20000, 20000).astype(np.int16)
+ 
+    return pd.DataFrame({
+        "x_offset": rng.integers(0, 5000, n_samples), "y_offset": rng.integers(0, 5000, n_samples),
+        "year": rng.choice([2018, 2019, 2020, 2021], n_samples), "julian_day": rng.integers(1, 366, n_samples),
+        "sur_refl_b01_1": sur_refl_b01_1, "sur_refl_b02_1": sur_refl_b02_1, "sur_refl_b03_1": sur_refl_b03_1,
+        "sur_refl_b04_1": sur_refl_b04_1, "sur_refl_b05_1": sur_refl_b05_1, "sur_refl_b06_1": sur_refl_b06_1,
+        "sur_refl_b07_1": sur_refl_b07_1, "ndvi": ndvi, "ndwi1": ndwi1, "ndwi2": ndwi2, "water": water,
+    })
+ 
+ 
+def clean_data(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.drop(columns=[c for c in COLS_TO_DROP if c in df.columns])
+    df[LABEL_WATER] = df[LABEL_WATER].astype(int)
+    return df.dropna(subset=BASE_FEATURE_COLS + [LABEL_WATER]).reset_index(drop=True)
+ 
+ 
+def engineer_water_features(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    out["nir_red_ratio"] = out["sur_refl_b02_1"] / (out["sur_refl_b01_1"] + 1e-3)
+    out["green_swir_ratio"] = out["sur_refl_b04_1"] / (out["sur_refl_b06_1"] + 1e-3)
+    out["brightness"] = out[BAND_COLS].sum(axis=1)
+    out["ndwi_minus_ndvi"] = out["ndwi1"] - out["ndvi"]
+    return out
+ 
+ 
+WATER_ENGINEERED = ["nir_red_ratio", "green_swir_ratio", "brightness", "ndwi_minus_ndvi"]
+WATER_FEATURES = BASE_FEATURE_COLS + WATER_ENGINEERED
+ 
+ 
+def assign_land_cover(row):
+    ndvi, ndwi1 = row["ndvi"], row["ndwi1"]
+    if row["water"] == 1 or ndwi1 > 2000:
+        return "Agua"
+    elif ndvi > 4000:
+        return "Vegetacion densa"
+    elif ndvi > 0:
+        return "Vegetacion escasa"
+    return "Suelo desnudo / Urbano"
+ 
+ 
+def engineer_land_features(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    out[LABEL_LC] = out.apply(assign_land_cover, axis=1)
+    out["nir_red_ratio"] = out["sur_refl_b02_1"] / (out["sur_refl_b01_1"] + 1e-3)
+    out["green_swir_ratio"] = out["sur_refl_b04_1"] / (out["sur_refl_b06_1"] + 1e-3)
+    out["brightness"] = out[BAND_COLS].sum(axis=1)
+    L = 0.5
+    out["savi_like"] = (out["sur_refl_b02_1"] - out["sur_refl_b01_1"]) / (out["sur_refl_b02_1"] + out["sur_refl_b01_1"] + L * 10000)
+    return out
+ 
+ 
+LAND_ENGINEERED = ["nir_red_ratio", "green_swir_ratio", "brightness", "savi_like"]
+LAND_FEATURES = BASE_FEATURE_COLS + LAND_ENGINEERED
+ 
+ 
+@st.cache_resource(show_spinner=False)
+def train_water_model(_df_fe: pd.DataFrame, n_estimators: int, test_size: float):
+    X, y = _df_fe[WATER_FEATURES], _df_fe[LABEL_WATER]
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=RANDOM_STATE, stratify=y)
+    scaler = StandardScaler()
+    X_train_s, X_test_s = scaler.fit_transform(X_train), scaler.transform(X_test)
+ 
+    model = RandomForestClassifier(n_estimators=n_estimators, max_depth=12, class_weight="balanced", random_state=RANDOM_STATE, n_jobs=-1)
+    model.fit(X_train_s, y_train)
+    y_pred, y_prob = model.predict(X_test_s), model.predict_proba(X_test_s)[:, 1]
+ 
+    metrics = {
+        "acc": accuracy_score(y_test, y_pred), "precision": precision_score(y_test, y_pred),
+        "recall": recall_score(y_test, y_pred), "f1": f1_score(y_test, y_pred),
+        "roc_auc": roc_auc_score(y_test, y_prob),
+        "cm": confusion_matrix(y_test, y_pred), "report": classification_report(y_test, y_pred, target_names=["No-agua", "Agua"]),
+        "fpr_tpr": roc_curve(y_test, y_prob),
+    }
+    gini_imp = pd.Series(model.feature_importances_, index=WATER_FEATURES).sort_values(ascending=False)
+    perm = permutation_importance(model, X_test_s, y_test, n_repeats=10, random_state=RANDOM_STATE, n_jobs=-1)
+    perm_imp = pd.Series(perm.importances_mean, index=WATER_FEATURES).sort_values(ascending=False)
+ 
+    return model, scaler, metrics, gini_imp, perm_imp
+ 
+ 
+@st.cache_resource(show_spinner=False)
+def train_land_model(_df_fe: pd.DataFrame, n_estimators: int, test_size: float):
+    X, y = _df_fe[LAND_FEATURES], _df_fe[LABEL_LC]
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=RANDOM_STATE, stratify=y)
+    scaler = StandardScaler()
+    X_train_s, X_test_s = scaler.fit_transform(X_train), scaler.transform(X_test)
+ 
+    model = RandomForestClassifier(n_estimators=n_estimators, max_depth=14, class_weight="balanced", random_state=RANDOM_STATE, n_jobs=-1)
+    model.fit(X_train_s, y_train)
+    y_pred = model.predict(X_test_s)
+ 
+    metrics = {
+        "acc": accuracy_score(y_test, y_pred), "f1_macro": f1_score(y_test, y_pred, average="macro"),
+        "f1_weighted": f1_score(y_test, y_pred, average="weighted"),
+        "cm": confusion_matrix(y_test, y_pred, labels=model.classes_), "labels": model.classes_,
+        "report": classification_report(y_test, y_pred),
+    }
+    gini_imp = pd.Series(model.feature_importances_, index=LAND_FEATURES).sort_values(ascending=False)
+    perm = permutation_importance(model, X_test_s, y_test, n_repeats=10, random_state=RANDOM_STATE, n_jobs=-1, scoring="f1_macro")
+    perm_imp = pd.Series(perm.importances_mean, index=LAND_FEATURES).sort_values(ascending=False)
+ 
+    return model, scaler, metrics, gini_imp, perm_imp
+ 
+ 
+def predict_pixel(model, scaler, features, values: dict):
+    row = pd.DataFrame([values])[features]
+    row_s = scaler.transform(row)
+    probs = model.predict_proba(row_s)[0]
+    return dict(zip(model.classes_, probs))
+ 
+ 
+# ----------------------------------------------------------------------------
+# Sidebar
+# ----------------------------------------------------------------------------
+with st.sidebar:
+    st.markdown("## \u2699\ufe0f Configuracion")
+    st.markdown("### \U0001F4C2 Fuente de datos")
+    uploaded = st.file_uploader(
+        "Sube un CSV alternativo (opcional)", type=["csv"],
+        help="Columnas esperadas: sur_refl_b01_1...b07_1, ndvi, ndwi1, ndwi2, water. "
+             "Si no subes nada, se intenta cargar el dataset real de HuggingFace "
+             "(MODIS Lake Powell); si no hay conexion, se usa un generador sintetico del mismo esquema."
+    )
+    raw_df, data_source = load_modis_data(uploaded.read() if uploaded else None)
+    df_clean = clean_data(raw_df)
+ 
+    st.markdown("### \U0001F916 Parametros del modelo")
+    n_trees = st.slider("Arboles del Bosque Aleatorio", 50, 300, 200, step=25)
+    test_frac = st.slider("Fraccion de test", 0.1, 0.4, 0.25, step=0.05)
+    train_btn = st.button("\U0001F680 Entrenar ambos modelos", width='stretch', type="primary")
+ 
+for key in ["water_model", "water_scaler", "water_metrics", "water_gini", "water_perm",
+            "land_model", "land_scaler", "land_metrics", "land_gini", "land_perm"]:
+    if key not in st.session_state:
+        st.session_state[key] = None
+ 
+df_water_fe = engineer_water_features(df_clean)
+df_land_fe = engineer_land_features(df_clean)
+ 
+if train_btn:
+    with st.spinner("Entrenando modelo de clasificacion de agua..."):
+        m, s, met, gi, pi = train_water_model(df_water_fe, n_trees, test_frac)
+        st.session_state.update(water_model=m, water_scaler=s, water_metrics=met, water_gini=gi, water_perm=pi)
+    with st.spinner("Entrenando modelo de cobertura del suelo..."):
+        m2, s2, met2, gi2, pi2 = train_land_model(df_land_fe, n_trees, test_frac)
+        st.session_state.update(land_model=m2, land_scaler=s2, land_metrics=met2, land_gini=gi2, land_perm=pi2)
+    st.success("Modelos entrenados correctamente.")
+ 
+# ----------------------------------------------------------------------------
+# Header
+# ----------------------------------------------------------------------------
+st.markdown('<p class="main-header">\U0001F30D GeoAI Explorer: Agua y Cobertura del Suelo</p>', unsafe_allow_html=True)
+st.markdown(
+    f'<p class="sub-header">Clasificacion de pixeles satelitales MODIS &nbsp;|&nbsp; '
+    f'Fuente: <b>{data_source}</b> &nbsp;|&nbsp; {len(df_clean):,} pixeles</p>',
+    unsafe_allow_html=True,
+)
+ 
+tab1, tab2, tab3, tab4, tab5 = st.tabs([
+    "\U0001F4CA EDA", "\U0001F4A7 Clasificacion del agua",
+    "\U0001F33F Cobertura del suelo", "\U0001F52E Predictor de pixel",
+    "\U0001F9E0 IA Explicable",
+])
+ 
+# ----------------------------------------------------------------------------
+# TAB 1: EDA
+# ----------------------------------------------------------------------------
+with tab1:
+    st.markdown('<p class="section-title">Analisis Exploratorio de Datos</p>', unsafe_allow_html=True)
+ 
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Pixeles totales", f"{len(df_clean):,}")
+    c2.metric("% Agua", f"{df_clean[LABEL_WATER].mean()*100:.1f}%")
+    c3.metric("NDVI promedio", f"{df_clean['ndvi'].mean():.0f}")
+    c4.metric("NDWI1 promedio", f"{df_clean['ndwi1'].mean():.0f}")
+ 
+    col_a, col_b = st.columns(2)
+    with col_a:
+        st.markdown("**Distribucion de NDVI por clase (agua / no-agua)**")
+        fig, ax = plt.subplots(figsize=(6, 4))
+        for cls, color, label in [(0, "#A9744F", "No-agua"), (1, "#1B6CA8", "Agua")]:
+            sns.kdeplot(df_clean.loc[df_clean[LABEL_WATER] == cls, "ndvi"], fill=True, alpha=0.4, color=color, label=label, ax=ax)
+        ax.set_xlabel("NDVI"); ax.legend()
+        fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+    with col_b:
+        st.markdown("**Firma espectral: NDVI vs NDWI1**")
+        fig, ax = plt.subplots(figsize=(6, 4))
+        for cls, color, label in [(0, "#A9744F", "No-agua"), (1, "#1B6CA8", "Agua")]:
+            sub = df_clean[df_clean[LABEL_WATER] == cls]
+            ax.scatter(sub["ndvi"], sub["ndwi1"], s=8, alpha=0.4, color=color, label=label)
+        ax.set_xlabel("NDVI"); ax.set_ylabel("NDWI1"); ax.legend()
+        fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+    st.markdown("**Reflectancia de superficie por banda MODIS, segun clase**")
+    melted = df_clean.melt(id_vars=LABEL_WATER, value_vars=BAND_COLS, var_name="banda", value_name="reflectancia")
+    melted[LABEL_WATER] = melted[LABEL_WATER].map({0: "No-agua", 1: "Agua"})
+    fig, ax = plt.subplots(figsize=(12, 4.5))
+    sns.boxplot(data=melted, x="banda", y="reflectancia", hue=LABEL_WATER, palette=["#A9744F", "#1B6CA8"], ax=ax)
+    ax.tick_params(axis="x", rotation=15)
+    fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+    st.markdown("**Matriz de correlacion: bandas, indices y etiqueta de agua**")
+    fig, ax = plt.subplots(figsize=(9, 6))
+    corr = df_clean[BAND_COLS + INDEX_COLS + [LABEL_WATER]].corr()
+    sns.heatmap(corr, annot=True, fmt=".2f", cmap="RdBu_r", center=0, ax=ax)
+    fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+    with st.expander("Vista previa de los datos"):
+        st.dataframe(df_clean.head(200), width='stretch')
+ 
+# ----------------------------------------------------------------------------
+# TAB 2: Clasificacion del agua
+# ----------------------------------------------------------------------------
+with tab2:
+    st.markdown('<p class="section-title">Modelo de Clasificacion del Agua (binario)</p>', unsafe_allow_html=True)
+ 
+    if st.session_state.water_metrics is None:
+        st.markdown('<div class="info-box">Presiona <b>Entrenar ambos modelos</b> en la barra lateral para ver resultados.</div>', unsafe_allow_html=True)
+    else:
+        met = st.session_state.water_metrics
+        c1, c2, c3, c4, c5 = st.columns(5)
+        c1.metric("Accuracy", f"{met['acc']*100:.1f}%")
+        c2.metric("Precision", f"{met['precision']*100:.1f}%")
+        c3.metric("Recall", f"{met['recall']*100:.1f}%")
+        c4.metric("F1-score", f"{met['f1']*100:.1f}%")
+        c5.metric("ROC AUC", f"{met['roc_auc']:.3f}")
+ 
+        col_a, col_b = st.columns(2)
+        with col_a:
+            fig, ax = plt.subplots(figsize=(5, 4.5))
+            sns.heatmap(met["cm"], annot=True, fmt="d", cmap="Blues", ax=ax,
+                        xticklabels=["No-agua", "Agua"], yticklabels=["No-agua", "Agua"])
+            ax.set_xlabel("Prediccion"); ax.set_ylabel("Real"); ax.set_title("Matriz de confusion")
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+        with col_b:
+            fpr, tpr, _ = met["fpr_tpr"]
+            fig, ax = plt.subplots(figsize=(5, 4.5))
+            ax.plot(fpr, tpr, color="#1B6CA8", linewidth=2, label=f"AUC = {met['roc_auc']:.3f}")
+            ax.plot([0, 1], [0, 1], linestyle="--", color="gray", label="Azar")
+            ax.set_xlabel("Falsos positivos"); ax.set_ylabel("Verdaderos positivos"); ax.set_title("Curva ROC"); ax.legend()
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+        with st.expander("Reporte de clasificacion completo"):
+            st.text(met["report"])
+ 
+# ----------------------------------------------------------------------------
+# TAB 3: Cobertura del suelo
+# ----------------------------------------------------------------------------
+with tab3:
+    st.markdown('<p class="section-title">Modelo de Cobertura del Suelo (multiclase)</p>', unsafe_allow_html=True)
+ 
+    if st.session_state.land_metrics is None:
+        st.markdown('<div class="info-box">Presiona <b>Entrenar ambos modelos</b> en la barra lateral para ver resultados.</div>', unsafe_allow_html=True)
+    else:
+        met = st.session_state.land_metrics
+        c1, c2, c3 = st.columns(3)
+        c1.metric("Accuracy", f"{met['acc']*100:.1f}%")
+        c2.metric("F1-macro", f"{met['f1_macro']*100:.1f}%")
+        c3.metric("F1-weighted", f"{met['f1_weighted']*100:.1f}%")
+ 
+        col_a, col_b = st.columns([1.1, 1])
+        with col_a:
+            fig, ax = plt.subplots(figsize=(6, 5))
+            sns.heatmap(met["cm"], annot=True, fmt="d", cmap="Greens", ax=ax,
+                        xticklabels=met["labels"], yticklabels=met["labels"])
+            ax.set_xlabel("Prediccion"); ax.set_ylabel("Real"); ax.tick_params(axis="x", rotation=20)
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+        with col_b:
+            st.markdown("**Distribucion de clases**")
+            fig, ax = plt.subplots(figsize=(5.5, 5))
+            counts = df_land_fe[LABEL_LC].value_counts()
+            ax.bar(counts.index, counts.values, color=[LC_PALETTE.get(c, "#888") for c in counts.index])
+            ax.tick_params(axis="x", rotation=20)
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+        with st.expander("Reporte de clasificacion completo"):
+            st.text(met["report"])
+ 
+# ----------------------------------------------------------------------------
+# TAB 4: Predictor de pixel
+# ----------------------------------------------------------------------------
+with tab4:
+    st.markdown('<p class="section-title">Predictor interactivo de pixel</p>', unsafe_allow_html=True)
+    if st.session_state.water_model is None:
+        st.markdown('<div class="info-box">Entrena los modelos primero en la barra lateral.</div>', unsafe_allow_html=True)
+    else:
+        st.markdown("Ajusta los valores espectrales de un pixel hipotetico y observa ambas predicciones:")
+        c1, c2, c3, c4 = st.columns(4)
+        b01 = c1.slider("Banda 1 (rojo)", -100, 16000, 1200)
+        b02 = c2.slider("Banda 2 (NIR)", -100, 16000, 2200)
+        b03 = c3.slider("Banda 3 (azul)", -100, 16000, 1100)
+        b04 = c4.slider("Banda 4 (verde)", -100, 16000, 1300)
+        c5, c6, c7 = st.columns(3)
+        b05 = c5.slider("Banda 5", -100, 16000, 1800)
+        b06 = c6.slider("Banda 6 (SWIR)", -100, 16000, 1400)
+        b07 = c7.slider("Banda 7 (SWIR)", -100, 16000, 900)
+        c8, c9, c10 = st.columns(3)
+        ndvi = c8.slider("NDVI", -20000, 20000, 1500)
+        ndwi1 = c9.slider("NDWI1", -20000, 20000, -500)
+        ndwi2 = c10.slider("NDWI2", -20000, 20000, -500)
+ 
+        base_vals = {
+            "sur_refl_b01_1": b01, "sur_refl_b02_1": b02, "sur_refl_b03_1": b03, "sur_refl_b04_1": b04,
+            "sur_refl_b05_1": b05, "sur_refl_b06_1": b06, "sur_refl_b07_1": b07,
+            "ndvi": ndvi, "ndwi1": ndwi1, "ndwi2": ndwi2,
+        }
+        water_vals = dict(base_vals)
+        water_vals["nir_red_ratio"] = b02 / (b01 + 1e-3)
+        water_vals["green_swir_ratio"] = b04 / (b06 + 1e-3)
+        water_vals["brightness"] = b01 + b02 + b03 + b04 + b05 + b06 + b07
+        water_vals["ndwi_minus_ndvi"] = ndwi1 - ndvi
+ 
+        land_vals = dict(base_vals)
+        land_vals["nir_red_ratio"] = water_vals["nir_red_ratio"]
+        land_vals["green_swir_ratio"] = water_vals["green_swir_ratio"]
+        land_vals["brightness"] = water_vals["brightness"]
+        land_vals["savi_like"] = (b02 - b01) / (b02 + b01 + 0.5 * 10000)
+ 
+        if st.button("\U0001F52E Predecir", type="primary"):
+            water_probs = predict_pixel(st.session_state.water_model, st.session_state.water_scaler, WATER_FEATURES, water_vals)
+            land_probs = predict_pixel(st.session_state.land_model, st.session_state.land_scaler, LAND_FEATURES, land_vals)
+ 
+            col_r1, col_r2 = st.columns(2)
+            with col_r1:
+                st.markdown("**Prediccion: Agua**")
+                st.metric("Probabilidad de Agua", f"{water_probs.get(1, 0)*100:.1f}%")
+                st.progress(min(int(water_probs.get(1, 0)*100), 100))
+            with col_r2:
+                st.markdown("**Prediccion: Cobertura del suelo**")
+                pred_lc = max(land_probs, key=land_probs.get)
+                st.metric("Clase mas probable", pred_lc)
+                for cls, p in sorted(land_probs.items(), key=lambda x: -x[1]):
+                    st.write(f"{cls}: {p*100:.1f}%")
+ 
+# ----------------------------------------------------------------------------
+# TAB 5: IA Explicable
+# ----------------------------------------------------------------------------
+with tab5:
+    st.markdown('<p class="section-title">IA Explicable: Importancia de Variables</p>', unsafe_allow_html=True)
+    if st.session_state.water_gini is None:
+        st.markdown('<div class="info-box">Entrena los modelos primero en la barra lateral.</div>', unsafe_allow_html=True)
+    else:
+        st.markdown("#### Clasificacion del agua")
+        col_a, col_b = st.columns(2)
+        with col_a:
+            fig, ax = plt.subplots(figsize=(6, 5))
+            colors = plt.cm.Blues_r(np.linspace(0.2, 0.8, len(st.session_state.water_gini)))
+            st.session_state.water_gini.plot(kind="barh", ax=ax, color=colors)
+            ax.invert_yaxis(); ax.set_xlabel("Importancia (impureza)")
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+        with col_b:
+            fig, ax = plt.subplots(figsize=(6, 5))
+            colors = plt.cm.Oranges_r(np.linspace(0.2, 0.8, len(st.session_state.water_perm)))
+            st.session_state.water_perm.plot(kind="barh", ax=ax, color=colors)
+            ax.invert_yaxis(); ax.set_xlabel("Caida de F1 al permutar")
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+        st.markdown("#### Cobertura del suelo")
+        col_c, col_d = st.columns(2)
+        with col_c:
+            fig, ax = plt.subplots(figsize=(6, 5))
+            colors = plt.cm.Greens_r(np.linspace(0.2, 0.8, len(st.session_state.land_gini)))
+            st.session_state.land_gini.plot(kind="barh", ax=ax, color=colors)
+            ax.invert_yaxis(); ax.set_xlabel("Importancia (impureza)")
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+        with col_d:
+            fig, ax = plt.subplots(figsize=(6, 5))
+            colors = plt.cm.Purples_r(np.linspace(0.2, 0.8, len(st.session_state.land_perm)))
+            st.session_state.land_perm.plot(kind="barh", ax=ax, color=colors)
+            ax.invert_yaxis(); ax.set_xlabel("Caida de F1-macro al permutar")
+            fig.tight_layout(); st.pyplot(fig); plt.close(fig)
+ 
+        st.caption(
+            "El agua absorbe fuertemente la radiacion infrarroja cercana (NIR), lo que reduce su "
+            "reflectancia en banda 2 y eleva los indices NDWI. El NDVI es el indice mas relevante "
+            "para distinguir vegetacion densa de escasa en el modelo de cobertura del suelo."
+        )
+ 
+st.markdown("---")
+st.markdown(
+    "<small>GeoAI Explorer. Dataset historico real: MODIS Lake Powell "
+    "(nasa-cisto-data-science-group, HuggingFace) o generador sintetico de respaldo con el mismo esquema.</small>",
+    unsafe_allow_html=True,
+)