Upload 2 files

UI.py

@@ -3,7 +3,7 @@ import gradio as gr
 import numpy as np # Importar numpy para np.inf
 
 def create_interface(process_function_for_button):
-    with gr.Blocks(theme='gradio/soft') as demo: # Usar un theme común de Gradio
+    with gr.Blocks(theme='gradio/soft') as demo: 
         gr.Markdown("# Modelado de Bioprocesos con Ecuaciones Personalizadas y Análisis por IA")
 
         with gr.Row():
@@ -16,11 +16,10 @@ def create_interface(process_function_for_button):
                 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' # String value, esto está bien
+                    value='best'
                 )
             with gr.Column(scale=1):
                 gr.Markdown("### Conteo de Ecuaciones a Probar")
-                # Asegurar que los valores son numéricos y dentro del rango
                 biomass_eq_count_ui = gr.Number(label="Biomasa (1-3)", value=1, minimum=1, maximum=3, step=1, precision=0)
                 substrate_eq_count_ui = gr.Number(label="Sustrato (1-3)", value=1, minimum=1, maximum=3, step=1, precision=0)
                 product_eq_count_ui = gr.Number(label="Producto (1-3)", value=1, minimum=1, maximum=3, step=1, precision=0)
@@ -30,10 +29,9 @@ def create_interface(process_function_for_button):
             with gr.Row():
                 with gr.Column(): # Columna 1 siempre visible
                     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, coma sep. '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). Use np.inf o None.")
+                    biomass_param1_ui = gr.Textbox(label="Parámetros Biomasa 1", value="Xm, um, t_lag", info="Nombres, 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). Use np.inf.")
                 
-                # Definir Columnas 2 y 3 fuera del `with` si se manipula su visibilidad programáticamente
                 biomass_col2_container = gr.Column(visible=False) 
                 with biomass_col2_container:
                     biomass_eq2_ui = gr.Textbox(label="Ecuación de Biomasa 2", value="X0 * exp(um * t)", lines=2)
@@ -42,7 +40,7 @@ def create_interface(process_function_for_button):
                 
                 biomass_col3_container = gr.Column(visible=False)
                 with biomass_col3_container:
-                    biomass_eq3_ui = gr.Textbox(label="Ecuación de Biomasa 3", lines=2, value="") # Explicit empty string
+                    biomass_eq3_ui = gr.Textbox(label="Ecuación de Biomasa 3", lines=2, value="")
                     biomass_param3_ui = gr.Textbox(label="Parámetros Biomasa 3", value="")
                     biomass_bound3_ui = gr.Textbox(label="Límites Biomasa 3", value="")
         
@@ -89,9 +87,10 @@ def create_interface(process_function_for_button):
 
         # Lógica para mostrar/ocultar campos de ecuación dinámicamente
         def update_eq_visibility(count_value):
-            # count_value es float si viene de gr.Number, convertir a int
-            count = int(count_value) 
-            return gr.update(visible=count >= 2), gr.update(visible=count >= 3)
+            # Asegurar que el valor es entero antes de la comparación
+            count = int(count_value)
+            # Retorna diccionarios de actualización para `gr.update`
+            return { "visible": count >= 2 }, { "visible": count >= 3 }
 
         biomass_eq_count_ui.change(fn=update_eq_visibility, inputs=biomass_eq_count_ui, outputs=[biomass_col2_container, biomass_col3_container])
         substrate_eq_count_ui.change(fn=update_eq_visibility, inputs=substrate_eq_count_ui, outputs=[substrate_col2_container, substrate_col3_container])
@@ -101,10 +100,11 @@ def create_interface(process_function_for_button):
         
         gr.Markdown("## Resultados del Análisis")
         with gr.Row():
-            image_output = gr.Image(label="Gráfico Generado", type="pil", scale=2, show_download_button=True, height=600) # Ajustar altura
+            image_output = gr.Image(label="Gráfico Generado", type="pil", scale=2, show_download_button=True, height=600)
             with gr.Column(scale=3):
