Upload 3 files

UI.py

@@ -1,16 +1,16 @@
 # UI.py
 import gradio as gr
-# La importación de process_and_plot se maneja por modal_app.py
-# from interface import process_and_plot
 
-def create_interface():
+# Ya no importamos process_and_plot aquí, se pasará como argumento a create_interface
+
+def create_interface(process_function_for_button): # <-- AÑADIDO: process_function_for_button
     """
-    Esta función crea la interfaz de usuario y la devuelve para que pueda ser lanzada
-    desde app.py utilizando demo.launch().
+    Esta función crea la interfaz de usuario y la devuelve.
+    Conecta el botón de submit a la 'process_function_for_button' proporcionada.
     """
     
-    with gr.Blocks(theme='upsatwal/mlsc_tiet') as demo: # Puede que necesites un theme diferente o default
-    # with gr.Blocks(theme=gr.themes.Soft()) as demo: # Alternativa más común
+    with gr.Blocks(theme='upsatwal/mlsc_tiet') as demo:
+    # with gr.Blocks(theme=gr.themes.Soft()) as demo: 
         gr.Markdown("# Modelado de Bioprocesos con Ecuaciones Personalizadas y Análisis por IA")
 
         with gr.Row():
@@ -31,73 +31,73 @@ def create_interface():
                 substrate_eq_count_ui = gr.Number(label="Número de ecuaciones de Sustrato a probar (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
                 product_eq_count_ui = gr.Number(label="Número de ecuaciones de Producto a probar (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
 
-
-        # --- Sección de Biomasa ---
         with gr.Accordion("Ecuaciones y Parámetros de Biomasa", open=True):
             with gr.Row():
                 with gr.Column():
-                    biomass_eq1_ui = gr.Textbox(label="Ecuación de Biomasa 1 (ej: Xm * (1 - exp(-um * t)))", value="Xm * (1 - exp(-um * t))", lines=2) # Modelo de Moser simplificado
-                    biomass_param1_ui = gr.Textbox(label="Parámetros Biomasa 1 (coma sep., ej: Xm, um, Ks)", value="Xm, um, t_lag", info="Use 't' para tiempo. Use 'Ks' o 't_lag' para fases de retardo si es necesario.")
-                    biomass_bound1_ui = gr.Textbox(label="Límites Biomasa 1 (ej: (0,inf),(0,5),(-10,10))", value="(0, inf), (0, inf), (0, inf)", info="Formato: (low,high) para cada param. Use np.inf.")
-                with gr.Column(visible=False) as biomass_col2: # Inicialmente oculto
-                    biomass_eq2_ui = gr.Textbox(label="Ecuación de Biomasa 2", value="X0 * exp(um * t)", lines=2) # Crecimiento exponencial simple
+                    biomass_eq1_ui = gr.Textbox(label="Ecuación de Biomasa 1 (ej: Xm * (1 - exp(-um * t)))", value="Xm * (1 - exp(-um * t_lag))", lines=2)
+                    biomass_param1_ui = gr.Textbox(label="Parámetros Biomasa 1 (coma sep., ej: Xm, um, t_lag)", value="Xm, um, t_lag", info="Use 't' para tiempo. X_val para S/P.")
+                    biomass_bound1_ui = gr.Textbox(label="Límites Biomasa 1 (ej: (0,inf),(0,5),(0,inf))", value="(0, inf), (0, inf), (0, inf)", info="Formato: (low,high). Use np.inf.")
+                biomass_col2 = gr.Column(visible=False)
+                with biomass_col2:
+                    biomass_eq2_ui = gr.Textbox(label="Ecuación de Biomasa 2", value="X0 * exp(um * t)", lines=2)
                     biomass_param2_ui = gr.Textbox(label="Parámetros Biomasa 2", value="X0, um")
                     biomass_bound2_ui = gr.Textbox(label="Límites Biomasa 2", value="(0, inf), (0, inf)")
-                with gr.Column(visible=False) as biomass_col3: # Inicialmente oculto
+                biomass_col3 = gr.Column(visible=False)
+                with biomass_col3:
                     biomass_eq3_ui = gr.Textbox(label="Ecuación de Biomasa 3", lines=2)
                     biomass_param3_ui = gr.Textbox(label="Parámetros Biomasa 3")
                     biomass_bound3_ui = gr.Textbox(label="Límites Biomasa 3")
         
-        # --- Sección de Sustrato ---
         with gr.Accordion("Ecuaciones y Parámetros de Sustrato", open=True):
-            gr.Markdown("Para ecuaciones de Sustrato y Producto, usa `X_val` para representar la concentración de biomasa calculada X(t). Ejemplo: `S0 - (1/YXS) * (X_val - X0_biomass)`")
+            gr.Markdown("Para Sustrato/Producto, usa `X_val` para X(t). Ejemplo: `S0 - (1/YXS) * (X_val - X0_bio)` donde X0_bio es un parámetro o valor.")
             with gr.Row():
                 with gr.Column():
-                    substrate_eq1_ui = gr.Textbox(label="Ecuación de Sustrato 1", value="S0 - (X_val / YXS) - mS * t", lines=2) # Luedeking-Piret simplificado
+                    substrate_eq1_ui = gr.Textbox(label="Ecuación de Sustrato 1", value="S0 - (X_val / YXS) - mS * t", lines=2)
                     substrate_param1_ui = gr.Textbox(label="Parámetros Sustrato 1", value="S0, YXS, mS")
                     substrate_bound1_ui = gr.Textbox(label="Límites Sustrato 1", value="(0, inf), (0.01, inf), (0, inf)")
-                with gr.Column(visible=False) as substrate_col2:
+                substrate_col2 = gr.Column(visible=False)
+                with substrate_col2:
                     substrate_eq2_ui = gr.Textbox(label="Ecuación de Sustrato 2", lines=2)
                     substrate_param2_ui = gr.Textbox(label="Parámetros Sustrato 2")
                     substrate_bound2_ui = gr.Textbox(label="Límites Sustrato 2")
-                with gr.Column(visible=False) as substrate_col3:
+                substrate_col3 = gr.Column(visible=False)
+                with substrate_col3:
                     substrate_eq3_ui = gr.Textbox(label="Ecuación de Sustrato 3", lines=2)
                     substrate_param3_ui = gr.Textbox(label="Parámetros Sustrato 3")
                     substrate_bound3_ui = gr.Textbox(label="Límites Sustrato 3")
 
-        # --- Sección de Producto ---
         with gr.Accordion("Ecuaciones y Parámetros de Producto", open=True):
             with gr.Row():
                 with gr.Column():
-                    product_eq1_ui = gr.Textbox(label="Ecuación de Producto 1", value="P0 + YPX * X_val + mP * t", lines=2) # Luedeking-Piret simplificado
+                    product_eq1_ui = gr.Textbox(label="Ecuación de Producto 1", value="P0 + YPX * X_val + mP * t", lines=2)
                     product_param1_ui = gr.Textbox(label="Parámetros Producto 1", value="P0, YPX, mP")
                     product_bound1_ui = gr.Textbox(label="Límites Producto 1", value="(0, inf), (0, inf), (0, inf)")
-                with gr.Column(visible=False) as product_col2:
+                product_col2 = gr.Column(visible=False)
+                with product_col2:
                     product_eq2_ui = gr.Textbox(label="Ecuación de Producto 2", lines=2)
                     product_param2_ui = gr.Textbox(label="Parámetros Producto 2")
                     product_bound2_ui = gr.Textbox(label="Límites Producto 2")
-                with gr.Column(visible=False) as product_col3:
+                product_col3 = gr.Column(visible=False)
+                with product_col3:
                     product_eq3_ui = gr.Textbox(label="Ecuación de Producto 3", lines=2)
                     product_param3_ui = gr.Textbox(label="Parámetros Producto 3")
                     product_bound3_ui = gr.Textbox(label="Límites Producto 3")
 
-        # Lógica para mostrar/ocultar campos de ecuación dinámicamente
-        def update_visibility(count, c2, c3):
-            return gr.Column(visible=count >= 2), gr.Column(visible=count >= 3)
+        def update_visibility(count): # Simplificado, devuelve tupla de dicts
+            return {"visible": count >= 2}, {"visible": count >= 3}
 
-        biomass_eq_count_ui.change(fn=lambda x: update_visibility(x, biomass_col2, biomass_col3), inputs=biomass_eq_count_ui, outputs=[biomass_col2, biomass_col3])
-        substrate_eq_count_ui.change(fn=lambda x: update_visibility(x, substrate_col2, substrate_col3), inputs=substrate_eq_count_ui, outputs=[substrate_col2, substrate_col3])
-        product_eq_count_ui.change(fn=lambda x: update_visibility(x, product_col2, product_col3), inputs=product_eq_count_ui, outputs=[product_col2, product_col3])
+        biomass_eq_count_ui.change(fn=update_visibility, inputs=biomass_eq_count_ui, outputs=[biomass_col2, biomass_col3])
+        substrate_eq_count_ui.change(fn=update_visibility, inputs=substrate_eq_count_ui, outputs=[substrate_col2, substrate_col3])
+        product_eq_count_ui.change(fn=update_visibility, inputs=product_eq_count_ui, outputs=[product_col2, product_col3])
         
         submit_button = gr.Button("Procesar y Analizar", variant="primary", scale=1)
         
         gr.Markdown("## Resultados del Análisis")
         with gr.Row():
-            image_output = gr.Image(label="Gráfico Generado", type="pil", width=600, height=900, scale=2) # Ajusta escala si es necesario
-            with gr.Column(scale=3): # Más espacio para el análisis
-                analysis_output = gr.Markdown(label="Análisis del Modelo por IA") # Usar Markdown para mejor formato
+            image_output = gr.Image(label="Gráfico Generado", type="pil", width=600, height=900, scale=2)
+            with gr.Column(scale=3):
+                analysis_output = gr.Markdown(label="Análisis del Modelo por IA")
         
-        # Lista de todos los inputs para el botón de submit
         all_inputs = [
             file_input,
             biomass_eq1_ui, biomass_eq2_ui, biomass_eq3_ui,
@@ -116,10 +116,25 @@ def create_interface():
             substrate_eq_count_ui,
             product_eq_count_ui
         ]
-        # La conexión se hace en modal_app.py al inyectar la función de `interface`
-        # El atributo `fn` del botón se establecerá allí.
-        demo.load(fn=lambda: (gr.Column(visible=False), gr.Column(visible=False)), outputs=[biomass_col2, biomass_col3])
-        demo.load(fn=lambda: (gr.Column(visible=False), gr.Column(visible=False)), outputs=[substrate_col2, substrate_col3])
-        demo.load(fn=lambda: (gr.Column(visible=False), gr.Column(visible=False)), outputs=[product_col2, product_col3])
+        
+        # --- CONEXIÓN DEL BOTÓN DENTRO DEL CONTEXTO DE BLOCKS ---
+        submit_button.click(
+            fn=process_function_for_button, # Usa la función pasada como argumento
+            inputs=all_inputs,
+            outputs=[image_output, analysis_output]
+        )
+
+        # Inicializar la visibilidad correctamente al cargar la demo
+        # No es necesario demo.load para esto si la visibilidad por defecto es False
+        # y la función `update_visibility` se llama con el valor inicial del Number input.
+        # Para asegurar que se llama al inicio:
+        demo.load(lambda val_b, val_s, val_p: (
+            update_visibility(val_b)[0], update_visibility(val_b)[1], # Para biomasa
+            update_visibility(val_s)[0], update_visibility(val_s)[1], # Para sustrato
+            update_visibility(val_p)[0], update_visibility(val_p)[1]  # Para producto
+            ), 
+            inputs=[biomass_eq_count_ui, substrate_eq_count_ui, product_eq_count_ui], 
+            outputs=[biomass_col2, biomass_col3, substrate_col2, substrate_col3, product_col2, product_col3]
+        )
 
-    return demo, all_inputs, [image_output, analysis_output], submit_button # Devolver también inputs, outputs y botón
+    return demo

app.py

@@ -1,23 +1,10 @@
 # app.py
-# Importar create_interface desde UI.py
-import os
-
-os.system("pip install --upgrade gradio")
 from UI import create_interface
-import interface as app_interface_module # Para el click handler
+import interface as app_interface_module # Necesitamos la función process_and_plot
 
 def main():
-    # Crear la interfaz y obtener los componentes necesarios
-    demo, all_inputs, outputs_list, submit_button_obj = create_interface()
-    
-    # Conectar el botón de submit a la función process_and_plot del módulo interface
-    # Esto es crucial para que la UI llame a la lógica correcta.
-    submit_button_obj.click(
-        fn=app_interface_module.process_and_plot, # La función real
-        inputs=all_inputs,       # La lista de componentes de entrada
-        outputs=outputs_list     # La lista de componentes de salida
-    )
-    
+    # Pasa la función de procesamiento real a create_interface
+    demo = create_interface(process_function_for_button=app_interface_module.process_and_plot)
     demo.launch()
 
 if __name__ == "__main__":

model_app.py

@@ -2,19 +2,17 @@
 import modal
 import sys
 from pathlib import Path
-import os # Para HF_TOKEN
+import os
+import traceback # Para imprimir traceback detallado
 
 # --- Configuración ---
 PYTHON_VERSION = "3.10"
 APP_NAME = "bioprocess-custom-eq-agent-modal"
-
-# Directorios (asume que modal_app.py está en la raíz del proyecto junto a los otros .py)
 LOCAL_APP_DIR = Path(__file__).parent
-REMOTE_APP_DIR = "/app"  # Directorio dentro del contenedor Modal
+REMOTE_APP_DIR = "/app"
 
 stub = modal.Stub(APP_NAME)
 
-# Definición de la imagen del contenedor Modal
 app_image = (
     modal.Image.debian_slim(python_version=PYTHON_VERSION)
     .pip_install_from_requirements(LOCAL_APP_DIR / "requirements.txt")
@@ -23,35 +21,30 @@ app_image = (
     )
     .env({
         "PYTHONPATH": REMOTE_APP_DIR,
-        "HF_HOME": "/cache/huggingface", # Directorio de caché de Hugging Face
+        "HF_HOME": "/cache/huggingface",
         "HF_HUB_CACHE": "/cache/huggingface/hub",
-        "TRANSFORMERS_CACHE": "/cache/huggingface/hub", # Alias común
-        "MPLCONFIGDIR": "/tmp/matplotlib_cache" # Para evitar warnings de matplotlib
+        "TRANSFORMERS_CACHE": "/cache/huggingface/hub",
+        "MPLCONFIGDIR": "/tmp/matplotlib_cache"
     })
-    .run_commands( # Comandos para ejecutar durante la construcción de la imagen
-        "apt-get update && apt-get install -y git git-lfs && rm -rf /var/lib/apt/lists/*", # git-lfs para algunos modelos
-        "mkdir -p /cache/huggingface/hub /tmp/matplotlib_cache" # Crear directorios de caché
+    .run_commands(
+        "apt-get update && apt-get install -y git git-lfs && rm -rf /var/lib/apt/lists/*",
+        "mkdir -p /cache/huggingface/hub /tmp/matplotlib_cache"
     )
 )
 
-# --- Función Modal para Generación de Análisis con LLM ---
+# --- Función Modal para LLM (sin cambios respecto a la anterior respuesta) ---
 @stub.function(
     image=app_image,
-    gpu="any",  # Solicitar GPU (ej. "T4", "A10G", o "any")
-    secrets=[
-        modal.Secret.from_name("huggingface-read-token", optional=True) # Para modelos privados/gated
-    ],
-    timeout=600, # 10 minutos de timeout
-    # Montar un volumen para cachear modelos de Hugging Face
+    gpu="any",
+    secrets=[modal.Secret.from_name("huggingface-read-token", optional=True)],
+    timeout=600,
     volumes={"/cache/huggingface": modal.Volume.persisted(f"{APP_NAME}-hf-cache-vol")}
 )
 def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_new_tokens_config: int) -> str:
-    import torch
+    import torch # Mover importaciones pesadas dentro de la función Modal
     from transformers import AutoTokenizer, AutoModelForCausalLM
     
-    # El token de HF se inyecta como variable de entorno si el secreto está configurado
     hf_token = os.environ.get("HUGGING_FACE_TOKEN") 
-
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     print(f"LLM Modal Func: Usando dispositivo: {device}")
     print(f"LLM Modal Func: Cargando modelo: {model_path_config} con token: {'Sí' if hf_token else 'No'}")
@@ -60,16 +53,19 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
         tokenizer = AutoTokenizer.from_pretrained(model_path_config, cache_dir="/cache/huggingface/hub", token=hf_token)
         model = AutoModelForCausalLM.from_pretrained(
             model_path_config,
-            torch_dtype="auto", # bfloat16 en A100/H100, float16 en otras
-            device_map="auto",  # Distribuye automáticamente en GPUs disponibles
+            torch_dtype="auto", 
+            device_map="auto",
             cache_dir="/cache/huggingface/hub",
             token=hf_token,
-            # low_cpu_mem_usage=True # Puede ayudar con modelos muy grandes
         )
-        # No es necesario .to(device) explícitamente con device_map="auto"
-        # model.eval() no es necesario si solo se hace inferencia y no se entrena
-
-        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=4096-max_new_tokens_config).to(model.device) # Truncar prompt si es muy largo
+        
+        # Ajustar longitud de truncamiento para el prompt para dejar espacio a max_new_tokens
+        # La longitud total (prompt + generado) no debe exceder el context window del modelo.
+        # Asumamos un context window conservador de 4096 si no se conoce.
+        model_context_window = getattr(model.config, 'max_position_embeddings', 4096)
+        max_prompt_len = model_context_window - max_new_tokens_config - 50 # 50 tokens de buffer
+        
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=max_prompt_len).to(model.device)
 
         with torch.no_grad():
             outputs = model.generate(
@@ -78,12 +74,10 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
                 eos_token_id=tokenizer.eos_token_id,
                 pad_token_id=tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id,
                 do_sample=True,
-                temperature=0.6, # Ajustar para creatividad vs factualidad
+                temperature=0.6, 
                 top_p=0.9,
-                # num_beams=1 # Usar num_beams > 1 para beam search si se desea, pero más lento
             )
         
