Upload 8 files

UI.py

@@ -0,0 +1,125 @@
+# 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():
+    """
+    Esta función crea la interfaz de usuario y la devuelve para que pueda ser lanzada
+    desde app.py utilizando demo.launch().
+    """
+    
+    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
+        gr.Markdown("# Modelado de Bioprocesos con Ecuaciones Personalizadas y Análisis por IA")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                gr.Markdown("### Carga de Datos y Configuración General")
+                file_input = gr.File(label="Subir archivo Excel (.xlsx)", file_types=[".xlsx"])
+                
+                show_legend_ui = gr.Checkbox(label="Mostrar leyenda en gráficos", value=True)
+                show_params_ui = gr.Checkbox(label="Mostrar parámetros ajustados en gráficos", value=True)
+                legend_position_ui = gr.Dropdown(
+                    label="Posición de la leyenda",
+                    choices=['best', 'upper right', 'upper left', 'lower right', 'lower left', 'center left', 'center right', 'lower center', 'upper center', 'center'],
+                    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)
+
+
+        # --- 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_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_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)`")
+            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_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_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_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_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_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_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)
+
+        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])
+        
+        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
+        
+        # Lista de todos los inputs para el botón de submit
+        all_inputs = [
+            file_input,
+            biomass_eq1_ui, biomass_eq2_ui, biomass_eq3_ui,
+            biomass_param1_ui, biomass_param2_ui, biomass_param3_ui,
+            biomass_bound1_ui, biomass_bound2_ui, biomass_bound3_ui,
+            substrate_eq1_ui, substrate_eq2_ui, substrate_eq3_ui,
+            substrate_param1_ui, substrate_param2_ui, substrate_param3_ui,
+            substrate_bound1_ui, substrate_bound2_ui, substrate_bound3_ui,
+            product_eq1_ui, product_eq2_ui, product_eq3_ui,
+            product_param1_ui, product_param2_ui, product_param3_ui,
+            product_bound1_ui, product_bound2_ui, product_bound3_ui,
+            legend_position_ui,
+            show_legend_ui,
+            show_params_ui,
+            biomass_eq_count_ui,
+            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])
+
+    return demo, all_inputs, [image_output, analysis_output], submit_button # Devolver también inputs, outputs y botón

app.py

@@ -0,0 +1,21 @@
+# app.py
+# Importar create_interface desde UI.py
+from UI import create_interface
+import interface as app_interface_module # Para el click handler
+
+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
+    )
+    
+    demo.launch()
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,17 @@
+# config.py
+import torch
+
+# Configuración del dispositivo
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Ruta al modelo de Hugging Face Hub que quieres usar para el análisis
+# Asegúrate de que tienes acceso a este modelo y que es compatible con AutoModelForCausalLM
+MODEL_PATH = "Qwen/Qwen2-7B-Instruct" # Ejemplo, Qwen2-7B-Instruct es un buen modelo.
+# MODEL_PATH = "mistralai/Mistral-7B-Instruct-v0.2" # Otro ejemplo
+# MODEL_PATH = "01-ai/Yi-1.5-9B-Chat" # Si prefieres Yi y es accesible
+
+# Longitud máxima para NUEVOS tokens generados por el LLM
+MAX_LENGTH = 1024 # Aumentado para permitir análisis más detallados
+
+# Temperatura para la generación de texto (ajusta según la creatividad deseada)
+TEMPERATURE = 0.5

decorators.py

