Update bioprocess_model.py

bioprocess_model.py

@@ -1,11 +1,8 @@
 # bioprocess_model.py
 
 import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
 from scipy.optimize import curve_fit
 from sklearn.metrics import mean_squared_error
-from sympy import symbols, lambdify, sympify, Function
 
 class BioprocessModel:
     def __init__(self):
@@ -18,107 +15,104 @@ class BioprocessModel:
     def logistic(time, xo, xm, um):
         return (xo * np.exp(um * time)) / (1 - (xo / xm) * (1 - np.exp(um * time)))
 
-    @staticmethod
-    def substrate(time, so, p, q, xo, xm, um):
-        return so - (p * xo * ((np.exp(um * time)) / (1 - (xo / xm) * (1 - np.exp(um * time))) - 1)) - \
-               (q * (xm / um) * np.log(1 - (xo / xm) * (1 - np.exp(um * time))))
-
-    @staticmethod
-    def product(time, po, alpha, beta, xo, xm, um):
-        return po + (alpha * xo * ((np.exp(um * time) / (1 - (xo / xm) * (1 - np.exp(um * time))) - 1))) + \
-               (beta * (xm / um) * np.log(1 - (xo / xm) * (1 - np.exp(um * time))))
-
-    def set_model(self, model_type, equation, params_str):
+    def set_model_biomass(self, equation, params_str):
         """
-        Configures the model based on the type, equation, and parameters.
-
-        :param model_type: Type of the model ('biomass', 'substrate', 'product')
-        :param equation: The equation as a string
-        :param params_str: Comma-separated string of parameter names
+        Configura el modelo de Biomasa.
+        
+        :param equation: La ecuación de Biomasa como cadena de texto
+        :param params_str: Cadena de parámetros separados por comas
         """
-        t_symbol = symbols('t')
-        X = Function('X')  # Definir 'X(t)' como una función simbólica
-
         try:
-            expr = sympify(equation)
+            # Define la función de Biomasa directamente
+            def biomass_func(t, xo, xm, um):
+                return (xo * np.exp(um * t)) / (1 - (xo / xm) * (1 - np.exp(um * t)))
+            
+            self.models['biomass'] = {
+                'function': biomass_func,
+                'params': [param.strip() for param in params_str.split(',')]
+            }
         except Exception as e:
-            raise ValueError(f"Error al parsear la ecuación '{equation}': {e}")
-
-        params = [param.strip() for param in params_str.split(',')]
-        params_symbols = symbols(params)
+            raise ValueError(f"Error al configurar el modelo de biomasa: {e}")
 