-                analysis_output = gr.Markdown(label="Análisis del Modelo por IA") # Usar Markdown para mejor formato
+                analysis_output = gr.Markdown(label="Análisis del Modelo por IA")
         
+        # 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,
@@ -132,12 +132,17 @@ def create_interface(process_function_for_button):
         )
 
         # Inicializar visibilidad usando demo.load para que se aplique al cargar la UI
-        def set_initial_visibility_on_load_wrapper(b_c, s_c, p_c):
-            # Convertir a int, ya que el valor inicial de gr.Number puede ser float
-            b_c_int, s_c_int, p_c_int = int(b_c), int(s_c), int(p_c)
+        # Esto asegura que el estado inicial de visibilidad es correcto
+        def set_initial_visibility_on_load_wrapper(b_c_val, s_c_val, p_c_val):
+            # Obtener los valores iniciales de los gr.Number components
+            # y aplicar la lógica de visibilidad.
+            # Los valores de los Number inputs pueden ser float, convertirlos a int
+            b_c_int, s_c_int, p_c_int = int(b_c_val), int(s_c_val), int(p_c_val)
+            
             b_vis2_upd, b_vis3_upd = update_eq_visibility(b_c_int)
             s_vis2_upd, s_vis3_upd = update_eq_visibility(s_c_int)
             p_vis2_upd, p_vis3_upd = update_eq_visibility(p_c_int)
+            
             return b_vis2_upd, b_vis3_upd, s_vis2_upd, s_vis3_upd, p_vis2_upd, p_vis3_upd
 
         demo.load(

interface.py

@@ -2,44 +2,33 @@
 import numpy as np
 import pandas as pd
 import matplotlib
-matplotlib.use('Agg') # Backend no interactivo para matplotlib en Modal/servidores
+matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 from PIL import Image
 import io
 import json
-import traceback # Para imprimir traceback detallado de errores
+import traceback
 
-# 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
+from models import BioprocessModel # Asegúrate que esto apunta a tu models.py
+# from decorators import gpu_decorator # Mantener comentado si usas Modal
 
-# Variables globales que serán "inyectadas" por modal_app.py
+# Variables globales inyectadas por modal_app.py o app.py
 USE_MODAL_FOR_LLM_ANALYSIS = False
-generate_analysis_from_modal = None # Placeholder para la función remota de Modal
+generate_analysis_from_modal = None 
 
 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).")
+    bounds_str = str(bounds_str_input).strip()
+    if not bounds_str:
+        print(f"Cadena de límites vacía para {num_params} params. Usando (-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 = bounds_str.lower().replace('inf', 'np.inf').replace('none', 'None')
+        if not (bounds_str.startswith('[') and bounds_str.endswith(']')): # Asegurar que sea una lista
             bounds_str = f"[{bounds_str}]"
             
-        parsed_bounds_list = eval(bounds_str)
-
+        parsed_bounds_list = eval(bounds_str, {'np': np, 'inf': np.inf, 'None': None}) # Evaluar con np
+        
         if not isinstance(parsed_bounds_list, list):
             raise ValueError("La cadena de límites no evaluó a una lista.")
 
@@ -51,9 +40,11 @@ def parse_bounds_str(bounds_str_input, num_params):
         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
+            
+            # Convertir a float y manejar None/np.nan
             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)
             
@@ -64,30 +55,30 @@ def parse_bounds_str(bounds_str_input, 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}")
+            traceback.print_exc() # Imprimir el traceback de la llamada a Modal
             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í
+            model_local = AutoModelForCausalLM.from_pretrained(MODEL_PATH).to(DEVICE)
             
-            inputs = tokenizer_local(prompt, return_tensors="pt").to(DEVICE)
-            with torch.no_grad(): # Importante para inferencia
+            model_context_window = getattr(model_local.config, 'max_position_embeddings', getattr(model_local.config, 'sliding_window', 4096))
+            max_prompt_len = model_context_window - MAX_LENGTH - 50 
+            if max_prompt_len <= 0 : max_prompt_len = model_context_window // 2 
+
+            inputs = tokenizer_local(prompt, return_tensors="pt", truncation=True, max_length=max_prompt_len).to(DEVICE)
+            with torch.no_grad():
                 outputs = model_local.generate(
                     **inputs,
                     max_new_tokens=MAX_LENGTH,
@@ -100,12 +91,12 @@ def call_llm_analysis_service(prompt: str) -> str:
             return analysis.strip()
         except Exception as e_local_llm:
             print(f"Error en el fallback LLM local: {e_local_llm}")
+            traceback.print_exc()
             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)