@@ -0,0 +1,32 @@
+# decorators.py
+from functools import wraps
+# La importación original 'from spaces import GPU' es específica de Hugging Face Spaces.
+# Para un uso general o con Modal, este decorador necesitaría ser adaptado o
+# la gestión de GPU se haría directamente a través de la configuración de la función Modal.
+
+# Por ahora, mantenemos la estructura, pero ten en cuenta que @GPU no funcionará
+# fuera del entorno de HF Spaces tal como está. Modal tiene su propia forma de asignar GPUs.
+
+class GPU: # Placeholder para simular la estructura si no se ejecuta en HF Spaces
+    def __init__(self, duration=100):
+        self.duration = duration
+    def __call__(self, func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # print(f"Simulando ejecución con GPU (duración: {self.duration}s) para: {func.__name__}")
+            return func(*args, **kwargs)
+        return wrapper
+
+def gpu_decorator(duration=100):
+    """
+    Decorador personalizado que simula el uso de GPU.
+    En un entorno de Hugging Face Spaces con GPU asignada,
+    el decorador `spaces.GPU` real se encargaría de la gestión.
+    """
+    def decorator(func):
+        @GPU(duration=duration) # Usando nuestro placeholder o el real de `spaces`
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

interface.py

@@ -0,0 +1,306 @@
+# interface.py
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use('Agg') # Backend no interactivo para matplotlib en Modal/servidores
+import matplotlib.pyplot as plt
+from PIL import Image
+import io
+import json
+import traceback # Para imprimir traceback detallado de errores
+
+# Importar BioprocessModel de TU models.py (el que usa sympy)
+from models import BioprocessModel
+# from decorators import gpu_decorator # El decorador @gpu es de HF Spaces, Modal lo maneja diferente
+
+# Variables globales que serán "inyectadas" por modal_app.py
+USE_MODAL_FOR_LLM_ANALYSIS = False
+generate_analysis_from_modal = None # Placeholder para la función remota de Modal
+
+def parse_bounds_str(bounds_str_input, num_params):
+    """Parsea una cadena de límites y devuelve listas para lower y upper bounds."""
+    # Usar una copia para evitar modificar la entrada original si es mutable
+    bounds_str = str(bounds_str_input) 
+    
+    # Manejar el caso de cadena vacía o solo espacios en blanco
+    if not bounds_str.strip():
+        print(f"Cadena de límites vacía para {num_params} params. Usando límites (-inf, inf).")
+        return [-np.inf] * num_params, [np.inf] * num_params
+
+    try:
+        # Reemplazar 'inf' con 'np.inf' para que eval funcione correctamente con NumPy
+        # Hacerlo insensible a mayúsculas/minúsculas para 'inf'
+        bounds_str = bounds_str.lower().replace('inf', 'np.inf')
+        
+        # Evaluar la cadena para convertirla en una lista de tuplas o listas
+        # Ejemplo de entrada esperada: " (0, np.inf), (0,10), (np.nan, np.nan) "
+        # Asegurar que esté encerrado en corchetes para que eval produzca una lista
+        if not bounds_str.startswith('['):
+            bounds_str = f"[{bounds_str}]"
+            
+        parsed_bounds_list = eval(bounds_str)
+
+        if not isinstance(parsed_bounds_list, list):
+            raise ValueError("La cadena de límites no evaluó a una lista.")
+
+        if len(parsed_bounds_list) != num_params:
+            raise ValueError(f"Número de tuplas de límites ({len(parsed_bounds_list)}) no coincide con el número de parámetros ({num_params}).")
+
+        lower_bounds = []
+        upper_bounds = []
+        for item in parsed_bounds_list:
+            if not (isinstance(item, (tuple, list)) and len(item) == 2):
+                raise ValueError(f"Cada límite debe ser una tupla/lista de dos elementos (low, high). Se encontró: {item}")
+            # np.nan puede ser usado para indicar sin límite, curve_fit lo trata como -inf/inf
+            low = -np.inf if (item[0] is None or (isinstance(item[0], float) and np.isnan(item[0]))) else float(item[0])
+            high = np.inf if (item[1] is None or (isinstance(item[1], float) and np.isnan(item[1]))) else float(item[1])
+            lower_bounds.append(low)
+            upper_bounds.append(high)
+            
+        return lower_bounds, upper_bounds
+    except Exception as e:
+        print(f"Error al parsear los límites '{bounds_str_input}': {e}. Usando límites por defecto (-inf, inf).")
+        return [-np.inf] * num_params, [np.inf] * num_params
+
+
+def call_llm_analysis_service(prompt: str) -> str:
+    """Llama al servicio LLM (ya sea localmente o a través de Modal)."""
+    if USE_MODAL_FOR_LLM_ANALYSIS and generate_analysis_from_modal:
+        print("interface.py: Usando la función de análisis LLM de Modal...")
+        try:
+            # La función wrapper en modal_app.py obtiene MODEL_PATH y MAX_LENGTH de config.py
+            return generate_analysis_from_modal(prompt)
+        except Exception as e_modal_call:
+            print(f"Error llamando a la función Modal LLM: {e_modal_call}")
+            return f"Error al contactar el servicio de análisis IA (Modal): {e_modal_call}"
+    else:
+        # --- Implementación de Fallback (o si no se usa Modal) ---
+        print("interface.py: Usando la función de análisis LLM local (fallback)...")
+        try:
+            # Esta parte necesitaría que cargues el modelo localmente
+            # como lo hacías en tu versión original de interface.py
+            from config import MODEL_PATH, MAX_LENGTH, DEVICE # Importar configuración local
+            from transformers import AutoTokenizer, AutoModelForCausalLM # Importaciones locales
+            
+            print(f"Fallback: Cargando modelo {MODEL_PATH} localmente en {DEVICE}...")
+            tokenizer_local = AutoTokenizer.from_pretrained(MODEL_PATH)
+            model_local = AutoModelForCausalLM.from_pretrained(MODEL_PATH).to(DEVICE) # No .eval() aquí
+            
+            inputs = tokenizer_local(prompt, return_tensors="pt").to(DEVICE)
+            with torch.no_grad(): # Importante para inferencia
+                outputs = model_local.generate(
+                    **inputs,
+                    max_new_tokens=MAX_LENGTH,
+                    eos_token_id=tokenizer_local.eos_token_id,
+                    pad_token_id=tokenizer_local.pad_token_id if tokenizer_local.pad_token_id else tokenizer_local.eos_token_id,
+                    do_sample=True, temperature=0.6, top_p=0.9
+                )
+            input_len = inputs.input_ids.shape[1]
+            analysis = tokenizer_local.decode(outputs[0][input_len:], skip_special_tokens=True)
+            return analysis.strip()
+        except Exception as e_local_llm:
+            print(f"Error en el fallback LLM local: {e_local_llm}")
+            return f"Análisis (fallback local): Error al cargar/ejecutar modelo LLM local: {e_local_llm}."
+
+# @gpu_decorator(duration=100) # Este decorador es de HF Spaces. Modal gestiona GPU diferente.
+def process_and_plot(
+    file_obj, # Gradio pasa un objeto File
+    # Entradas de la UI (desempaquetadas)
+    biomass_eq1_ui, biomass_eq2_ui, biomass_eq3_ui,
+    biomass_param1_ui, biomass_param2_ui, biomass_param3_ui,
+    biomass_bound1_ui, biomass_bound2_ui, biomass_bound3_ui,
+    substrate_eq1_ui, substrate_eq2_ui, substrate_eq3_ui,
+    substrate_param1_ui, substrate_param2_ui, substrate_param3_ui,
+    substrate_bound1_ui, substrate_bound2_ui, substrate_bound3_ui,
+    product_eq1_ui, product_eq2_ui, product_eq3_ui,
+    product_param1_ui, product_param2_ui, product_param3_ui,
+    product_bound1_ui, product_bound2_ui, product_bound3_ui,
+    legend_position_ui,
+    show_legend_ui,
+    show_params_ui,
+    biomass_eq_count_ui,
+    substrate_eq_count_ui,
+    product_eq_count_ui
+):
+    analysis_text = "Iniciando análisis..."
+    if file_obj is None:
+        return None, "Error: Por favor, sube un archivo Excel."
+    
+    try:
+        df = pd.read_excel(file_obj.name) # .name para obtener el path del archivo temporal de Gradio
+    except Exception as e:
+        return None, f"Error al leer el archivo Excel: {e}\n{traceback.format_exc()}"
+
+    expected_cols = ['Tiempo', 'Biomasa', 'Sustrato', 'Producto']
+    for col in expected_cols:
+        if col not in df.columns:
+            return None, f"Error: La columna '{col}' no se encuentra en el archivo Excel."
+
+    time_data = df['Tiempo'].values
+    biomass_data_exp = df['Biomasa'].values
+    substrate_data_exp = df['Sustrato'].values
+    product_data_exp = df['Producto'].values
+
+    # Convertir contadores a enteros
+    active_biomass_eqs = int(biomass_eq_count_ui)
+    active_substrate_eqs = int(substrate_eq_count_ui)
+    active_product_eqs = int(product_eq_count_ui)
+
+    # Agrupar entradas de la UI
+    all_eq_inputs = {
+        'biomass': (
+            [biomass_eq1_ui, biomass_eq2_ui, biomass_eq3_ui][:active_biomass_eqs],
+            [biomass_param1_ui, biomass_param2_ui, biomass_param3_ui][:active_biomass_eqs],
+            [biomass_bound1_ui, biomass_bound2_ui, biomass_bound3_ui][:active_biomass_eqs],
+            biomass_data_exp
+        ),
+        'substrate': (
+            [substrate_eq1_ui, substrate_eq2_ui, substrate_eq3_ui][:active_substrate_eqs],
+            [substrate_param1_ui, substrate_param2_ui, substrate_param3_ui][:active_substrate_eqs],
+            [substrate_bound1_ui, substrate_bound2_ui, substrate_bound3_ui][:active_substrate_eqs],
+            substrate_data_exp
+        ),
+        'product': (
+            [product_eq1_ui, product_eq2_ui, product_eq3_ui][:active_product_eqs],
+            [product_param1_ui, product_param2_ui, product_param3_ui][:active_product_eqs],
+            [product_bound1_ui, product_bound2_ui, product_bound3_ui][:active_product_eqs],
+            product_data_exp
+        )
+    }
+
+    model_handler = BioprocessModel() # De TU models.py (el que usa sympy)
+    
+    fitted_results_for_plot = {'biomass': [], 'substrate': [], 'product': []}
+    results_for_llm_prompt = {'biomass': [], 'substrate': [], 'product': []}
+    biomass_params_for_s_p = None # Para almacenar parámetros de biomasa ajustados
+
+    for model_type, (eq_list, param_str_list, bound_str_list, exp_data) in all_eq_inputs.items():
+        if not exp_data.any(): # Si no hay datos experimentales para este componente, saltar
+            print(f"No hay datos experimentales para {model_type}, saltando ajuste.")
+            continue
+
+        for i in range(len(eq_list)):
+            eq_str = eq_list[i]
+            param_s = param_str_list[i]
+            bound_s = bound_str_list[i]
+
+            if not eq_str or not param_s:
+                print(f"Ecuación o parámetros vacíos para {model_type} #{i+1}, saltando.")
+                continue
+            
+            print(f"Procesando {model_type} #{i+1}: Eq='{eq_str}', Params='{param_s}'")
+
+            try:
+                model_handler.set_model(model_type, eq_str, param_s)
+                num_p = len(model_handler.models[model_type]['params'])
+                l_b, u_b = parse_bounds_str(bound_s, num_p)
+                
+                # Pasar biomass_params_fitted si es sustrato o producto
+                current_biomass_params = biomass_params_for_s_p if model_type in ['substrate', 'product'] else None
+                
+                y_pred, popt = model_handler.fit_model(model_type, time_data, exp_data, bounds=(l_b, u_b), biomass_params_fitted=current_biomass_params)
+                
+                # Guardar resultados
+                current_params = model_handler.params[model_type]
+                r2_val = model_handler.r2.get(model_type, float('nan'))
+                rmse_val = model_handler.rmse.get(model_type, float('nan'))
+
+                fitted_results_for_plot[model_type].append({
+                    'equation': eq_str, 
+                    'y_pred': y_pred, 
+                    'params': current_params, 
+                    'R2': r2_val
+                })
+                results_for_llm_prompt[model_type].append({
+                    'equation': eq_str, 
+                    'params_fitted': current_params, 
+                    'R2': r2_val, 
+                    'RMSE': rmse_val
+                })
+
+                # Si es el primer modelo de biomasa ajustado con éxito, guardar sus parámetros
+                if model_type == 'biomass' and biomass_params_for_s_p is None:
+                    biomass_params_for_s_p = current_params
+                    print(f"Parámetros de Biomasa (para S/P): {biomass_params_for_s_p}")
+
+            except Exception as e:
+                error_msg = f"Error ajustando {model_type} #{i+1} ('{eq_str}'): {e}\n{traceback.format_exc()}"
+                print(error_msg)
+                # Devolver error a la UI en lugar de solo None
+                return None, error_msg 
+
+    # Generar gráfico
+    fig, axs = plt.subplots(3, 1, figsize=(10, 18), sharex=True) # Aumentar altura
+    plot_config = {
+        axs[0]: (biomass_data_exp, 'Biomasa', fitted_results_for_plot['biomass']),
+        axs[1]: (substrate_data_exp, 'Sustrato', fitted_results_for_plot['substrate']),
+        axs[2]: (product_data_exp, 'Producto', fitted_results_for_plot['product'])
+    }
+
+    for ax, data_actual, ylabel, plot_results_list in plot_config.items():
+        ax.plot(time_data, data_actual, 'o', label=f'Datos {ylabel}', markersize=5, alpha=0.7)
+        for idx, res_detail in enumerate(plot_results_list):
+            label = f'Modelo {idx+1} (R²:{res_detail["R2"]:.3f})'
+            # if len(plot_results_list) == 1: label = f'Modelo {ylabel} (R²:{res_detail["R2"]:.3f})'
+            ax.plot(time_data, res_detail['y_pred'], '-', label=label, linewidth=2)
+        ax.set_xlabel('Tiempo')
+        ax.set_ylabel(ylabel)
+        ax.grid(True, linestyle=':', alpha=0.7)
+        if show_legend_ui:
+            ax.legend(loc=legend_position_ui, fontsize='small')
+        
+        if show_params_ui and plot_results_list:
+            # Mostrar parámetros para todos los modelos ajustados en este subplot
+            param_display_texts = []
+            for idx, res_detail in enumerate(plot_results_list):
+                params_text = f"Modelo {idx+1}:\n" + "\n".join([f"  {k}: {v:.4g}" for k,v in res_detail['params'].items()])
+                param_display_texts.append(params_text)
+            full_param_text = "\n---\n".join(param_display_texts)
+            
+            # Ajustar posición del texto para que no se solape con la leyenda si es posible
+            text_x_pos = 0.02
+            text_y_pos = 0.98
+            v_align = 'top'
+            if legend_position_ui and 'upper' in legend_position_ui:
+                 text_y_pos = 0.02
+                 v_align = 'bottom'
+
+            ax.text(text_x_pos, text_y_pos, full_param_text, transform=ax.transAxes, fontsize=7,
+                    verticalalignment=v_align, bbox=dict(boxstyle='round,pad=0.3', fc='lightyellow', alpha=0.8))
+
+    plt.tight_layout(rect=[0, 0, 1, 0.96]) # Ajustar para el suptitle si lo hubiera
+    fig.suptitle("Resultados del Ajuste de Modelos Cinéticos", fontsize=16)
+    
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=150) # Aumentar dpi para mejor calidad
+    buf.seek(0)
+    image = Image.open(buf)
+    plt.close(fig) # Cerrar la figura para liberar memoria
+
+    # Construir prompt para LLM
+    prompt_intro = "Eres un experto en modelado cinético de bioprocesos. Analiza los siguientes resultados del ajuste de modelos a datos experimentales:\n\n"
+    prompt_details = json.dumps(results_for_llm_prompt, indent=2, ensure_ascii=False)
+    prompt_instructions = """\n\nPor favor, proporciona un análisis detallado y crítico en español, estructurado de la siguiente manera:
+1.  **Resumen General:** Una breve descripción del experimento y qué se intentó modelar.
+2.  **Análisis por Componente (Biomasa, Sustrato, Producto):**
+    a.  Para cada ecuación probada:
+        i.  Calidad del Ajuste: Evalúa el R² (cercano a 1 es ideal) y el RMSE (más bajo es mejor). Comenta si el ajuste es bueno, regular o pobre.
+        ii. Interpretación de Parámetros: Explica brevemente qué representan los parámetros ajustados y si sus valores parecen razonables en un contexto de bioproceso (ej. tasas positivas, concentraciones no negativas).
+        iii. Ecuación Específica: Menciona la ecuación usada.
+    b.  Comparación (si se probó más de una ecuación para un componente): ¿Cuál ecuación proporcionó el mejor ajuste y por qué?
+3.  **Problemas y Limitaciones:**
+    a.  ¿Hay problemas evidentes (ej. R² muy bajo, parámetros físicamente no realistas, sobreajuste si se puede inferir, etc.)?
+    b.  ¿Qué limitaciones podrían tener los modelos o el proceso de ajuste?
+4.  **Sugerencias y Próximos Pasos:**
+    a.  ¿Cómo se podría mejorar el modelado (ej. probar otras ecuaciones, transformar datos, revisar calidad de datos experimentales)?
+    b.  ¿Qué experimentos adicionales podrían realizarse para validar o refinar los modelos?
+5.  **Conclusión Final:** Un veredicto general sobre el éxito del modelado y la utilidad de los resultados obtenidos.
+
+Utiliza un lenguaje claro y accesible, pero manteniendo el rigor técnico. El análisis debe ser útil para alguien que busca entender la cinética de su bioproceso."""
+    
+    full_prompt = prompt_intro + prompt_details + prompt_instructions
+    
+    # Llamar al servicio LLM (ya sea Modal o local)
+    analysis_text = call_llm_analysis_service(full_prompt)
+
+    return image, analysis_text

