Upload app.py

app.py

@@ -1,321 +1,260 @@
-import io
-import requests
-import pandas as pd
+import os, io, json, requests
+from typing import Optional, List, Dict
 import numpy as np
+import pandas as pd
+import joblib
+import tensorflow as tf
 import gradio as gr
-import json
-import pickle
-import os
-from typing import Dict, List, Any
 
-os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+# ===== Artifacts =====
+MODEL_PATH = "modelo_tabular.h5"
+SCALER_PATH = "scaler.pkl"
+ENCODER_PATH = "label_encoder.pkl"
+STATS_PATH = "feature_stats.json"
 
-print("🚀 Iniciando Eco Finder API...")
+assert os.path.exists(MODEL_PATH), "Falta modelo_tabular.h5"
+assert os.path.exists(SCALER_PATH), "Falta scaler.pkl"
+assert os.path.exists(ENCODER_PATH), "Falta label_encoder.pkl"
+assert os.path.exists(STATS_PATH), "Falta feature_stats.json"
 
-# Configuración
-try:
-    import tensorflow as tf
-    print(f"✅ TensorFlow version: {tf.__version__}")
-    from tensorflow.keras.models import load_model
-    TENSORFLOW_AVAILABLE = True
-except ImportError as e:
-    print(f"❌ TensorFlow no disponible: {e}")
-    TENSORFLOW_AVAILABLE = False
+model = tf.keras.models.load_model(MODEL_PATH)
+scaler = joblib.load(SCALER_PATH)
+label_encoder = joblib.load(ENCODER_PATH)
+with open(STATS_PATH) as f:
+    stats = json.load(f)
 
-# Cargar recursos
-def load_resources():
-    try:
-        with open("feature_stats.json", "r") as f:
-            feature_stats = json.load(f)
-        print("✅ Feature stats cargado")
-            
-        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")
-        
-        model = None
-        if TENSORFLOW_AVAILABLE:
-            model = load_model("modulo_tabular.h5")
-            print("✅ Modelo cargado")
-        
-        return model, scaler, label_encoder, feature_stats
-        
-    except Exception as e:
-        print(f"❌ Error cargando recursos: {str(e)}")
-        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
-            }
-        }
-        return None, None, None, feature_stats
+FEATURE_COLUMNS: List[str] = stats["feature_columns"]
+MEDIANS: Dict[str, float] = stats["medians"]
+CLASSES = list(label_encoder.classes_)
 
-# Cargar recursos
-model, scaler, label_encoder, feature_stats = load_resources()
-feature_columns = feature_stats.get("feature_columns", [])
-train_medians = feature_stats.get("train_medians", {})
+# ===== Helpers =====
+def first_present(candidates, cols_set):
+    for c in candidates:
+        if c in cols_set:
+            return c
+    for c in candidates:
+        found = [x for x in cols_set if c in x]
+        if found:
+            return found[0]
+    return None
 
-BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
+CANDIDATES_MAP = {
+    "koi_period":       ["pl_orbper","tce_period","orbper","period"],
+    "koi_duration":     ["pl_trandurh","tce_duration","trandur","duration","dur"],
+    "koi_depth":        ["pl_trandep","tce_depth","depth","trandep"],
+    "koi_prad":         ["pl_rade","prad","rade","planet_radius"],
+    "koi_srad":         ["st_rad","srad","stellar_radius","star_radius"],
+    "koi_teq":          ["pl_eqt","teq","equilibrium_temp"],
+    "koi_steff":        ["st_teff","teff","stellar_teff","effective_temp"],
+    "koi_slogg":        ["st_logg","logg","slogg"],
+    "koi_smet":         ["st_met","feh","metallicity","smet"],
+    "koi_kepmag":       ["st_tmag","tmag","kepmag","koi_kepmag"],
+    "koi_model_snr":    ["tce_model_snr","model_snr","snr"],
+    "koi_num_transits": ["tce_num_transits","num_transits","ntransits","tran_count"]
+}
 