-        # Decodificar solo los tokens generados nuevos, no el prompt
         input_length = inputs.input_ids.shape[1]
         generated_ids = outputs[0][input_length:]
         analysis = tokenizer.decode(generated_ids, skip_special_tokens=True)
@@ -96,18 +90,19 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
         return f"Error al generar análisis con el modelo LLM: {str(e)}"
 
 # --- Servidor Gradio ---
-@stub.asgi_app() # image se hereda del stub si no se especifica aquí
+@stub.asgi_app()
 def serve_gradio_app_asgi():
     # Estas importaciones ocurren DENTRO del contenedor Modal
     import gradio as gr
-    sys.path.insert(0, REMOTE_APP_DIR) # Asegurar que los módulos de la app son importables
+    # sys.path ya está configurado por la imagen, pero por si acaso:
+    if REMOTE_APP_DIR not in sys.path:
+        sys.path.insert(0, REMOTE_APP_DIR)
     
-    # Importar los módulos de la aplicación AHORA que sys.path está configurado
-    from UI import create_interface
-    import interface as app_interface_module # Renombrar para claridad
+    from UI import create_interface # De tu UI.py
+    import interface as app_interface_module # El módulo interface.py
     from config import MODEL_PATH as cfg_MODEL_PATH, MAX_LENGTH as cfg_MAX_LENGTH
 
