Upload 3 files

UI.py

@@ -1,16 +1,16 @@
 # UI.py
 import gradio as gr
 
-# Ya no importamos process_and_plot aquí, se pasará como argumento a create_interface
+# La importación de process_and_plot ya no es necesaria aquí,
+# la función de procesamiento se pasará como argumento a create_interface.
 
-def create_interface(process_function_for_button): # <-- AÑADIDO: process_function_for_button
+def create_interface(process_function_for_button):
     """
     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:
-    # with gr.Blocks(theme=gr.themes.Soft()) as demo: 
+    with gr.Blocks(theme='upsatwal/mlsc_tiet') as demo: # O usa gr.themes.Soft() o tu theme preferido
         gr.Markdown("# Modelado de Bioprocesos con Ecuaciones Personalizadas y Análisis por IA")
 
         with gr.Row():
@@ -26,35 +26,39 @@ def create_interface(process_function_for_button): # <-- AÑADIDO: process_funct
                     value='best'
                 )
             with gr.Column(scale=1):
-                gr.Markdown("### Conteo de Ecuaciones")
-                biomass_eq_count_ui = gr.Number(label="Número de ecuaciones de Biomasa a probar (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
-                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)
+                gr.Markdown("### Conteo de Ecuaciones a Probar")
+                biomass_eq_count_ui = gr.Number(label="Biomasa (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
+                substrate_eq_count_ui = gr.Number(label="Sustrato (1-3)", value=1, minimum=1, maximum=3, precision=0, step=1)
+                product_eq_count_ui = gr.Number(label="Producto (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_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_eq1_ui = gr.Textbox(label="Ecuación de Biomasa 1", value="Xm * (1 - exp(-um * (t - t_lag)))", lines=2, placeholder="Ej: Xm * (1 - exp(-um * (t - t_lag)))")
+                    biomass_param1_ui = gr.Textbox(label="Parámetros Biomasa 1", value="Xm, um, t_lag", info="Nombres de parámetros, coma sep. Use 't' para tiempo. 'X_val' para X(t) en S/P.")
+                    biomass_bound1_ui = gr.Textbox(label="Límites Biomasa 1", value="(0, np.inf), (0, np.inf), (0, np.inf)", info="Formato: (low,high) para cada param. Use np.inf.")
+                # Columna 2 para Biomasa (inicialmente oculta)
                 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)")
+                    biomass_bound2_ui = gr.Textbox(label="Límites Biomasa 2", value="(0, np.inf), (0, np.inf)")
+                # Columna 3 para Biomasa (inicialmente oculta)
                 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 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.")
+            gr.Markdown("Para ecuaciones de Sustrato y Producto que dependen de la biomasa X(t), usa la variable `X_val` en tu ecuación. Ejemplo: `S0 - (X_val / YXS)`.")
             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)
                     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)")
+                    substrate_bound1_ui = gr.Textbox(label="Límites Sustrato 1", value="(0, np.inf), (1e-9, np.inf), (0, np.inf)") # YXS no debe ser cero
                 substrate_col2 = gr.Column(visible=False)
                 with substrate_col2:
                     substrate_eq2_ui = gr.Textbox(label="Ecuación de Sustrato 2", lines=2)
@@ -66,12 +70,13 @@ def create_interface(process_function_for_button): # <-- AÑADIDO: process_funct
                     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)
                     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)")
+                    product_bound1_ui = gr.Textbox(label="Límites Producto 1", value="(0, np.inf), (0, np.inf), (0, np.inf)")
                 product_col2 = gr.Column(visible=False)
                 with product_col2:
                     product_eq2_ui = gr.Textbox(label="Ecuación de Producto 2", lines=2)
@@ -83,22 +88,25 @@ def create_interface(process_function_for_button): # <-- AÑADIDO: process_funct
                     product_param3_ui = gr.Textbox(label="Parámetros Producto 3")
                     product_bound3_ui = gr.Textbox(label="Límites Producto 3")
 
-        def update_visibility(count): # Simplificado, devuelve tupla de dicts
-            return {"visible": count >= 2}, {"visible": count >= 3}
+        # Lógica para mostrar/ocultar campos de ecuación dinámicamente
+        # La función `update_visibility` devuelve una tupla de diccionarios para Gradio
+        def update_visibility_fn(count):
+            return gr.Column(visible=count >= 2), gr.Column(visible=count >= 3)
 
-        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])
+        biomass_eq_count_ui.change(fn=update_visibility_fn, inputs=biomass_eq_count_ui, outputs=[biomass_col2, biomass_col3])
+        substrate_eq_count_ui.change(fn=update_visibility_fn, inputs=substrate_eq_count_ui, outputs=[substrate_col2, substrate_col3])
+        product_eq_count_ui.change(fn=update_visibility_fn, 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)
+            image_output = gr.Image(label="Gráfico Generado", type="pil", width=600, height=900, scale=2, show_download_button=True)
             with gr.Column(scale=3):
                 analysis_output = gr.Markdown(label="Análisis del Modelo por IA")
         
-        all_inputs = [
+        # Lista de todos los inputs para el botón de submit
+        all_inputs_for_button = [
             file_input,
             biomass_eq1_ui, biomass_eq2_ui, biomass_eq3_ui,
             biomass_param1_ui, biomass_param2_ui, biomass_param3_ui,
@@ -117,24 +125,30 @@ def create_interface(process_function_for_button): # <-- AÑADIDO: process_funct
             product_eq_count_ui
         ]
         
-        # --- CONEXIÓN DEL BOTÓN DENTRO DEL CONTEXTO DE BLOCKS ---
+        outputs_for_button = [image_output, analysis_output]
+
+        # 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]
+            inputs=all_inputs_for_button,
+            outputs=outputs_for_button
         )
 
         # 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
-            ), 
+        # para los campos de ecuación 2 y 3.
+        def initial_visibility_setup(val_b, val_s, val_p):
+            return (
+                update_visibility_fn(val_b)[0], update_visibility_fn(val_b)[1],
+                update_visibility_fn(val_s)[0], update_visibility_fn(val_s)[1],
+                update_visibility_fn(val_p)[0], update_visibility_fn(val_p)[1]
+            )
+        demo.load(
+            fn=initial_visibility_setup, 
             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]
+            outputs=[
+                biomass_col2, biomass_col3, 
+                substrate_col2, substrate_col3, 
+                product_col2, product_col3
+            ]
         )
-
     return demo

app.py

@@ -1,11 +1,45 @@
 # app.py
 from UI import create_interface
 import interface as app_interface_module # Necesitamos la función process_and_plot
+import sys # Para manipulación de path si es necesario
+from pathlib import Path
+
+# --- Intento de Neutralizar el decorador problemático para ejecución local ---
+# Esto es un hack para evitar el error de 'No @spaces.GPU' si Gradio lo busca.
+try:
+    # Intentar importar el módulo 'decorators' de tu proyecto
+    # Asume que app.py está en la raíz del proyecto y decorators.py también
+    current_dir = Path(__file__).parent
+    if str(current_dir) not in sys.path:
+         sys.path.insert(0, str(current_dir))
+    import decorators
+    
+    class _GPUNeutralizerLocal:
+        def __init__(self, *args, **kwargs): pass
+        def __call__(self, func): return func
+    
+    # Sobrescribir si existen para que no causen error
+    if hasattr(decorators, 'GPU'):
+        decorators.GPU = _GPUNeutralizerLocal
+        print("INFO (app.py): 'decorators.GPU' neutralizado para ejecución local.")
+    if hasattr(decorators, 'gpu_decorator'):
+        decorators.gpu_decorator = lambda duration=0: lambda func: func
+        print("INFO (app.py): 'decorators.gpu_decorator' neutralizado para ejecución local.")
+
+except ImportError:
+    print("ADVERTENCIA (app.py): Módulo 'decorators' no encontrado, no se pudo neutralizar GPU. Puede que no sea necesario.")
+except Exception as e_dec:
+    print(f"ADVERTENCIA (app.py): Error al intentar neutralizar decoradores: {e_dec}")
+# --- Fin de la neutralización ---
+
 
 def main():
-    # 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()
+    # Pasa la función de procesamiento real (process_and_plot) a create_interface
+    # app_interface_module.process_and_plot es la función que queremos que el botón llame.
+    demo_instance = create_interface(process_function_for_button=app_interface_module.process_and_plot)
+    
+    print("Lanzando interfaz Gradio localmente...")
+    demo_instance.launch()
 
 if __name__ == "__main__":
     main()

model_app.py

@@ -3,7 +3,7 @@ import modal
 import sys
 from pathlib import Path
 import os
-import traceback # Para imprimir traceback detallado
+import traceback
 
 # --- Configuración ---
 PYTHON_VERSION = "3.10"
@@ -32,16 +32,16 @@ app_image = (
     )
 )
 
-# --- Función Modal para LLM (sin cambios respecto a la anterior respuesta) ---
+# --- Función Modal para LLM (sin cambios respecto a la anterior respuesta completa) ---
 @stub.function(
-    image=app_image,
+    image=app_image, # Hereda la imagen base del stub si está definida, o usa esta.
     gpu="any",
     secrets=[modal.Secret.from_name("huggingface-read-token", optional=True)],
-    timeout=600,
+    timeout=600, # 10 minutos
     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 # Mover importaciones pesadas dentro de la función Modal
+    import torch # Importaciones pesadas dentro de la función Modal
     from transformers import AutoTokenizer, AutoModelForCausalLM
     
     hf_token = os.environ.get("HUGGING_FACE_TOKEN") 
@@ -50,21 +50,22 @@ def generate_analysis_llm_modal_remote(prompt: str, model_path_config: str, max_
     print(f"LLM Modal Func: Cargando modelo: {model_path_config} con token: {'Sí' if hf_token else 'No'}")
 
     try:
-        tokenizer = AutoTokenizer.from_pretrained(model_path_config, cache_dir="/cache/huggingface/hub", token=hf_token)
+        tokenizer = AutoTokenizer.from_pretrained(model_path_config, cache_dir="/cache/huggingface/hub", token=hf_token, trust_remote_code=True)
         model = AutoModelForCausalLM.from_pretrained(
             model_path_config,
             torch_dtype="auto", 
             device_map="auto",
             cache_dir="/cache/huggingface/hub",
             token=hf_token,
+            trust_remote_code=True # Necesario para algunos modelos como Qwen
         )
         
-        # 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
+        model_context_window = getattr(model.config, 'max_position_embeddings', getattr(model.config, 'sliding_window', 4096)) # Para Qwen2 sliding_window
+        if model_context_window is None : model_context_window = 4096 # Fallback
         
+        max_prompt_len = model_context_window - max_new_tokens_config - 50 # Buffer
+        if max_prompt_len <=0 : max_prompt_len = model_context_window // 2 # Si max_new_tokens es muy grande
+
         inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=max_prompt_len).to(model.device)
 
         with torch.no_grad():
@@ -90,52 +91,72 @@ 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()
+@stub.asgi_app(image=app_image) # Especificar la imagen para el endpoint ASGI también
 def serve_gradio_app_asgi():
-    # Estas importaciones ocurren DENTRO del contenedor Modal
     import gradio as gr
-    # sys.path ya está configurado por la imagen, pero por si acaso:
+    
+    # sys.path ya está configurado por la imagen de Modal debido a .env({"PYTHONPATH": REMOTE_APP_DIR})
+    # y .copy_mount(... remote_path=REMOTE_APP_DIR)
+    # No obstante, una comprobación o inserción explícita no daña:
     if REMOTE_APP_DIR not in sys.path:
         sys.path.insert(0, REMOTE_APP_DIR)
+        print(f"INFO (modal_app.py): Añadido {REMOTE_APP_DIR} a sys.path")
     
-    from UI import create_interface # De tu UI.py
-    import interface as app_interface_module # El módulo interface.py
+    # --- Intento de Neutralizar el decorador problemático ANTES de las importaciones de la app ---
+    # Esto es para evitar el error "No @spaces.GPU function detected" si Gradio lo busca.
+    try:
+        import decorators # Intenta importar TU decorators.py
+        class _GPUNeutralizerModal:
+            def __init__(self, *args, **kwargs): pass
+            def __call__(self, func): return func
+        
+        if hasattr(decorators, 'GPU'):
+            decorators.GPU = _GPUNeutralizerModal
+            print("INFO (modal_app.py): 'decorators.GPU' neutralizado para el entorno Modal.")
+        if hasattr(decorators, 'gpu_decorator'):
+            decorators.gpu_decorator = lambda duration=0: lambda func: func
+            print("INFO (modal_app.py): 'decorators.gpu_decorator' neutralizado para el entorno Modal.")
+    except ImportError:
+        print("ADVERTENCIA (modal_app.py): Módulo 'decorators' no encontrado durante la neutralización. Esto puede ser OK.")
+    except Exception as e_neut:
+        print(f"ADVERTENCIA (modal_app.py): Error durante la neutralización de decoradores: {e_neut}")
+    # --- Fin de la neutralización ---
+
+    # Importar los módulos de la aplicación AHORA
+    from UI import create_interface
+    import interface as app_interface_module
     from config import MODEL_PATH as cfg_MODEL_PATH, MAX_LENGTH as cfg_MAX_LENGTH
 
-    # 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...")
+    # Wrapper para llamar a la función Modal remota desde tu interface.py
+    def analysis_func_wrapper_for_interface_modal(prompt: str) -> str:
+        print("Gradio Backend (Modal): Llamando a generate_analysis_llm_modal_remote.remote...")
         return generate_analysis_llm_modal_remote.remote(prompt, cfg_MODEL_PATH, cfg_MAX_LENGTH)
 
-    # Inyectar esta función wrapper en el módulo `interface`
-    app_interface_module.generate_analysis_from_modal = analysis_func_wrapper_for_interface
+    # Inyectar esta función wrapper en el módulo `interface` que usa Gradio
+    app_interface_module.generate_analysis_from_modal = analysis_func_wrapper_for_interface_modal
     app_interface_module.USE_MODAL_FOR_LLM_ANALYSIS = True
+    print("INFO (modal_app.py): Runner de LLM Modal inyectado en el módulo '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)
+    # Crear la app Gradio, pasándole la función de procesamiento real
+    gradio_ui_instance = create_interface(process_function_for_button=app_interface_module.process_and_plot)
     
-    return gr.routes.App.create_app(gradio_ui)
+    print("INFO (modal_app.py): Interfaz Gradio creada y lista para ser servida.")
+    return gr.routes.App.create_app(gradio_ui_instance)
 
 @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í.
+def test_llm_local_entry(): # Renombrado para evitar conflicto con el `test_llm` de la respuesta anterior
+    print("Probando la generación de LLM con Modal (local_entrypoint)...")
     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."
-    # 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:
+        # Para ejecutar esto, necesitarías que el stub esté activo.
+        # `modal run modal_app.py test_llm_local_entry`
         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}")
+        print(f"Error durante test_llm_local_entry: {e}")
         traceback.print_exc()