model_app.py

@@ -0,0 +1,138 @@
+# modal_app.py
+import modal
+import sys
+from pathlib import Path
+import os # Para HF_TOKEN
+
+# --- 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
+
+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")
+    .copy_mount(
+        modal.Mount.from_local_dir(LOCAL_APP_DIR, remote_path=REMOTE_APP_DIR)
+    )
+    .env({
+        "PYTHONPATH": REMOTE_APP_DIR,
+        "HF_HOME": "/cache/huggingface", # Directorio de caché de Hugging Face
+        "HF_HUB_CACHE": "/cache/huggingface/hub",
+        "TRANSFORMERS_CACHE": "/cache/huggingface/hub", # Alias común
+        "MPLCONFIGDIR": "/tmp/matplotlib_cache" # Para evitar warnings de matplotlib
+    })
+    .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é
+    )
+)
+
+# --- Función Modal para Generación de Análisis con LLM ---
+@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
+    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
+    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'}")
+
+    try:
+        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
+            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
+
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens_config,
+                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
+                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)
+        
+        print(f"LLM Modal Func: Longitud del análisis generado: {len(analysis)} caracteres.")
+        return analysis.strip()
+    except Exception as e:
+        error_traceback = traceback.format_exc()
+        print(f"Error en generate_analysis_llm_modal_remote: {e}\n{error_traceback}")
+        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í
+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
+    
+    # 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 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
+    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)
+
+    # Inyectar esta función wrapper en el módulo `interface`
+    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()
+    
+    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
+
+# (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)...")
+    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)