-    # Wrapper para llamar a la función Modal remota desde tu interface.py
+    # Wrapper para llamar a la función Modal remota
     def analysis_func_wrapper_for_interface(prompt: str) -> str:
         print("Gradio Backend: Llamando a generate_analysis_llm_modal_remote.remote...")
         return generate_analysis_llm_modal_remote.remote(prompt, cfg_MODEL_PATH, cfg_MAX_LENGTH)
@@ -116,23 +111,31 @@ def serve_gradio_app_asgi():
     app_interface_module.generate_analysis_from_modal = analysis_func_wrapper_for_interface
     app_interface_module.USE_MODAL_FOR_LLM_ANALYSIS = True
 
-    # Crear la app Gradio y conectar el botón
-    gradio_ui, all_ui_inputs, ui_outputs, ui_submit_button = create_interface()
+    # Crear la app Gradio, pasándole la función de procesamiento que ahora está en app_interface_module
+    # create_interface ahora toma la función de callback como argumento.
+    gradio_ui = create_interface(process_function_for_button=app_interface_module.process_and_plot)
     
-    ui_submit_button.click(
-        fn=app_interface_module.process_and_plot,
-        inputs=all_ui_inputs,
-        outputs=ui_outputs
-    )
-    
-    return gr.routes.App.create_app(gradio_ui) # Para montar Gradio en FastAPI/ASGI
+    return gr.routes.App.create_app(gradio_ui)
 