+    file_obj,
     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,
@@ -122,165 +113,163 @@ def process_and_plot(
     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.")
+    try: # Bloque try-except general para capturar cualquier error y retornar consistentemente
+        analysis_text = "Iniciando análisis..."
+        default_image = Image.new('RGB', (600, 400), color = 'white') # Imagen placeholder
+        
+        if file_obj is None:
+            return default_image, "Error: Por favor, sube un archivo Excel."
+        
+        try:
+            df = pd.read_excel(file_obj.name)
+        except Exception as e:
+            return default_image, 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 default_image, 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
+
+        active_biomass_eqs = int(biomass_eq_count_ui)
+        active_substrate_eqs = int(substrate_eq_count_ui)
+        active_product_eqs = int(product_eq_count_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()
+        
+        fitted_results_for_plot = {'biomass': [], 'substrate': [], 'product': []}
+        results_for_llm_prompt = {'biomass': [], 'substrate': [], 'product': []}
+        biomass_params_for_s_p = None
+
+        for model_type, (eq_list, param_str_list, bound_str_list, exp_data) in all_eq_inputs.items():
+            if not np.any(exp_data) and len(exp_data) > 0: # Check if all data points are zero or NaN
+                print(f"Datos experimentales para {model_type} son todos cero o NaN, saltando ajuste.")
                 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)
+            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
                 
-                # 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 = []
+                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)
+                    
+                    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)
+                    
+                    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
+                    })
+
+                    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)
+                    return default_image, error_msg
+
+        # Generar gráfico
+        fig, axs = plt.subplots(3, 1, figsize=(10, 18), sharex=True)
+        plot_config = {
+            axs[0]: (biomass_data_exp, 'Biomasa', fitted_results_for_plot['biomasa']),
+            axs[1]: (substrate_data_exp, 'Sustrato', fitted_results_for_plot['sustrato']),
+            axs[2]: (product_data_exp, 'Producto', fitted_results_for_plot['producto'])
+        }
+
+        for ax, data_actual, ylabel, plot_results_list in plot_config.items():
+            if np.any(data_actual): # Solo plotear si hay datos
+                ax.plot(time_data, data_actual, 'o', label=f'Datos {ylabel}', markersize=5, alpha=0.7)
+            else:
+                ax.text(0.5, 0.5, f"No hay datos para {ylabel}", transform=ax.transAxes, ha='center', va='center', fontsize=12, color='gray')
+
             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)
+                label = f'Modelo {idx+1} (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')
             
-            # 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:
+            if show_params_ui and plot_results_list:
+                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)
+                
+                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])
+        fig.suptitle("Resultados del Ajuste de Modelos Cinéticos", fontsize=16)
+        
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', dpi=150)
+        buf.seek(0)
+        image = Image.open(buf)
+        plt.close(fig)
+
+        # Construir prompt para LLM y llamar al servicio
+        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:
@@ -294,13 +283,19 @@ def process_and_plot(
 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.
+5.  **Conclusión Final:** Un veredicto general conciso 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)
+        
+        full_prompt = prompt_intro + prompt_details + prompt_instructions
+        
+        analysis_text = call_llm_analysis_service(full_prompt)
+
+        return image, analysis_text
 
-    return image, analysis_text
+    except Exception as general_e:
+        # Captura cualquier excepción no manejada y la muestra en la UI
+        error_trace = traceback.format_exc()
+        error_message_full = f"Error inesperado en process_and_plot: {general_e}\n{error_trace}"
+        print(error_message_full)
+        return Image.new('RGB', (600, 400), color = 'red'), error_message_full # Retorna imagen roja de error