Upload 2 files

interface.py

@@ -2,36 +2,30 @@
 import numpy as np
 import pandas as pd
 import matplotlib
-matplotlib.use('Agg') # Backend no interactivo
+matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 from PIL import Image
 import io
 import json
-import traceback # Para traceback detallado
+import traceback
 
-# Importar BioprocessModel de TU models.py (el que usa sympy)
-from models import BioprocessModel
-# from decorators import gpu_decorator # No es necesario con Modal
+from models import BioprocessModel # De TU models.py
+# from decorators import gpu_decorator # No relevante para Modal
 
-# Variables globales que serán "inyectadas"
 USE_MODAL_FOR_LLM_ANALYSIS = False
 generate_analysis_from_modal = None 
 
-def create_error_image(message="Error", width=600, height=400):
-    """Crea una imagen PIL simple para mostrar mensajes de error."""
-    img = Image.new('RGB', (width, height), color = (255, 200, 200)) # Fondo rojo claro
-    # No podemos dibujar texto fácilmente sin Pillow-SIMD o dependencias de dibujo complejas.
-    # Una imagen simple es suficiente para indicar un error.
-    # from PIL import ImageDraw
-    # d = ImageDraw.Draw(img)
-    # d.text((10,10), message, fill=(0,0,0)) # Esto requeriría una fuente
+def create_error_image(message="Error en procesamiento", width=600, height=400):
+    # ... (sin cambios) ...
+    img = Image.new('RGB', (width, height), color = (255, 200, 200))
     print(f"Generando imagen de error: {message}")
     return img
 
 def parse_bounds_str(bounds_str_input, num_params):
+    # ... (sin cambios, pero asegúrate que es la versión robusta de respuestas anteriores) ...
     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).")
+        print(f"DEBUG (parse_bounds_str): Cadena de límites vacía para {num_params} params. Usando (-inf, inf).")
         return [-np.inf] * num_params, [np.inf] * num_params
     try:
         bounds_str = bounds_str.lower().replace('inf', 'np.inf').replace('none', 'None')
@@ -51,53 +45,37 @@ def parse_bounds_str(bounds_str_input, num_params):
             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)
+        print(f"DEBUG (parse_bounds_str): Límites parseados: L={lower_bounds}, U={upper_bounds}")
         return lower_bounds, upper_bounds
     except Exception as e:
-        print(f"Error al parsear límites '{bounds_str_input}': {e}. Usando por defecto (-inf, inf).")
+        print(f"ERROR (parse_bounds_str): Parseando '{bounds_str_input}': {e}. Usando 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)."""
-    # ... (sin cambios respecto a la versión anterior completa)
+    # ... (sin cambios) ...
     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:
-            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() 
-            return f"Error al contactar el servicio de análisis IA (Modal): {e_modal_call}"
+        print("DEBUG (interface.py): Llamando a Modal LLM...")
+        try: return generate_analysis_from_modal(prompt)
+        except Exception as e: print(f"ERROR (interface.py): Modal LLM: {e}"); traceback.print_exc(); return f"Error servicio IA: {e}"
     else:
-        print("interface.py: Usando la función de análisis LLM local (fallback)...")
-        # Implementación de fallback local (como en la respuesta anterior)
+        print("DEBUG (interface.py): Usando LLM local (fallback)...")
         try:
             from config import MODEL_PATH, MAX_LENGTH, DEVICE 
             from transformers import AutoTokenizer, AutoModelForCausalLM 
-            import torch # Asegurar importación de torch para fallback
-            
-            print(f"Fallback: Cargando modelo {MODEL_PATH} localmente en {DEVICE}...")
+            import torch
             tokenizer_local = AutoTokenizer.from_pretrained(MODEL_PATH)
             model_local = AutoModelForCausalLM.from_pretrained(MODEL_PATH).to(DEVICE)
-            
             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,
-                    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
-                )
+                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}")
-            traceback.print_exc()
-            return f"Análisis (fallback local): Error al cargar/ejecutar modelo LLM local: {e_local_llm}."
+        except Exception as e: print(f"ERROR (interface.py): Fallback LLM: {e}"); traceback.print_exc(); return f"Error LLM local: {e}."
 
 
 def process_and_plot(
@@ -118,136 +96,165 @@ def process_and_plot(
     substrate_eq_count_ui,
     product_eq_count_ui
 ):
-    # Imagen y texto de error por defecto
-    error_img = create_error_image("Error en procesamiento")
-    error_analysis_text = "No se pudo generar el análisis debido a un error."
+    print("\nDEBUG (interface.py): process_and_plot INICIADO.")
+    error_img = create_error_image("Error inicial en procesamiento")
+    error_analysis_text = "No se pudo generar el análisis debido a un error de inicialización."
 
     try:
         if file_obj is None:
+            print("ERROR (interface.py): No se subió archivo.")
             return error_img, "Error: Por favor, sube un archivo Excel."
+        print(f"DEBUG (interface.py): Archivo recibido: {file_obj.name}")
         
         try:
             df = pd.read_excel(file_obj.name)
+            print(f"DEBUG (interface.py): Excel leído. Columnas: {df.columns.tolist()}")
         except Exception as e:
             return error_img, 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 error_img, f"Error: La columna '{col}' no se encuentra en el archivo Excel."
+        missing_cols = [col for col in expected_cols if col not in df.columns]
+        if missing_cols:
+            return error_img, f"Error: Faltan columnas en Excel: {', '.join(missing_cols)}."
 
         time_data = df['Tiempo'].values
         biomass_data_exp = df['Biomasa'].values
         substrate_data_exp = df['Sustrato'].values
         product_data_exp = df['Producto'].values
+        print(f"DEBUG (interface.py): Datos extraídos. Longitud de tiempo: {len(time_data)}")
 
-        # Asegurar que los contadores sean enteros válidos
         try:
             active_biomass_eqs = int(float(biomass_eq_count_ui))
             active_substrate_eqs = int(float(substrate_eq_count_ui))
             active_product_eqs = int(float(product_eq_count_ui))
-        except (TypeError, ValueError):
-             return error_img, "Error: Número de ecuaciones inválido."
-
-
-        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
-            )
+        except (TypeError, ValueError) as e_count:
+             return error_img, f"Error: Número de ecuaciones inválido: {e_count}"
+        print(f"DEBUG (interface.py): Counts: Bio={active_biomass_eqs}, Sub={active_substrate_eqs}, Prod={active_product_eqs}")
+
+        all_eq_inputs = { # ... (sin cambios) ...
+            '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
+        biomass_params_for_s_p_dict = None # Debe ser un dict para models.py
 
         for model_type, (eq_list, param_str_list, bound_str_list, exp_data) in all_eq_inputs.items():
             if not (isinstance(exp_data, np.ndarray) and exp_data.size > 0 and np.any(np.isfinite(exp_data))):
-                print(f"Datos experimentales para {model_type} no válidos o vacíos, saltando ajuste.")
+                print(f"INFO (interface.py): Datos experimentales para {model_type} no válidos o vacíos, saltando ajuste.")
+                results_for_llm_prompt[model_type].append({'equation': 'N/A - Sin datos válidos', 'params_fitted': {}, 'R2': np.nan, 'RMSE': np.nan})
                 continue
 
             for i in range(len(eq_list)):
                 eq_str, param_s, bound_s = eq_list[i], param_str_list[i], bound_str_list[i]
-                if not eq_str or not param_s: continue
+                if not eq_str or not param_s:
+                    print(f"INFO (interface.py): Ecuación o parámetros vacíos para {model_type} #{i+1}, saltando.")
+                    results_for_llm_prompt[model_type].append({'equation': eq_str if eq_str else 'Ecuación Vacía', 'params_fitted': {}, 'R2': np.nan, 'RMSE': np.nan, 'error': 'Ecuación o parámetros vacíos'})
+                    continue
+                
+                print(f"\nDEBUG (interface.py): 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_p = 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_p)
+                    # Pasar biomass_params_fitted si es sustrato o producto
+                    current_biomass_params_for_fit = biomass_params_for_s_p_dict if model_type in ['substrate', 'product'] else None
                     
-                    current_params = model_handler.params.get(model_type, {}) # Obtener params del handler
+                    print(f"DEBUG (interface.py): Llamando a fit_model para {model_type} #{i+1}")
+                    y_pred, popt_values = model_handler.fit_model(model_type, time_data, exp_data, bounds=(l_b, u_b), biomass_params_fitted=current_biomass_params_for_fit)
+                    print(f"DEBUG (interface.py): fit_model regresó para {model_type} #{i+1}. y_pred (primeros 5): {y_pred[:5] if y_pred is not None else 'None'}")
+
+                    if y_pred is None or popt_values is None: # Chequear si fit_model indicó fallo
+                        print(f"ERROR (interface.py): Ajuste falló (y_pred o popt es None) para {model_type} #{i+1}.")
+                        results_for_llm_prompt[model_type].append({'equation': eq_str, 'params_fitted': {}, 'R2': np.nan, 'RMSE': np.nan, 'error': 'Fallo en curve_fit'})
+                        continue # Saltar al siguiente modelo/ecuación
+
+                    current_params = model_handler.params.get(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 and current_params:
-                        biomass_params_for_s_p = current_params
-                except Exception as e_fit:
-                    error_msg = f"Error ajustando {model_type} #{i+1} ('{eq_str}'): {e_fit}\n{traceback.format_exc()}"
-                    print(error_msg); return error_img, error_msg
+                    if model_type == 'biomass' and biomass_params_for_s_p_dict is None and current_params:
+                        biomass_params_for_s_p_dict = current_params # Guardar como dict
+                        print(f"DEBUG (interface.py): Parámetros de Biomasa (para S/P) guardados: {biomass_params_for_s_p_dict}")
+
+                except Exception as e_fit_loop:
+                    error_msg = f"Error en bucle de ajuste para {model_type} #{i+1} ('{eq_str}'): {e_fit_loop}\n{traceback.format_exc()}"
+                    print(error_msg)
+                    results_for_llm_prompt[model_type].append({'equation': eq_str, 'params_fitted': {}, 'R2': np.nan, 'RMSE': np.nan, 'error': str(e_fit_loop)})
+                    # Considerar si continuar con otros modelos o retornar error general
+                    # Por ahora, continuamos para intentar ajustar otros modelos si es posible
 
         # Generar gráfico
+        print("DEBUG (interface.py): Generando gráfico...")
         fig, axs = plt.subplots(3, 1, figsize=(10, 18), sharex=True)
-        plot_config_map = {
-            axs[0]: (biomass_data_exp, 'Biomasa', fitted_results_for_plot['biomass']),
-            axs[1]: (substrate_data_exp, 'Sustrato', fitted_results_for_plot['sustrato']),
-            axs[2]: (product_data_exp, 'Producto', fitted_results_for_plot['producto'])
-        }
-
+        # ... (resto de la lógica de graficación, como en tu versión completa, sin cambios significativos) ...
+        plot_config_map = {axs[0]:(biomass_data_exp,'Biomasa',fitted_results_for_plot['biomass']), axs[1]:(substrate_data_exp,'Sustrato',fitted_results_for_plot['sustrato']), axs[2]:(product_data_exp,'Producto',fitted_results_for_plot['product'])}
+        any_plot_successful = False
         for ax, data_actual, ylabel, plot_results in plot_config_map.items():
             if isinstance(data_actual, np.ndarray) and data_actual.size > 0 and np.any(np.isfinite(data_actual)):
                 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')
-
+            else: ax.text(0.5,0.5,f"No hay datos para {ylabel}",transform=ax.transAxes,ha='center',va='center')
             for idx, res_detail in enumerate(plot_results):
-                label = f'Modelo {idx+1} (R²:{res_detail.get("R2", float("nan")):.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 res_detail.get('y_pred') is not None and np.any(np.isfinite(res_detail['y_pred'])): # Solo plotear si y_pred es válido
+                    label = f'Modelo {idx+1} (R²:{res_detail.get("R2", float("nan")):.3f})'
+                    ax.plot(time_data, res_detail['y_pred'], '-', label=label, linewidth=2)
+                    any_plot_successful = True
+            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:
-                param_display_texts = [f"Modelo {idx+1}:\n" + "\n".join([f"  {k}: {v:.4g}" for k,v in res_detail.get('params',{}).items()]) for idx, res_detail in enumerate(plot_results)]
-                ax.text(0.02, 0.98 if not ('upper' in legend_position_ui) else 0.02, "\n---\n".join(param_display_texts), 
-                        transform=ax.transAxes, fontsize=7, verticalalignment='top' if not ('upper' in legend_position_ui) else 'bottom', 
-                        bbox=dict(boxstyle='round,pad=0.3', fc='lightyellow', alpha=0.8))
+                param_display_texts = [f"Modelo {idx+1}:\n" + "\n".join([f"  {k}: {v:.4g}" for k,v in res_d.get('params',{}).items()]) for idx, res_d in enumerate(plot_results) if res_d.get('params')]
+                if param_display_texts: ax.text(0.02,0.98 if not ('upper' in legend_position_ui) else 0.02,"\n---\n".join(param_display_texts),transform=ax.transAxes,fontsize=7,verticalalignment='top' if not ('upper' in legend_position_ui) else 'bottom',bbox=dict(boxstyle='round,pad=0.3',fc='lightyellow',alpha=0.8))
+        
+        if not any_plot_successful: # Si ningún modelo se ajustó o y_pred fue NaN
+            print("WARN (interface.py): Ningún modelo produjo un gráfico válido.")
+            # Podrías dibujar algo en la figura para indicar esto
+            axs[0].text(0.5, 0.5, "Ningún modelo se pudo ajustar o graficar.", transform=axs[0].transAxes, ha='center', va='center', fontsize=12, color='red')
+
 
-        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)
+        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_pil = Image.open(buf); plt.close(fig)
+        print("DEBUG (interface.py): Gráfico generado.")
 
         # Construir prompt y llamar a LLM
-        prompt_intro = "Eres un experto en modelado cinético de bioprocesos...\n\n" # (como antes)
+        # ... (sin cambios en la lógica del prompt) ...
+        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...\n" # (como antes)
+        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.
+        iv. Errores: Si hubo un error durante el ajuste para esta ecuación específica, menciónalo.
+    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 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
+        print("DEBUG (interface.py): Prompt para LLM generado. Llamando al servicio LLM...")
         analysis_text_llm = call_llm_analysis_service(full_prompt)
+        print("DEBUG (interface.py): Análisis LLM recibido.")
 
         return image_pil, analysis_text_llm
 
     except Exception as general_e:
         error_trace = traceback.format_exc()
-        error_message_full = f"Error inesperado en process_and_plot: {general_e}\n{error_trace}"
+        error_message_full = f"Error GENERAL INESPERADO en process_and_plot: {general_e}\n{error_trace}"
         print(error_message_full)
-        return create_error_image(f"Error: {general_e}"), error_message_full
+        return create_error_image(f"Error General: {general_e}"), error_message_full

models.py

@@ -3,193 +3,236 @@ 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
+from sklearn.metrics import mean_squared_error
 
 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
+        self.params = {}
+        self.models = {}
+        self.r2 = {}
+        self.rmse = {}
+        print("DEBUG (models.py): BioprocessModel instanciado.")
 
     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()
+        print(f"\nDEBUG (models.py): set_model llamado para tipo='{model_type}'")
+        print(f"  Equation str (raw): '{equation_str}'")
+        print(f"  Param str (raw): '{param_str}'")
 
-        params_list = [param.strip() for param in param_str.split(',')]
+        equation_str_cleaned = str(equation_str).strip()
+        if '=' in equation_str_cleaned:
+            equation_str_cleaned = equation_str_cleaned.split('=', 1)[1].strip()
         
+        if not equation_str_cleaned:
+            print(f"ERROR (models.py): Ecuación vacía para {model_type}.")
+            raise ValueError(f"La cadena de la ecuación para '{model_type}' no puede estar vacía.")
+        if not param_str:
+            print(f"ERROR (models.py): Cadena de parámetros vacía para {model_type}.")
+            raise ValueError(f"La cadena de parámetros para '{model_type}' no puede estar vacía.")
+
+        params_list = [param.strip() for param in param_str.split(',')]
+        if not all(params_list): # Chequear si algún nombre de parámetro es vacío
+            print(f"ERROR (models.py): Algún nombre de parámetro está vacío en '{param_str}' para {model_type}.")
+            raise ValueError(f"Los nombres de los parámetros no pueden ser vacíos para '{model_type}'.")
+
+        print(f"  Equation (cleaned): '{equation_str_cleaned}'")
+        print(f"  Params list: {params_list}")
+
         self.models[model_type] = {
-            'equation_str': equation_str,
+            'equation_str': equation_str_cleaned,
             '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
+        try:
+            # Símbolos para el tiempo y los parámetros del modelo actual
+            t_sym = symbols('t')
+            # Asegurar que los parámetros sean símbolos válidos
+            current_param_syms = []
+            for p_name in params_list:
+                if not p_name.isidentifier(): # Chequeo básico de validez del nombre del símbolo
+                    raise ValueError(f"Nombre de parámetro '{p_name}' no es un identificador Python válido para sympy.")
+                current_param_syms.append(symbols(p_name))
+            
+            # Símbolo para X(t) si es necesario (solo para modelos S y P)
+            X_val_sym = symbols('X_val')
+
+            # Crear la expresión simbólica
+            sympy_expr = sympify(equation_str_cleaned)
+            print(f"  Sympy expression: {sympy_expr}")
+            print(f"  Free symbols in expr: {sympy_expr.free_symbols}")
+
+            # Guardar la expresión y los símbolos para uso en fit_model
+            self.models[model_type]['sympy_expr'] = sympy_expr
+            self.models[model_type]['param_symbols'] = tuple(current_param_syms) # Usar tupla
+            self.models[model_type]['time_symbol'] = t_sym
+            self.models[model_type]['X_val_symbol'] = X_val_sym # Guardar por si se usa
+            print(f"  Modelo '{model_type}' configurado exitosamente.")
+
+        except Exception as e:
+            print(f"ERROR (models.py): Fallo al procesar con sympy para '{model_type}': {e}")
+            raise ValueError(f"Error en la ecuación o parámetros para '{model_type}': {e}")
+
 
     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
-        """
+        print(f"\nDEBUG (models.py): fit_model llamado para tipo='{model_type}'")
         if model_type not in self.models:
+            print(f"ERROR (models.py): Modelo para '{model_type}' no configurado.")
             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']
+        current_param_names = model_config['params'] # Lista de strings
+        current_param_syms = model_config['param_symbols'] # Tupla de símbolos sympy
         t_sym = model_config['time_symbol']
+        X_val_sym = model_config['X_val_symbol']
+
+        print(f"  Ajustando con ecuación: {equation_expr}")
+        print(f"  Parámetros a ajustar: {current_param_names}")
+        print(f"  Datos de tiempo (primeros 5): {time[:5]}")
+        print(f"  Datos experimentales (primeros 5): {data[:5]}")
+        print(f"  Límites: {bounds}")
+        if biomass_params_fitted:
+            print(f"  Parámetros de biomasa ajustados (para S/P): {biomass_params_fitted}")
 
-        # 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)}
+        # Función que será pasada a curve_fit
+        def fit_model_wrapper(t_data_wrapper, *current_p_values_wrapper):
+            # `t_data_wrapper` es un array numpy de tiempos.
+            # `current_p_values_wrapper` es una tupla de los valores actuales de los parámetros.
             
-            # Si es sustrato o producto y depende de la biomasa (X_val)
-            X_val_sym = symbols('X_val') # Símbolo para X(t)
+            # Diccionario de sustitución para los parámetros del modelo actual
+            subs_dict_wrapper = {sym: val for sym, val in zip(current_param_syms, current_p_values_wrapper)}
+            
+            # Preparar la expresión para lambdify: solo con `t` y los parámetros del modelo actual
+            lambdify_args_wrapper = [t_sym] + list(current_param_syms)
+            expr_to_lambdify = equation_expr
+
+            # Manejar dependencia de X_val para sustrato y producto
             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).")
+                if biomass_params_fitted is None or 'biomass' not in self.models or 'sympy_expr' not in self.models['biomass']:
+                    print("ERROR (models.py fit_model_wrapper): Falta config/params de biomasa para modelo S/P dependiente.")
+                    # Devolver algo que cause error en curve_fit o un array de NaNs de tamaño correcto
+                    return np.full_like(t_data_wrapper, np.nan) 
                 
-                # 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']
+                biomass_t_sym = biomass_model_config['time_symbol']
                 
-                # 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'])}
+                biomass_subs_for_calc = {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).
+                # Calcular X(t) para cada tiempo en t_data_wrapper
+                # Esto DEBE resultar en un array numpy
+                try:
+                    # Lambdify la expresión de biomasa una vez si es posible
+                    if 'biomass_func_lambdified' not in biomass_model_config:
+                         biomass_model_config['biomass_func_lambdified'] = lambdify(
+                             [biomass_t_sym] + list(biomass_p_syms), 
+                             biomass_expr, 
+                             'numpy'
+                         )
+                    # Obtener los valores de los parámetros de biomasa en el orden correcto
+                    biomass_p_values_for_calc = [biomass_params_fitted[p_name] for p_name in biomass_model_config['params']]
+                    X_t_values_wrapper = biomass_model_config['biomass_func_lambdified'](t_data_wrapper, *biomass_p_values_for_calc)
+
+                except Exception as e_biomass_calc:
+                    print(f"ERROR (models.py fit_model_wrapper): Calculando X(t) para S/P: {e_biomass_calc}")
+                    return np.full_like(t_data_wrapper, np.nan)
+
+                # Ahora, X_val_sym necesita ser reemplazado por X_t_values_wrapper en expr_to_lambdify
+                # Esto es complicado porque X_t_values_wrapper es un array, no un escalar simbólico.
+                # La forma más segura es sustituirlo en la expresión antes de lambdify, si sympy lo permite,
+                # o pasarlo como un argumento extra a una función lambdify que lo espere.
                 #
-                # 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`.
+                # Alternativa: si lambdify no maneja bien un array como X_val, evaluar punto por punto.
+                # Por ahora, intentaremos pasar X_val como un argumento adicional a lambdify.
+                if X_val_sym not in current_param_syms: # Asegurar que no es ya un parámetro del modelo S/P
+                    lambdify_args_wrapper.append(X_val_sym)
                 
-                # 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
+                # Crear la función compilada para el modelo actual (S o P)
+                # Esta función ahora tomará t, params_actuales..., y X_val_array
+                func_compiled = lambdify(lambdify_args_wrapper, expr_to_lambdify, 'numpy')
                 
-                # 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
+                # Llamar a la función compilada
+                try:
+                    # Pasar X_t_values_wrapper como el último argumento si X_val_sym fue añadido
+                    call_args = [t_data_wrapper] + list(current_p_values_wrapper)
+                    if X_val_sym in lambdify_args_wrapper[-1:]: # Si X_val_sym es el último argumento esperado
+                        call_args.append(X_t_values_wrapper)
+                    return func_compiled(*call_args)
+                except Exception as e_sp_eval:
+                    print(f"ERROR (models.py fit_model_wrapper): Evaluando S/P con X_val: {e_sp_eval}")
+                    return np.full_like(t_data_wrapper, np.nan)
 
-        # Asegurar que los límites tengan la longitud correcta
+            else: # Es el modelo de biomasa o un modelo S/P que no usa X_val
+                func_compiled = lambdify(lambdify_args_wrapper, expr_to_lambdify, 'numpy')
+                try:
+                    return func_compiled(t_data_wrapper, *current_p_values_wrapper)
+                except Exception as e_bio_eval:
+                    print(f"ERROR (models.py fit_model_wrapper): Evaluando biomasa: {e_bio_eval}")
+                    return np.full_like(t_data_wrapper, np.nan)
+
+
+        p0 = np.ones(len(current_param_names)) 
+        lower_bounds, upper_bounds = bounds
         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)
+        print(f"  Estimaciones iniciales p0: {p0}")
+        print(f"  Límites para curve_fit: L={lower_bounds}, U={upper_bounds}")
+
+        popt, pcov = None, None # Inicializar
         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)
+            warnings.simplefilter("ignore", UserWarning) 
+            try:
+                popt, pcov = curve_fit(fit_model_wrapper, time, data, p0=p0, bounds=(lower_bounds, upper_bounds), maxfev=50000, method='trf') # 'trf' es bueno con límites
+                print(f"  curve_fit completado. Parámetros optimizados (popt): {popt}")
+            except RuntimeError as e_curvefit: # A menudo "Optimal parameters not found"
+                print(f"ERROR (models.py): curve_fit falló para {model_type} con RuntimeError: {e_curvefit}")
+                self.params[model_type] = {p: np.nan for p in current_param_names}
+                self.r2[model_type] = np.nan
+                self.rmse[model_type] = np.nan
+                return np.full_like(data, np.nan), None # Devolver NaNs y None para popt
+            except ValueError as e_val_curvefit: # A menudo por límites o datos incompatibles
+                print(f"ERROR (models.py): curve_fit falló para {model_type} con ValueError: {e_val_curvefit}")
+                self.params[model_type] = {p: np.nan for p in current_param_names}
+                self.r2[model_type] = np.nan
+                self.rmse[model_type] = np.nan
+                return np.full_like(data, np.nan), None
+            except Exception as e_gen_curvefit: # Cualquier otro error
+                print(f"ERROR (models.py): curve_fit falló inesperadamente para {model_type}: {e_gen_curvefit}")
+                self.params[model_type] = {p: np.nan for p in current_param_names}
+                self.r2[model_type] = np.nan
+                self.rmse[model_type] = np.nan
+                return np.full_like(data, np.nan), None
+
+
+        if popt is None: # Si curve_fit falló y ya manejamos el error
+            return np.full_like(data, np.nan), None
 
         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))
+        # Re-calcular y_pred con los parámetros optimizados
+        try:
+            y_pred = fit_model_wrapper(time, *popt)
+            if np.any(np.isnan(y_pred)): # Si la evaluación con popt da NaN
+                 print(f"ADVERTENCIA (models.py): y_pred contiene NaNs después del ajuste para {model_type}.")
+                 self.r2[model_type] = np.nan
+                 self.rmse[model_type] = np.nan
+                 # No sobrescribir self.params[model_type] aquí si popt fue encontrado
+            else:
+                ss_res = np.sum((data - y_pred) ** 2)
+                ss_tot = np.sum((data - np.mean(data)) ** 2)
+                if ss_tot == 0: 
+                    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))
+        except Exception as e_ypred:
+            print(f"ERROR (models.py): Calculando y_pred final para {model_type}: {e_ypred}")
+            y_pred = np.full_like(data, np.nan) # Devolver NaNs si la predicción final falla
+            self.r2[model_type] = np.nan
+            self.rmse[model_type] = np.nan
+
 
-        return y_pred, popt # Devolver y_pred y los parámetros optimizados
+        print(f"  Ajuste para {model_type} completado. R2: {self.r2.get(model_type)}, RMSE: {self.rmse.get(model_type)}")
+        return y_pred, popt