-# ==================== FUNCIONES PARA GRADIO ====================
+def impute_and_scale(df: pd.DataFrame) -> np.ndarray:
+    for col in FEATURE_COLUMNS:
+        if col not in df.columns:
+            df[col] = np.nan
+    df = df[FEATURE_COLUMNS].copy()
+    for c in FEATURE_COLUMNS:
+        if df[c].isna().any():
+            df[c] = df[c].fillna(MEDIANS.get(c, 0.0))
+    X = scaler.transform(df.values)
+    return X
 
-def predict_single(features: Dict) -> Dict:
-    """Función para predecir un solo objeto - USADA POR GRADIO"""
-    try:
-        if model is None or scaler is None or label_encoder is None:
-            return {"error": "Modelo no disponible"}
-        
-        # Crear array de características
-        input_features = []
-        for feature in feature_columns:
-            value = features.get(feature, train_medians.get(feature, 0))
-            input_features.append(float(value))
-        
-        # Predecir
-        input_array = np.array([input_features])
-        X_input = scaler.transform(input_array)
-        
-        if TENSORFLOW_AVAILABLE:
-            probs = model.predict(X_input, verbose=0)[0]
+def predict_proba_from_df(df: pd.DataFrame):
+    X = impute_and_scale(df)
+    probs = model.predict(X, verbose=0)
+    classes = list(label_encoder.classes_)
+    return probs, classes
+
+# ===== Endpoint 1: Probar con 2 TOI/TCE de la API =====
+def predict_toi_samples(n=2, table="tce"):
+    if table not in {"tce","toi"}:
+        table = "tce"
+
+    if table == "tce":
+        TAP_URL = "https://exoplanetarchive.ipac.caltech.edu/TAP/sync"
+        query = f"""
+        SELECT TOP {int(n)}
+          kepid, tce_plnt_num, tce_period, tce_duration, tce_depth, tce_model_snr
+        FROM q1_q17_dr25_tce
+        WHERE tce_period > 0 AND tce_duration > 0 AND tce_depth > 0
+        ORDER BY tce_model_snr DESC
+        """
+        r = requests.get(TAP_URL, params={"query": query, "format": "csv"}, timeout=90)
+    else:
+        BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
+        where = ("(tfopwg_disp like 'PC' or tfopwg_disp like 'APC') and "
+                 "(pl_orbper is not null or tce_period is not null)")
+        r = requests.get(BASE, params={"table":"toi","where":where,"format":"csv"}, timeout=90)
+
+    r.raise_for_status()
+    df = pd.read_csv(io.StringIO(r.text))
+    df.columns = [c.strip().lower() for c in df.columns]
+    df = df.sample(min(n, len(df)), random_state=7).reset_index(drop=True)
+
+    # map flexible a FEATURE_COLUMNS
+    cols_set = set(df.columns)
+    cases = pd.DataFrame(index=df.index, columns=FEATURE_COLUMNS, dtype="float64")
+    for feat in FEATURE_COLUMNS:
+        src = first_present(CANDIDATES_MAP.get(feat, []), cols_set)
+        if src is not None:
+            cases[feat] = pd.to_numeric(df[src], errors="coerce")
         else:
-            probs = np.random.dirichlet(np.ones(3), size=1)[0]
-        
-        pred_idx = np.argmax(probs)
-        pred_label = label_encoder.inverse_transform([pred_idx])[0]
-        
-        return {
-            "prediction": pred_label,
-            "probabilities": {
-                "CONFIRMED": float(probs[0]),
-                "CANDIDATE": float(probs[1]),
-                "FALSE_POSITIVE": float(probs[2])
-            },
-            "input_features": dict(zip(feature_columns, input_features))
-        }
-        
-    except Exception as e:
-        return {"error": str(e)}
+            cases[feat] = np.nan
 
