Update interface.py

interface.py

@@ -23,7 +23,6 @@ model = AutoModelForCausalLM.from_pretrained(model_path)
 
 ###############################
 
-
 # bioprocess_model.py
 
 import numpy as np
@@ -33,6 +32,7 @@ from scipy.integrate import odeint
 from scipy.optimize import curve_fit
 from sklearn.metrics import mean_squared_error
 import seaborn as sns
+from sympy import symbols, lambdify, sympify
 
 class BioprocessModel:
     def __init__(self):
@@ -122,27 +122,38 @@ class BioprocessModel:
         params = [param.strip() for param in params_str.split(',')]
         params_symbols = symbols(params)
         
+        # Extraer símbolos utilizados en la expresión
+        used_symbols = expr.free_symbols
+        # Convertir símbolos a strings
+        used_params = [str(s) for s in used_symbols if s != t_symbol]
+        
+        # Verificar que todos los parámetros en params_str estén usados en la ecuación
+        for param in params:
+            if param not in used_params:
+                raise ValueError(f"El parámetro '{param}' no se usa en la ecuación '{equation}'.")
+
         if model_type == 'biomass':
-            # Assuming biomass is a function of time only for logistic
+            # Biomasa como función de tiempo y parámetros
             func_expr = expr
-            func = lambdify(t_symbol, func_expr, 'numpy')
+            func = lambdify((t_symbol, *params_symbols), func_expr, 'numpy')
             self.models['biomass'] = {
                 'function': func,
                 'params': params
             }
         elif model_type in ['substrate', 'product']:
-            # These models depend on biomass, which should already be set
+            # Estos modelos dependen de biomasa, que ya debería estar establecida
             if 'biomass' not in self.models:
-                raise ValueError("Biomass model must be set before substrate or product models.")
+                raise ValueError("Biomasa debe estar configurada antes de Sustrato o Producto.")
             biomass_func = self.models['biomass']['function']
-            func_expr = expr.subs('X(t)', biomass_func(t_symbol))
+            # Reemplazar 'X(t)' por la función de biomasa
+            func_expr = expr.subs('X(t)', biomass_func)
             func = lambdify((t_symbol, *params_symbols), func_expr, 'numpy')
             self.models[model_type] = {
                 'function': func,
                 'params': params
             }
         else:
-            raise ValueError(f"Unsupported model type: {model_type}")
+            raise ValueError(f"Tipo de modelo no soportado: {model_type}")
 
     def fit_model(self, model_type, time, data, bounds=([-np.inf], [np.inf])):
         """
@@ -156,8 +167,7 @@ class BioprocessModel:
         """
         if model_type not in self.models:
             raise ValueError(f"Model type '{model_type}' is not set. Please use set_model first.")
-    
-        # Función generada por lambdify
+
         func = self.models[model_type]['function']
         params = self.models[model_type]['params']
         
@@ -171,18 +181,18 @@ class BioprocessModel:
             except Exception as e:
                 print(f"Error in fit_func: {e}")
                 raise
-    
+
         # Depuración: Verificar el número de parámetros que se espera ajustar
         print(f"Number of parameters to fit: {len(params)}")
-    
+
         try:
             # Verifica que curve_fit puede recibir la función correctamente
             print(f"Calling curve_fit with time: {time}, data: {data}, bounds: {bounds}")
-    
+
             # Intentar ajustar el modelo usando curve_fit
             popt, _ = curve_fit(fit_func, time, data, bounds=bounds, maxfev=10000)
             print(f"Optimal parameters found: {popt}")
-    
+
             # Guardar los parámetros ajustados en el modelo
             self.params[model_type] = {param: val for param, val in zip(params, popt)}
             y_pred = fit_func(time, *popt)
@@ -193,7 +203,6 @@ class BioprocessModel:
             print(f"Error while fitting {model_type} model: {str(e)}")
             raise
 