-# (Opcional) Un entrypoint local para probar rápidamente la generación LLM
 @stub.local_entrypoint()
 def test_llm():
     print("Probando la generación de LLM con Modal (localmente)...")
+    # Necesitas importar config para que MODEL_PATH y MAX_LENGTH estén definidos
+    # Esto debe hacerse dentro de un contexto donde los módulos de la app sean accesibles.
+    # Es mejor llamar a la función stub desde aquí.
+    if REMOTE_APP_DIR not in sys.path: # Asegurar path para pruebas locales también
+        sys.path.insert(0, str(LOCAL_APP_DIR))
     from config import MODEL_PATH, MAX_LENGTH
+    
     sample_prompt = "Explica brevemente el concepto de R cuadrado (R²) en el ajuste de modelos."
-    analysis = generate_analysis_llm_modal_remote.remote(sample_prompt, MODEL_PATH, MAX_LENGTH)
-    print("\nRespuesta del LLM:")
-    print(analysis)
+    # Ejecuta la función Modal directamente (no .remote() para prueba local de lógica)
+    # Para probar la ejecución remota real, necesitarías `modal run modal_app.py test_llm`
+    # o que test_llm llame a .remote().
+    # Aquí vamos a probar la llamada remota.
+    try:
+        analysis = generate_analysis_llm_modal_remote.remote(sample_prompt, MODEL_PATH, MAX_LENGTH)
+        print("\nRespuesta del LLM:")
+        print(analysis)
+    except Exception as e:
+        print(f"Error durante test_llm: {e}")
+        traceback.print_exc()