-def predict_from_dict(
-    koi_period: float, koi_duration: float, koi_depth: float, 
-    koi_prad: float, koi_srad: float, koi_teq: float,
-    koi_steff: float, koi_slogg: float, koi_smet: float,
-    koi_kepmag: float, koi_model_snr: float, koi_num_transits: float
-) -> Dict:
-    """Wrapper que toma parámetros individuales y los convierte a dict"""
-    features = {
-        "koi_period": koi_period,
-        "koi_duration": koi_duration,
-        "koi_depth": koi_depth,
-        "koi_prad": koi_prad,
-        "koi_srad": koi_srad,
-        "koi_teq": koi_teq,
-        "koi_steff": koi_steff,
-        "koi_slogg": koi_slogg,
-        "koi_smet": koi_smet,
-        "koi_kepmag": koi_kepmag,
-        "koi_model_snr": koi_model_snr,
-        "koi_num_transits": koi_num_transits
-    }
-    return predict_single(features)
+    probs, classes = predict_proba_from_df(cases)
+    idx = np.argmax(probs, axis=1)
+    preds = label_encoder.inverse_transform(idx)
 
-def predict_toi_realtime():
-    """Función para TOI en tiempo real"""
-    try:
-        if model is None or scaler is None or label_encoder is None:
-            return "❌ Modelo no disponible"
-        
-        # Consultar API de exoplanetas
-        where = ("(tfopwg_disp like 'PC' or tfopwg_disp like 'APC') "
-                 "and (pl_orbper is not null or tce_period is not null)")
-        
-        params = {"table": "toi", "where": where, "format": "csv"}
-        resp = requests.get(BASE, params=params, timeout=60)
-        resp.raise_for_status()
-        toi_df = pd.read_csv(io.StringIO(resp.text))
-        
-        if toi_df.empty:
-            return "❌ No se encontraron objetos TOI"
-        
-        # Tomar muestra
-        toi_sample = toi_df.sample(min(3, len(toi_df)), random_state=7)
-        toi_sample.columns = [c.strip().lower() for c in toi_sample.columns]
-        
-        # Mapeo de sinónimos
-        candidates_map = {
-            "koi_period": ["pl_orbper", "tce_period", "orbper", "period"],
-            "koi_duration": ["pl_trandurh", "tce_duration", "tran_dur", "trandur", "duration", "dur"],
-            "koi_depth": ["pl_trandep", "tce_depth", "depth", "trandep"],
-            "koi_prad": ["pl_rade", "prad", "rade", "planet_radius"],
-            "koi_srad": ["st_rad", "srad", "stellar_radius", "star_radius"],
-            "koi_teq": ["pl_eqt", "teq", "equilibrium_temp"],
-            "koi_steff": ["st_teff", "teff", "stellar_teff", "effective_temp"],
-            "koi_slogg": ["st_logg", "logg", "slogg"],
-            "koi_smet": ["st_met", "feh", "metallicity", "smet"],
-            "koi_kepmag": ["st_tmag", "tmag", "kepmag", "koi_kepmag"],
-            "koi_model_snr": ["tce_model_snr", "model_snr", "snr"],
-            "koi_num_transits": ["tce_num_transits", "num_transits", "ntransits", "tran_count"]
-        }
-        
-        def first_present(candidates, cols_set):
-            for name in candidates:
-                if name in cols_set:
-                    return name
-            for name in candidates:
-                found = [c for c in cols_set if name in c]
-                if found:
-                    return found[0]
-            return None
-        
-        cols_set = set(toi_sample.columns)
-        results = []
-        
-        for idx, row in toi_sample.iterrows():
-            # Preparar características
-            features = {}
-            for feat in feature_columns:
-                src = first_present(candidates_map.get(feat, []), cols_set)
-                if src and src in row and pd.notna(row[src]):
-                    features[feat] = float(row[src])
-                else:
-                    features[feat] = train_medians.get(feat, 0)
-            
-            # Predecir
-            result = predict_single(features)
-            
-            if "error" not in result:
-                results.append({
-                    "TOI": row.get('toi', f"TOI-{idx}"),
-                    "Disposición": row.get('tfopwg_disp', 'Unknown'),
-                    "Predicción": result['prediction'],
-                    "P(Confirmado)": f"{result['probabilities']['CONFIRMED']:.3f}",
-                    "P(Candidato)": f"{result['probabilities']['CANDIDATE']:.3f}",
-                    "P(Falso Positivo)": f"{result['probabilities']['FALSE_POSITIVE']:.3f}"
-                })
-        
-        if not results:
-            return "❌ No se pudieron generar predicciones"
-        
-        result_df = pd.DataFrame(results)
-        return f"**Predicciones TOI:**\n\n{result_df.to_markdown(index=False)}"
-        
-    except Exception as e:
-        return f"❌ Error: {str(e)}"
+    # construir salida
+    out = []
+    for i in range(len(df)):
+        row_probs = probs[i]
+        d = {"prediction": preds[i]}
+        for j, cls in enumerate(classes):
+            d[f"P({cls})"] = float(row_probs[j])
+        out.append(d)
+    res = pd.DataFrame(out)
+    csv_path = "pred_toi_samples.csv"
+    res.to_csv(csv_path, index=False)
+    return res, csv_path
 
