Update app.py

app.py

@@ -8,67 +8,128 @@ import pickle
 import os
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 
+# Configuración para compatibilidad
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+print("🚀 Iniciando aplicación Eco Finder API...")
+
 # Intentar importar TensorFlow con manejo de errores
 try:
-    from tensorflow.keras.models import load_model
-    TENSORFLOW_AVAILABLE = True
+    import tensorflow as tf
+    print(f"✅ TensorFlow version: {tf.__version__}")
+    
+    # Intentar diferentes métodos de carga
+    try:
+        from tensorflow.keras.models import load_model
+        TENSORFLOW_AVAILABLE = True
+        LOAD_METHOD = "keras"
+    except:
+        try:
+            # Intentar con tf.keras
+            from tensorflow import keras
+            load_model = keras.models.load_model
+            TENSORFLOW_AVAILABLE = True
+            LOAD_METHOD = "tf.keras"
+        except:
+            TENSORFLOW_AVAILABLE = False
+            LOAD_METHOD = "none"
+            
 except ImportError as e:
-    print(f"TensorFlow no disponible: {e}")
+    print(f"❌ TensorFlow no disponible: {e}")
     TENSORFLOW_AVAILABLE = False
-    # Usar una alternativa
-    from sklearn.ensemble import RandomForestClassifier
-    import joblib
+    LOAD_METHOD = "none"
+
+print(f"📊 Estado TensorFlow: {TENSORFLOW_AVAILABLE}, Método: {LOAD_METHOD}")
 
 # Cargar modelo y artefactos
 def load_resources():
     """Carga el modelo y todos los artefactos necesarios"""
     try:
+        model = None
+        scaler = None
+        label_encoder = None
+        feature_stats = None
+        
+        # 1. Cargar feature_stats primero (siempre necesario)
+        try:
+            with open("feature_stats.json", "r") as f:
+                feature_stats = json.load(f)
+            print("✅ Feature stats cargado")
+        except Exception as e:
+            print(f"❌ Error cargando feature_stats: {e}")
+            feature_stats = create_default_feature_stats()
+        
+        # 2. Cargar scaler
+        try:
+            with open("scaler.pkl", "rb") as f:
+                scaler = pickle.load(f)
+            print("✅ Scaler cargado")
+        except Exception as e:
+            print(f"❌ Error cargando scaler: {e}")
+            scaler = None
+        
+        # 3. Cargar label_encoder
+        try:
+            with open("label_encoder.pkl", "rb") as f:
+                label_encoder = pickle.load(f)
+            print("✅ Label encoder cargado")
+        except Exception as e:
+            print(f"❌ Error cargando label_encoder: {e}")
+            label_encoder = None
+        
+        # 4. Intentar cargar el modelo con diferentes métodos
         if TENSORFLOW_AVAILABLE:
-            model = load_model("modulo_tabular.h5")
-            print("✅ Modelo TensorFlow cargado exitosamente")
-        else:
-            # Si TensorFlow falla, intentar cargar con joblib
             try:
-                model = joblib.load("modulo_tabular.h5")
-                print("✅ Modelo cargado con joblib")
-            except:
-                # Crear un modelo dummy para pruebas
-                print("⚠️  Usando modelo dummy para demostración")
-                model = None
-        
-        with open("scaler.pkl", "rb") as f:
-            scaler = pickle.load(f)
-        print("✅ Scaler cargado")
-            
-        with open("label_encoder.pkl", "rb") as f:
-            label_encoder = pickle.load(f)
-        print("✅ Label encoder cargado")
-            
-        with open("feature_stats.json", "r") as f:
-            feature_stats = json.load(f)
-        print("✅ Feature stats cargado")
-            
+                print("🔄 Intentando cargar modelo con load_model...")
+                model = load_model("modulo_tabular.h5")
+                print("✅ Modelo cargado con load_model")
+            except Exception as e1:
+                print(f"❌ Método 1 falló: {e1}")
+                try:
+                    # Intentar cargar solo arquitectura y pesos por separado
+                    print("🔄 Intentando cargar arquitectura y pesos por separado...")
+                    from tensorflow.keras.models import Model
+                    from tensorflow.keras.layers import Input, Dense
+                    
+                    # Crear arquitectura manualmente (ajusta según tu modelo)
+                    inputs = Input(shape=(12,))
+                    x = Dense(64, activation='relu')(inputs)
+                    x = Dense(32, activation='relu')(x)
+                    outputs = Dense(3, activation='softmax')(x)
+                    model = Model(inputs=inputs, outputs=outputs)
+                    model.load_weights("modulo_tabular.h5")
+                    print("✅ Modelo cargado con pesos manualmente")
+                except Exception as e2:
+                    print(f"❌ Método 2 falló: {e2}")
+                    model = None
+        else:
+            print("⚠️  TensorFlow no disponible, usando modelo dummy")
+            model = None
+        
         return model, scaler, label_encoder, feature_stats
         
     except Exception as e:
-        print(f"❌ Error cargando recursos: {str(e)}")
-        # Crear objetos dummy para que la app funcione
-        feature_stats = {
-            "feature_columns": [
-                "koi_period", "koi_duration", "koi_depth", "koi_prad", 
-                "koi_srad", "koi_teq", "koi_steff", "koi_slogg", 
-                "koi_smet", "koi_kepmag", "koi_model_snr", "koi_num_transits"
-            ],
-            "train_medians": {
-                "koi_period": 10.0, "koi_duration": 5.0, "koi_depth": 1000.0,
-                "koi_prad": 2.0, "koi_srad": 1.0, "koi_teq": 1000.0,
-                "koi_steff": 6000.0, "koi_slogg": 4.5, "koi_smet": 0.0,
-                "koi_kepmag": 12.0, "koi_model_snr": 10.0, "koi_num_transits": 3.0
-            }
+        print(f"❌ Error general cargando recursos: {str(e)}")
+        return None, None, None, create_default_feature_stats()
+
+def create_default_feature_stats():
+    """Crea estadísticas por defecto si no se pueden cargar"""
+    return {
+        "feature_columns": [
+            "koi_period", "koi_duration", "koi_depth", "koi_prad", 
+            "koi_srad", "koi_teq", "koi_steff", "koi_slogg", 
+            "koi_smet", "koi_kepmag", "koi_model_snr", "koi_num_transits"
+        ],
+        "train_medians": {
+            "koi_period": 10.0, "koi_duration": 5.0, "koi_depth": 1000.0,
+            "koi_prad": 2.0, "koi_srad": 1.0, "koi_teq": 1000.0,
+            "koi_steff": 6000.0, "koi_slogg": 4.5, "koi_smet": 0.0,
+            "koi_kepmag": 12.0, "koi_model_snr": 10.0, "koi_num_transits": 3.0
         }
-        return None, None, None, feature_stats
+    }
 
 # Cargar recursos al inicio
+print("🔄 Cargando recursos del modelo...")
 model, scaler, label_encoder, feature_stats = load_resources()
 
 if feature_stats:
@@ -78,6 +139,11 @@ else:
     feature_columns = []
     train_medians = {}
 
+print(f"📋 Features cargadas: {len(feature_columns)}")
+print(f"🤖 Modelo disponible: {model is not None}")
+print(f"⚖️  Scaler disponible: {scaler is not None}")
+print(f"🏷️  Label encoder disponible: {label_encoder is not None}")
+
 BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
 
 def first_present(candidates, cols_set):
@@ -91,16 +157,38 @@ def first_present(candidates, cols_set):
             return found[0]
     return None
 
-def predict_dummy():
-    """Función de predicción dummy para cuando el modelo no está disponible"""
-    return "🔧 El modelo no está disponible actualmente. Por favor, verifica que los archivos del modelo estén correctamente cargados."
+def create_demo_predictions():
+    """Crear predicciones de demostración"""
+    demo_data = [
+        {
+            "TOI": "TOI-1234.01", "Disposición Actual": "PC", "Predicción": "CONFIRMED",
+            "P(Confirmado)": "0.875", "P(Candidato)": "0.120", "P(Falso Positivo)": "0.005",
+            "Período (días)": "15.234", "Duración (horas)": "4.567", "Radio Planetario (R⊕)": "2.345"
+        },
+        {
+            "TOI": "TOI-5678.01", "Disposición Actual": "APC", "Predicción": "CANDIDATE", 
+            "P(Confirmado)": "0.345", "P(Candidato)": "0.650", "P(Falso Positivo)": "0.005",
+            "Período (días)": "8.912", "Duración (horas)": "3.210", "Radio Planetario (R⊕)": "1.789"
+        },
+        {
+            "TOI": "TOI-9012.01", "Disposición Actual": "PC", "Predicción": "FALSE POSITIVE",
+            "P(Confirmado)": "0.050", "P(Candidato)": "0.150", "P(Falso Positivo)": "0.800",
+            "Período (días)": "25.678", "Duración (horas)": "6.543", "Radio Planetario (R⊕)": "0.987"
+        }
+    ]
+    return pd.DataFrame(demo_data)
 
 def predict_toi_realtime():
     """Obtiene y predice objetos TOI en tiempo real"""
     try:
-        # Verificar si el modelo está disponible
-        if model is None or scaler is None or label_encoder is None:
-            return predict_dummy()
+        # Verificar si los componentes esenciales están disponibles
+        if model is None:
+            result_df = create_demo_predictions()
+            summary = "⚠️ **MODO DEMOSTRACIÓN**: El modelo no está disponible. Mostrando datos de ejemplo.\n\n"
+            return summary + result_df.to_markdown(index=False)
+        
+        if scaler is None or label_encoder is None:
+            return "❌ Error: Scaler o Label Encoder no disponibles"
         
         # 1) Traer TOI (TESS Objects of Interest)
         where = ("(tfopwg_disp like 'PC' or tfopwg_disp like 'APC') "
@@ -156,17 +244,7 @@ def predict_toi_realtime():
         
         # 7) Escalar y predecir
         X_cases = scaler.transform(cases.values)
-        
-        if TENSORFLOW_AVAILABLE:
-            probs = model.predict(X_cases, verbose=0)
-        else:
-            # Si no es TensorFlow, usar predict_proba si está disponible
-            if hasattr(model, 'predict_proba'):
-                probs = model.predict_proba(X_cases)
-            else:
-                probs = np.random.rand(len(X_cases), 3)
-                probs = probs / probs.sum(axis=1, keepdims=True)
-        
+        probs = model.predict(X_cases, verbose=0)
         pred_idx = np.argmax(probs, axis=1)
         pred_labels = label_encoder.inverse_transform(pred_idx)
         clases = list(label_encoder.classes_)
@@ -203,30 +281,28 @@ def predict_toi_realtime():
         return summary + result_df.to_markdown(index=False)
         
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        print(f"❌ Error en predicción TOI: {str(e)}")
+        # Fallback a datos de demostración
+        result_df = create_demo_predictions()
+        summary = f"⚠️ **Error en consulta TOI**: {str(e)}\n\nMostrando datos de ejemplo:\n\n"
+        return summary + result_df.to_markdown(index=False)
 
 def predict_custom_data(period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits):
     """Predice para datos personalizados ingresados manualmente"""
     try:
         # Verificar si el modelo está disponible
-        if model is None or scaler is None or label_encoder is None:
-            return predict_dummy()
+        if model is None:
+            return "⚠️ **MODO DEMOSTRACIÓN**: El modelo no está disponible actualmente. Esta es una predicción de ejemplo.\n\n**Predicción:** CANDIDATE\n\n**Probabilidades:**\n- CONFIRMED: 0.350\n- CANDIDATE: 0.600\n- FALSE POSITIVE: 0.050"
+        
+        if scaler is None or label_encoder is None:
+            return "❌ Error: Scaler o Label Encoder no disponibles"
         
         # Crear array con los datos de entrada
         input_data = np.array([[period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits]])
         
         # Escalar y predecir
         X_input = scaler.transform(input_data)
-        
-        if TENSORFLOW_AVAILABLE:
-            probs = model.predict(X_input, verbose=0)
-        else:
-            if hasattr(model, 'predict_proba'):
-                probs = model.predict_proba(X_input)
-            else:
-                probs = np.random.rand(1, 3)
-                probs = probs / probs.sum(axis=1, keepdims=True)
-        
+        probs = model.predict(X_input, verbose=0)
         pred_idx = np.argmax(probs, axis=1)
         pred_label = label_encoder.inverse_transform(pred_idx)[0]
         
@@ -291,8 +367,12 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API - Clasificador de E
         )
     
     with gr.Tab("ℹ️ Información del Modelo"):
+        model_status = "✅ Cargado y funcionando" if model is not None else "⚠️ En modo demostración"
         gr.Markdown(f"""
-        ## Estado del Modelo: {'✅ Cargado' if model is not None else '❌ No disponible'}
+        ## Estado del Modelo: {model_status}
+        
+        **TensorFlow disponible:** {TENSORFLOW_AVAILABLE}
+        **Método de carga:** {LOAD_METHOD}
         
         **Features utilizadas:** {", ".join(feature_columns) if feature_columns else "No disponibles"}
         
@@ -301,20 +381,12 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API - Clasificador de E
         - 🔍 **CANDIDATE**: Candidato a exoplaneta  
         - ❌ **FALSE POSITIVE**: Falso positivo
         
-        **Descripción de features:**
-        - `koi_period`: Período orbital (días)
-        - `koi_duration`: Duración del tránsito (horas)
-        - `koi_depth`: Profundidad del tránsito (ppm)
-        - `koi_prad`: Radio planetario (Radios terrestres)
-        - `koi_srad`: Radio estelar (Radios solares)
-        - `koi_teq`: Temperatura de equilibrio (K)
-        - `koi_steff`: Temperatura efectiva estelar (K)
-        - `koi_slogg`: Gravedad superficial estelar (log g)
-        - `koi_smet`: Metalicidad estelar ([Fe/H])
-        - `koi_kepmag`: Magnitud TESS
-        - `koi_model_snr`: Relación señal-ruido
-        - `koi_num_transits`: Número de tránsitos
+        **Componentes cargados:**
+        - Modelo: {'✅' if model is not None else '❌'}
+        - Scaler: {'✅' if scaler is not None else '❌'}
+        - Label Encoder: {'✅' if label_encoder is not None else '❌'}
         """)
 
+print("🎉 Aplicación iniciada correctamente!")
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(server_name="0.0.0.0", server_port=7860)