models.py

@@ -0,0 +1,195 @@
+# models.py
+import numpy as np
+from scipy.optimize import curve_fit
+from sympy import symbols, sympify, lambdify
+import warnings
+from sklearn.metrics import mean_squared_error # Asegúrate que está importado
+
+class BioprocessModel:
+    def __init__(self):
+        self.params = {}  # Almacenará los parámetros ajustados para cada tipo de modelo
+        self.models = {}  # Almacenará la configuración de cada tipo de modelo (ecuación, función, etc.)
+        self.r2 = {}      # Almacenará el R^2 para cada tipo de modelo
+        self.rmse = {}    # Almacenará el RMSE para cada tipo de modelo
+
+    def set_model(self, model_type, equation_str, param_str):
+        """
+        Configura un modelo (Biomasa, Sustrato, Producto) usando una ecuación simbólica.
+
+        :param model_type: 'biomass', 'substrate', o 'product'
+        :param equation_str: La ecuación como una cadena de texto (ej. "Xm * (1 - exp(-um * t))")
+                             Si la ecuación es para sustrato o producto y depende de la biomasa X(t),
+                             se debe usar 'X_val' en la ecuación para representar el valor de X(t).
+        :param param_str: Cadena de parámetros separados por comas (ej. "Xm, um")
+        """
+        equation_str = equation_str.strip()
+        # Si el usuario escribe "Y = ...", tomar solo la parte derecha
+        if '=' in equation_str:
+            equation_str = equation_str.split('=', 1)[1].strip()
+
+        params_list = [param.strip() for param in param_str.split(',')]
+        
+        self.models[model_type] = {
+            'equation_str': equation_str,
+            'params': params_list
+        }
+
+        # Símbolos para el tiempo y los parámetros del modelo actual
+        t_sym = symbols('t')
+        current_param_syms = symbols(params_list)
+        
+        # Argumentos para lambdify
+        lambdify_args = [t_sym] + list(current_param_syms)
+        
+        # Si el modelo es sustrato o producto, puede depender de la biomasa (X_val)
+        # y de los parámetros de biomasa ajustados.
+        # La función `lambdify` solo manejará los parámetros directos de este modelo.
+        # La dependencia de X(t) se resolverá en la función de ajuste.
+        
+        # Si la ecuación contiene 'X_val' (representando X(t) para modelos S y P)
+        # lo añadimos como un símbolo que se sustituirá en la función de ajuste.
+        all_symbols_in_eq = sympify(equation_str).free_symbols
+        
+        final_lambdify_args = list(lambdify_args) # Copia para modificar
+        
+        # Manejo de X_val para modelos S y P que dependen de biomasa
+        # No es necesario añadir X_val a lambdify_args aquí si se maneja en fit_model_wrapper
+        # func = lambdify(final_lambdify_args, sympify(equation_str), 'numpy')
+        
+        # Guardar los símbolos para uso posterior si es necesario
+        self.models[model_type]['sympy_expr'] = sympify(equation_str)
+        self.models[model_type]['param_symbols'] = current_param_syms
+        self.models[model_type]['time_symbol'] = t_sym
+        # La función compilada ('function') se creará dinámicamente en fit_model para manejar dependencias
+
+    def fit_model(self, model_type, time, data, bounds, biomass_params_fitted=None):
+        """
+        Ajusta el modelo configurado a los datos.
+
+        :param model_type: 'biomass', 'substrate', o 'product'
+        :param time: Array de datos de tiempo
+        :param data: Array de datos observados
+        :param bounds: Tupla (lower_bounds, upper_bounds) para los parámetros
+        :param biomass_params_fitted: Dict de parámetros de biomasa ajustados (necesario para sustrato/producto)
+        :return: (y_pred, popt) - Datos predichos y parámetros optimizados
+        """
+        if model_type not in self.models:
+            raise ValueError(f"Modelo para '{model_type}' no configurado. Llama a set_model primero.")
+
+        model_config = self.models[model_type]
+        equation_expr = model_config['sympy_expr']
+        current_param_names = model_config['params']
+        current_param_syms = model_config['param_symbols']
+        t_sym = model_config['time_symbol']
+
+        # Construir la función a ajustar con curve_fit
+        # Esta función tomará `t` y los parámetros del modelo actual como `*args`
+        def fit_model_wrapper(t_data, *current_p_values):
+            # Crear un diccionario de sustitución para los parámetros del modelo actual
+            subs_dict = {sym: val for sym, val in zip(current_param_syms, current_p_values)}
+            
+            # Si es sustrato o producto y depende de la biomasa (X_val)
+            X_val_sym = symbols('X_val') # Símbolo para X(t)
+            if model_type in ['substrate', 'product'] and X_val_sym in equation_expr.free_symbols:
+                if biomass_params_fitted is None or 'biomass' not in self.models:
+                    raise ValueError("Parámetros de biomasa ajustados son necesarios para modelos de sustrato/producto que dependen de X(t).")
+                
+                # Calcular X(t) usando el modelo de biomasa ajustado y los t_data actuales
+                biomass_model_config = self.models['biomass']
+                biomass_expr = biomass_model_config['sympy_expr']
+                biomass_p_syms = biomass_model_config['param_symbols']
+                
+                # Crear dict de sustitución para parámetros de biomasa
+                biomass_subs_dict = {sym: biomass_params_fitted[name] for sym, name in zip(biomass_p_syms, biomass_model_config['params'])}
+                
+                # Evaluar X(t) para cada punto en t_data
+                X_t_values = np.array([
+                    biomass_expr.subs(biomass_subs_dict).subs({biomass_model_config['time_symbol']: ti}).evalf() 
+                    for ti in t_data
+                ], dtype=float)
+                
+                # Añadir X_val (X(t)) al diccionario de sustituciones para la ecuación actual
+                subs_dict[X_val_sym] = X_t_values
+            
+            # Evaluar la ecuación del modelo actual (sustrato, producto, o biomasa)
+            # con los valores de sus parámetros y X(t) si es aplicable
+            # Es importante que la ecuación use t_sym como variable independiente
+            # y que lambdify se haga sobre (t_sym, *current_param_syms, X_val_sym_if_present)
+            
+            # Re-lambdify aquí para asegurar el scope correcto de X_t_values si se usa X_val_sym
+            args_for_lambdify = [t_sym] + list(current_param_syms)
+            final_expr = equation_expr # Expresión original
+            
+            # Si X_val está en la ecuación, NO lo incluimos en args_for_lambdify
+            # sino que lo sustituimos ANTES de lambdify o lo pasamos como constante si es posible.
+            # Lo más robusto es sustituir X_val en la expresión ANTES de lambdify
+            if X_val_sym in equation_expr.free_symbols and X_val_sym in subs_dict:
+                # Si X_val es un array (porque t_data es un array), no podemos sustituirlo directamente
+                # en la expresión simbólica para crear una única función lambdify que tome `t`.
+                # En su lugar, evaluamos la expresión punto por punto después de sustituir parámetros.
+                # Esto es menos eficiente que un lambdify completo, pero más flexible.
+                
+                # Evaluación numérica punto por punto
+                # No necesitamos lambdify si X_val es un array y se evalúa punto por punto
+                # La función `fit_model_wrapper` ya está iterando sobre los `t_data` (implícitamente a través de numpy)
+                # Entonces, si X_val es un array, la expresión `final_expr.subs(subs_dict)` debería funcionar si
+                # las operaciones son compatibles con numpy arrays (sympy suele hacerlo).
+                #
+                # La forma en que se llama a esta función desde curve_fit es: `fit_model_wrapper(time, p1, p2, ...)`
+                # donde `time` es el array completo de tiempos.
+                # `X_t_values` es un array de la misma longitud que `time`.
+                
+                # Simpler lambdify for the current model parameters, handle X_val in wrapper
+                func_for_current_model = lambdify(args_for_lambdify, equation_expr.subs({X_val_sym: X_val_sym}), 'numpy') # Keep X_val symbolic for now
+                
+                # Now call it, and if it needs X_val, it must be part of its signature or global
+                # This part is tricky with sympy and curve_fit when there are interdependencies.
+                # The lambda should capture X_t_values correctly if subs_dict[X_val_sym] is set.
+                
+                # Let's evaluate por punto para mayor robustez con X_val siendo un array
+                y_calculated = np.empty_like(t_data, dtype=float)
+                for i, ti in enumerate(t_data):
+                    point_subs = subs_dict.copy()
+                    point_subs[t_sym] = ti
+                    if X_val_sym in point_subs and isinstance(point_subs[X_val_sym], np.ndarray):
+                         # Si X_val es un array, tomar el valor correspondiente a ti
+                        point_subs[X_val_sym] = point_subs[X_val_sym][i]
+                    
+                    y_calculated[i] = equation_expr.subs(point_subs).evalf()
+                return y_calculated
+
+            else: # Modelo de Biomasa o modelo S/P que no usa X_val (raro)
+                func = lambdify(args_for_lambdify, equation_expr, 'numpy')
+                return func(t_data, *current_p_values)
+
+
+        p0 = np.ones(len(current_param_names))  # Estimaciones iniciales
+        lower_bounds, upper_bounds = bounds
+
+        # Asegurar que los límites tengan la longitud correcta
+        lower_bounds = np.array(lower_bounds if len(lower_bounds) == len(p0) else [-np.inf] * len(p0))
+        upper_bounds = np.array(upper_bounds if len(upper_bounds) == len(p0) else [np.inf] * len(p0))
+        
+        # Ignorar advertencias de RuntimeWarning de operaciones inválidas (ej. división por cero durante la optimización)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            warnings.simplefilter("ignore", UserWarning) # Sympy lambdify warnings
+            popt, pcov = curve_fit(fit_model_wrapper, time, data, p0=p0, bounds=(lower_bounds, upper_bounds), maxfev=100000)
+
+        self.params[model_type] = dict(zip(current_param_names, popt))
+        
+        # Calcular R^2 y RMSE usando los parámetros ajustados
+        # Es importante volver a llamar a fit_model_wrapper para obtener y_pred con los popt,
+        # ya que la función interna maneja las dependencias de X(t)
+        y_pred = fit_model_wrapper(time, *popt)
+        
+        ss_res = np.sum((data - y_pred) ** 2)
+        ss_tot = np.sum((data - np.mean(data)) ** 2)
+        if ss_tot == 0: # Evitar división por cero si los datos son constantes
+            self.r2[model_type] = 1.0 if ss_res < 1e-9 else 0.0
+        else:
+            self.r2[model_type] = 1 - (ss_res / ss_tot)
+        
+        self.rmse[model_type] = np.sqrt(mean_squared_error(data, y_pred))
+
+        return y_pred, popt # Devolver y_pred y los parámetros optimizados

requirements.txt

@@ -0,0 +1,15 @@
+gradio==4.29.0
+numpy
+pandas
+matplotlib
+scipy
+sympy
+openpyxl
+Pillow
+torch
+transformers
+sentencepiece
+scikit-learn
+seaborn
+accelerate
+huggingface_hub