-def predict_manual(
-    period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits
-):
-    """Función para predicción manual en Gradio"""
+# ===== Endpoint 2: POST JSON manual =====
+def predict_from_json(json_text: str, threshold: float = 0.5):
     try:
-        result = predict_from_dict(
-            period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits
-        )
-        
-        if "error" in result:
-            return f"❌ {result['error']}"
-        
-        output = f"**Predicción:** {result['prediction']}\n\n**Probabilidades:**\n"
-        for clase, prob in result['probabilities'].items():
-            output += f"- {clase}: {prob:.3f}\n"
-            
-        return output
-        
+        payload = json.loads(json_text)
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return {"error": f"JSON inválido: {e}"}
+
+    df = pd.DataFrame([payload])
+    # normalizar nombres
+    df.columns = [c.strip().lower() for c in df.columns]
+    # map a FEATURE_COLUMNS
+    cols_set = set(df.columns)
+    cases = pd.DataFrame(index=df.index, columns=FEATURE_COLUMNS, dtype="float64")
+    for feat in FEATURE_COLUMNS:
+        # si ya viene con el nombre koi_* lo usamos
+        if feat in cols_set:
+            cases[feat] = pd.to_numeric(df[feat], errors="coerce")
+            continue
+        # sino buscamos sinónimos
+        src = first_present(CANDIDATES_MAP.get(feat, []), cols_set)
+        if src is not None:
+            cases[feat] = pd.to_numeric(df[src], errors="coerce")
+        else:
+            cases[feat] = np.nan
+
+    probs, classes = predict_proba_from_df(cases)
+    p = probs[0]
+    idx = int(np.argmax(p))
+    pred = label_encoder.inverse_transform([idx])[0]
+    p_confirmed = float(p[classes.index("CONFIRMED")]) if "CONFIRMED" in classes else 0.0
+    return {
+        "prediction": pred,
+        "probabilities": {classes[i]: float(p[i]) for i in range(len(classes))},
+        "is_exoplanet": bool(pred.upper()=="CONFIRMED" and p_confirmed >= float(threshold)),
+        "p_confirmed": p_confirmed
+    }
+
+# ===== Endpoint 3: Descargar CSV de un TOI/TCE específico =====
+def download_object_csv(identifier: str, table: str = "toi"):
+    table = table.lower()
+    if table not in {"toi","tce"}:
+        table = "toi"
+    if table == "toi":
+        BASE = "https://exoplanetarchive.ipac.caltech.edu/cgi-bin/nstedAPI/nph-nstedAPI"
+        where = f"toi like '{identifier}'"
+        r = requests.get(BASE, params={"table":"toi","where":where,"format":"csv"}, timeout=60)
+    else:
+        # para TCE usamos TAP por kepid + tce_plnt_num, ejemplo: "KIC 11446443 1"
+        TAP_URL = "https://exoplanetarchive.ipac.caltech.edu/TAP/sync"
+        parts = identifier.replace(",", " ").split()
+        if len(parts) >= 2:
+            kep = parts[0]
+            num = parts[1]
+            query = f"""
+            SELECT *
+            FROM q1_q17_dr25_tce
+            WHERE CAST(kepid AS VARCHAR) like '{kep.replace('KIC','').strip()}'
+              AND CAST(tce_plnt_num AS VARCHAR) like '{num.strip()}'
+            """
+        else:
+            query = f"SELECT TOP 1 * FROM q1_q17_dr25_tce WHERE CAST(kepid AS VARCHAR) like '{identifier.strip()}'"
+        r = requests.get(TAP_URL, params={"query": query, "format": "csv"}, timeout=90)
+
+    r.raise_for_status()
+    path = "object.csv"
+    with open(path, "w") as f:
+        f.write(r.text)
+    return path
+
+# ===== Endpoint 4: Subir CSV y predecir =====
+def predict_from_csv(file_obj, threshold: float = 0.5):
+    if file_obj is None:
+        return pd.DataFrame(), None
+    df = pd.read_csv(file_obj.name)
+    # normalizar nombres
+    df.columns = [c.strip().lower() for c in df.columns]
+    cols_set = set(df.columns)
+
+    cases = pd.DataFrame(index=df.index, columns=FEATURE_COLUMNS, dtype="float64")
+    for feat in FEATURE_COLUMNS:
+        src = feat if feat in cols_set else first_present(CANDIDATES_MAP.get(feat, []), cols_set)
+        if src is not None:
+            cases[feat] = pd.to_numeric(df[src], errors="coerce")
+        else:
+            cases[feat] = np.nan
+
+    probs, classes = predict_proba_from_df(cases)
+    idx = np.argmax(probs, axis=1)
+    preds = label_encoder.inverse_transform(idx)
+
+    out = []
+    for i in range(len(df)):
+        row = {"prediction": preds[i]}
+        for j, cls in enumerate(classes):
+            row[f"P({cls})"] = float(probs[i][j])
+        out.append(row)
+    res = pd.DataFrame(out)
+    out_path = "predicciones.csv"
+    res.to_csv(out_path, index=False)
+    return res, out_path
+
+# ===== Gradio UI =====
+with gr.Blocks() as demo:
+    gr.Markdown("# 🔭 Exoplanet Classifier — API + UI (Gradio)")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 1) Probar con 2 objetos de la API (TOI o TCE)")
+            table_dd = gr.Dropdown(choices=["toi","tce"], value="tce", label="Tabla")
+            n_objs = gr.Slider(1, 10, value=2, step=1, label="N objetos")
+            out_df1 = gr.Dataframe(label="Resultados")
+            out_file1 = gr.File(label="Descargar CSV")
+            gr.Button("Probar API").click(predict_toi_samples, inputs=[n_objs, table_dd], outputs=[out_df1, out_file1], api_name="predict_toi_samples")
 