-        # 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':
-            # Biomasa como función de tiempo y parámetros
-            func_expr = expr
-            func = lambdify((t_symbol, *params_symbols), func_expr, 'numpy')
-            self.models['biomass'] = {
-                'function': func,
-                'params': params
+    def set_model_substrate(self, equation, params_str):
+        """
+        Configura el modelo de Sustrato.
+        
+        :param equation: La ecuación de Sustrato como cadena de texto (no usada en este enfoque)
+        :param params_str: Cadena de parámetros separados por comas
+        """
+        try:
+            # Define la función de Sustrato que depende de Biomasa
+            def substrate_func(t, so, p, q, xo, xm, um):
+                X_t = self.models['biomass']['function'](t, xo, xm, um)
+                return so - p * X_t - q * np.log(1 - (xo / xm) * (1 - np.exp(um * t)))
+            
+            self.models['substrate'] = {
+                'function': substrate_func,
+                'params': [param.strip() for param in params_str.split(',')]
             }
-        elif model_type in ['substrate', 'product']:
-            # Estos modelos dependen de biomasa, que ya debería estar establecida
-            if 'biomass' not in self.models:
-                raise ValueError("Biomasa debe estar configurada antes de Sustrato o Producto.")
-            biomass_func = self.models['biomass']['function']
-            # 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
+        except Exception as e:
+            raise ValueError(f"Error al configurar el modelo de sustrato: {e}")
+
+    def set_model_product(self, equation, params_str):
+        """
+        Configura el modelo de Producto.
+        
+        :param equation: La ecuación de Producto como cadena de texto (no usada en este enfoque)
+        :param params_str: Cadena de parámetros separados por comas
+        """
+        try:
+            # Define la función de Producto que depende de Biomasa
+            def product_func(t, po, alpha, beta, xo, xm, um):
+                X_t = self.models['biomass']['function'](t, xo, xm, um)
+                return po + alpha * X_t + beta * np.log(1 - (xo / xm) * (1 - np.exp(um * t)))
+            
+            self.models['product'] = {
+                'function': product_func,
+                'params': [param.strip() for param in params_str.split(',')]
             }
-        else:
-            raise ValueError(f"Tipo de modelo no soportado: {model_type}")
+        except Exception as e:
+            raise ValueError(f"Error al configurar el modelo de producto: {e}")
 
     def fit_model(self, model_type, time, data, bounds=([-np.inf], [np.inf])):
         """
-        Fits the model to the data.
-
-        :param model_type: Type of the model ('biomass', 'substrate', 'product')
-        :param time: Time data
-        :param data: Observed data to fit
-        :param bounds: Bounds for the parameters
-        :return: Predicted data from the model
+        Ajusta el modelo a los datos.
+        
+        :param model_type: Tipo de modelo ('biomass', 'substrate', 'product')
+        :param time: Datos de tiempo
+        :param data: Datos observados para ajustar
+        :param bounds: Límites para los parámetros
+        :return: Datos predichos por el modelo
         """
         if model_type not in self.models:
-            raise ValueError(f"Model type '{model_type}' is not set. Please use set_model first.")
+            raise ValueError(f"Tipo de modelo '{model_type}' no está configurado. Usa set_model primero.")
 
         func = self.models[model_type]['function']
         params = self.models[model_type]['params']
 
-        # Definir la función de ajuste
+        # Definir la función de ajuste para curve_fit
         def fit_func(t, *args):
             try:
-                y = func(t, *args)
-                return y
+                # Para Sustrato y Producto, se necesitan los parámetros de Biomasa
+                if model_type in ['substrate', 'product']:
+                    # Extraer los parámetros de Biomasa
+                    xo, xm, um = self.params['biomass']['xo'], self.params['biomass']['xm'], self.params['biomass']['um']
+                    return func(t, *args, xo, xm, um)
+                else:
+                    return func(t, *args)
             except Exception as e:
                 raise RuntimeError(f"Error en fit_func: {e}")
 
-        # Definir una estimación inicial para los parámetros
+        # Estimación inicial de los parámetros
         p0 = [1.0] * len(params)  # Puedes ajustar estos valores según sea necesario
 
         try:
-            # Definir los límites correctamente
-            lower_bounds, upper_bounds = bounds
-
-            # Ajustar el modelo usando curve_fit con p0
-            popt, _ = curve_fit(fit_func, time, data, p0=p0, bounds=(lower_bounds, upper_bounds), maxfev=10000)
-
-            # Guardar los parámetros ajustados en el modelo
+            popt, _ = curve_fit(fit_func, time, data, p0=p0, bounds=bounds, maxfev=10000)
+            # Guardar los parámetros ajustados
             self.params[model_type] = {param: val for param, val in zip(params, popt)}
             y_pred = fit_func(time, *popt)
             self.r2[model_type] = 1 - (np.sum((data - y_pred) ** 2) / np.sum((data - np.mean(data)) ** 2))
             self.rmse[model_type] = np.sqrt(mean_squared_error(data, y_pred))
             return y_pred
         except Exception as e:
-            raise RuntimeError(f"Error while fitting {model_type} model: {str(e)}")
+            raise RuntimeError(f"Error al ajustar el modelo '{model_type}': {e}")