-
     def plot_combined_results(self, time, biomass, substrate, product,
                               y_pred_biomass, y_pred_substrate, y_pred_product,
                               biomass_std=None, substrate_std=None, product_std=None,
@@ -227,8 +236,6 @@ class BioprocessModel:
         fig.tight_layout()
         return fig
 
-
-
 ###############################
 
 # Decorador GPU aplicado para manejar la ejecución en GPU si está disponible
@@ -268,13 +275,16 @@ def generate_analysis(prompt, max_length=1024, device=None):
 
 def parse_bounds(bounds_str, num_params):
     try:
+        # Reemplazar 'inf' por 'np.inf' si el usuario lo escribió así
+        bounds_str = bounds_str.replace('inf', 'np.inf')
         bounds = eval(f"[{bounds_str}]")
         if len(bounds) != num_params:
-            raise ValueError
+            raise ValueError("Número de límites no coincide con el número de parámetros.")
         lower_bounds = [b[0] for b in bounds]
         upper_bounds = [b[1] for b in bounds]
         return lower_bounds, upper_bounds
-    except:
+    except Exception as e:
+        print(f"Error al parsear los límites: {e}. Usando límites por defecto.")
         lower_bounds = [-np.inf] * num_params
         upper_bounds = [np.inf] * num_params
         return lower_bounds, upper_bounds
@@ -335,32 +345,41 @@ def process_and_plot(
     substrate_results = []
     product_results = []
 
+    # Inicializar el modelo principal
+    main_model = BioprocessModel()
+
     # Ajusta los modelos de Biomasa
     for i in range(len(biomass_eqs)):
         equation = biomass_eqs[i]
         params_str = biomass_params[i]
         bounds_str = biomass_bounds[i]
 
-        model = BioprocessModel()
-        model.set_model('biomass', equation, params_str)
+        try:
+            main_model.set_model('biomass', equation, params_str)
+        except ValueError as ve:
+            raise ValueError(f"Error en la configuración del modelo de biomasa {i+1}: {ve}")
 
         params = [param.strip() for param in params_str.split(',')]
         lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
 
-        y_pred = model.fit_model(
-            'biomass', time, biomass_data,
-            bounds=(lower_bounds, upper_bounds)
-        )
-        biomass_results.append({
-            'model': model,
-            'y_pred': y_pred,
-            'equation': equation
-        })
+        try:
+            y_pred = main_model.fit_model(
+                'biomass', time, biomass_data,
+                bounds=(lower_bounds, upper_bounds)
+            )
+            biomass_results.append({
+                'model': main_model,
+                'y_pred': y_pred,
+                'equation': equation,
+                'params': main_model.params['biomass']
+            })
+        except Exception as e:
+            raise RuntimeError(f"Error al ajustar el modelo de biomasa {i+1}: {e}")
 
     # Usa el primer modelo de biomasa para X(t)
     biomass_model = biomass_results[0]['model']
-    biomass_params_values = list(biomass_model.params['biomass'].values())
     biomass_func = biomass_model.models['biomass']['function']
+    biomass_params_values = list(biomass_model.params['biomass'].values())
 
     # Ajusta los modelos de Sustrato
     for i in range(len(substrate_eqs)):
@@ -368,21 +387,27 @@ def process_and_plot(
         params_str = substrate_params[i]
         bounds_str = substrate_bounds[i]
 
-        model = BioprocessModel()
-        model.set_model('substrate', equation, params_str)
+        try:
+            main_model.set_model('substrate', equation, params_str)
+        except ValueError as ve:
+            raise ValueError(f"Error en la configuración del modelo de sustrato {i+1}: {ve}")
 
-        params = model.models['substrate']['params']
+        params = [param.strip() for param in params_str.split(',')]
         lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
 
-        y_pred = model.fit_model(
-            'substrate', time, substrate_data,
-            bounds=(lower_bounds, upper_bounds)
-        )
-        substrate_results.append({
-            'model': model,
-            'y_pred': y_pred,
-            'equation': equation
-        })
+        try:
+            y_pred = main_model.fit_model(
+                'substrate', time, substrate_data,
+                bounds=(lower_bounds, upper_bounds)
+            )
+            substrate_results.append({
+                'model': main_model,
+                'y_pred': y_pred,
+                'equation': equation,
+                'params': main_model.params['substrate']
+            })
+        except Exception as e:
+            raise RuntimeError(f"Error al ajustar el modelo de sustrato {i+1}: {e}")
 
     # Ajusta los modelos de Producto
     for i in range(len(product_eqs)):
@@ -390,21 +415,27 @@ def process_and_plot(
         params_str = product_params[i]
         bounds_str = product_bounds[i]
 
-        model = BioprocessModel()
-        model.set_model('product', equation, params_str)
+        try:
+            main_model.set_model('product', equation, params_str)
+        except ValueError as ve:
+            raise ValueError(f"Error en la configuración del modelo de producto {i+1}: {ve}")
 
-        params = model.models['product']['params']
+        params = [param.strip() for param in params_str.split(',')]
         lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
 
-        y_pred = model.fit_model(
-            'product', time, product_data,
-            bounds=(lower_bounds, upper_bounds)
-        )
-        product_results.append({
-            'model': model,
-            'y_pred': y_pred,
-            'equation': equation
-        })
+        try:
+            y_pred = main_model.fit_model(
+                'product', time, product_data,
+                bounds=(lower_bounds, upper_bounds)
+            )
+            product_results.append({
+                'model': main_model,
+                'y_pred': y_pred,
+                'equation': equation,
+                'params': main_model.params['product']
+            })
+        except Exception as e:
+            raise RuntimeError(f"Error al ajustar el modelo de producto {i+1}: {e}")
 
     # Genera las gráficas
     fig, axs = plt.subplots(3, 1, figsize=(10, 15))
@@ -458,4 +489,4 @@ Producto:
 """
     analysis = generate_analysis(prompt, device=device)
 
-    return [image], analysis
+    return image, analysis