-# ==================== INTERFAZ GRADIO ====================
+        with gr.Column():
+            gr.Markdown("### 2) JSON manual (POST)")
+            jt = gr.Textbox(lines=12, label="JSON de entrada (TOI/TCE-like o koi_* )")
+            thr_json = gr.Slider(0, 1, value=0.5, step=0.01, label="Umbral P(CONFIRMED)")
+            out_json = gr.JSON(label="Respuesta")
+            gr.Button("Predecir JSON").click(predict_from_json, inputs=[jt, thr_json], outputs=out_json, api_name="predict_json")
 
-with gr.Blocks(theme=gr.themes.Soft(), title="Eco Finder API") as demo:
-    gr.Markdown("# 🌌 Eco Finder API")
-    gr.Markdown("Clasificador de exoplanetas")
-    
-    with gr.Tab("🎯 Predicción API"):
-        gr.Markdown("### Endpoint para consumo desde frontend")
-        gr.Markdown("""
-        **URL:** `https://jarpalucas-echo-finder-api.hf.space/api/predict`
-        
-        **Método:** POST
-        **Content-Type:** application/json
-        
-        **Ejemplo de uso con curl:**
-        ```bash
-        curl -X POST "https://jarpalucas-echo-finder-api.hf.space/api/predict" \\
-          -H "Content-Type: application/json" \\
-          -d '{
-            "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
-          }'
-        ```
-        """)
-        
-        # Inputs para probar la API localmente
-        with gr.Row():
-            with gr.Column():
-                period = gr.Number(label="koi_period", value=10.0)
-                duration = gr.Number(label="koi_duration", value=5.0)
-                depth = gr.Number(label="koi_depth", value=1000.0)
-                prad = gr.Number(label="koi_prad", value=2.0)
-            with gr.Column():
-                srad = gr.Number(label="koi_srad", value=1.0)
-                teq = gr.Number(label="koi_teq", value=1000.0)
-                steff = gr.Number(label="koi_steff", value=6000.0)
-                slogg = gr.Number(label="koi_slogg", value=4.5)
-            with gr.Column():
-                smet = gr.Number(label="koi_smet", value=0.0)
-                kepmag = gr.Number(label="koi_kepmag", value=12.0)
-                snr = gr.Number(label="koi_model_snr", value=10.0)
-                num_transits = gr.Number(label="koi_num_transits", value=3.0)
-        
-        api_btn = gr.Button("🚀 Probar Predicción")
-        api_output = gr.JSON()
-        
-        api_btn.click(
-            fn=predict_from_dict,
-            inputs=[period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits],
-            outputs=api_output
-        )
-    
-    with gr.Tab("🔭 TOI Tiempo Real"):
-        gr.Markdown("Predicciones de objetos TOI en tiempo real")
-        toi_btn = gr.Button("🔍 Analizar TOI")
-        toi_output = gr.Markdown()
-        toi_btn.click(predict_toi_realtime, outputs=toi_output)
-    
-    with gr.Tab("📊 Interfaz Manual"):
-        gr.Markdown("Interfaz manual para predicciones")
-        manual_btn = gr.Button("🎯 Predecir")
-        manual_output = gr.Markdown()
-        manual_btn.click(
-            fn=predict_manual,
-            inputs=[period, duration, depth, prad, srad, teq, steff, slogg, smet, kepmag, snr, num_transits],
-            outputs=manual_output
-        )
+    gr.Markdown("### 3) Descargar CSV de un objeto (por id)")
+    ident = gr.Textbox(label="Identificador (ej: TOI-1234.01 o 'KIC 11446443 1')", placeholder="TOI-xxx.yy  ó  KIC ###### <planet_num>")
+    table2 = gr.Dropdown(choices=["toi","tce"], value="toi", label="Tabla")
+    out_csv = gr.File(label="CSV del objeto")
+    gr.Button("Descargar CSV").click(download_object_csv, inputs=[ident, table2], outputs=out_csv, api_name="toi_csv")
 
-print("🎉 Aplicación iniciada correctamente!")
-print("🌐 Interfaz disponible en: /")
-print("🔗 Endpoint API disponible en: /api/predict")
+    gr.Markdown("### 4) Subir CSV y clasificar")
+    f_in = gr.File(label="CSV subida", file_types=[".csv"])
+    thr = gr.Slider(0,1,value=0.5, step=0.01, label="Umbral P(CONFIRMED)")
+    out_df2 = gr.Dataframe(label="Resultados")
+    out_file2 = gr.File(label="Descargar predicciones")
+    gr.Button("Predecir CSV").click(predict_from_csv, inputs=[f_in, thr], outputs=[out_df2, out_file2], api_name="predict_csv")
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+demo.queue().launch()