Update app.py

app.py

@@ -1,229 +1,675 @@
-# interface.py
+# -*- coding: utf-8 -*-
+"""PrediLectia - Gradio Final v2 with Multiple Y-Axes in Combined Plot.ipynb"""
+
+# Instalación de librerías necesarias
+#!pip install gradio seaborn scipy -q
+import os
+os.system('pip install gradio seaborn scipy scikit-learn openpyxl pydantic==1.10.0')
+
+from pydantic import BaseModel, ConfigDict
+
+class YourModel(BaseModel):
+    class Config:
+        arbitrary_types_allowed = True
 
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
-from PIL import Image
+import seaborn as sns
+from scipy.integrate import odeint
+from scipy.interpolate import interp1d
+from scipy.optimize import curve_fit
+from sklearn.metrics import mean_squared_error
+import gradio as gr
 import io
+from PIL import Image
+
+# Definición de la clase BioprocessModel
+class BioprocessModel:
+    def __init__(self):
+        self.params = {}
+        self.r2 = {}
+        self.rmse = {}
+        self.datax = []
+        self.datas = []
+        self.datap = []
+        self.dataxp = []
+        self.datasp = []
+        self.datapp = []
+        self.datax_std = []
+        self.datas_std = []
+        self.datap_std = []
+
+    # Funciones modelo analíticas
+    @staticmethod
+    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))))
+
+    # Funciones modelo diferenciales
+    @staticmethod
+    def logistic_diff(X, t, params):
+        xo, xm, um = params
+        dXdt = um * X * (1 - X / xm)
+        return dXdt
+
+    def substrate_diff(self, S, t, params, biomass_params, X_func):
+        so, p, q = params
+        xo, xm, um = biomass_params
+        X_t = X_func(t)
+        dSdt = -p * (um * X_t * (1 - X_t / xm)) - q * X_t
+        return dSdt
+
+    def product_diff(self, P, t, params, biomass_params, X_func):
+        po, alpha, beta = params
+        xo, xm, um = biomass_params
+        X_t = X_func(t)
+        dPdt = alpha * (um * X_t * (1 - X_t / xm)) + beta * X_t
+        return dPdt
+
+    # Métodos de procesamiento y ajuste de datos
+    def process_data(self, df):
+        # Obtener todas las columnas que contengan "Biomasa", "Sustrato", y "Producto"
+        biomass_cols = [col for col in df.columns if col[1] == 'Biomasa']
+        substrate_cols = [col for col in df.columns if col[1] == 'Sustrato']
+        product_cols = [col for col in df.columns if col[1] == 'Producto']
+
+        # Procesar los datos de tiempo
+        time_col = [col for col in df.columns if col[1] == 'Tiempo'][0]
+        time = df[time_col].values
+
+        # Procesar los datos de biomasa
+        data_biomass = [df[col].values for col in biomass_cols]
+        data_biomass = np.array(data_biomass)  # shape (num_experiments, num_time_points)
+        self.datax.append(data_biomass)
+        self.dataxp.append(np.mean(data_biomass, axis=0))
+        self.datax_std.append(np.std(data_biomass, axis=0, ddof=1))
+
+        # Procesar los datos de sustrato
+        data_substrate = [df[col].values for col in substrate_cols]
+        data_substrate = np.array(data_substrate)
+        self.datas.append(data_substrate)
+        self.datasp.append(np.mean(data_substrate, axis=0))
+        self.datas_std.append(np.std(data_substrate, axis=0, ddof=1))
+
+        # Procesar los datos de producto
+        data_product = [df[col].values for col in product_cols]
+        data_product = np.array(data_product)
+        self.datap.append(data_product)
+        self.datapp.append(np.mean(data_product, axis=0))
+        self.datap_std.append(np.std(data_product, axis=0, ddof=1))
+
+        self.time = time
+
+    def fit_model(self, model_type='logistic'):
+        if model_type == 'logistic':
+            self.fit_biomass = self.fit_biomass_logistic
+            self.fit_substrate = self.fit_substrate_logistic
+            self.fit_product = self.fit_product_logistic
+        # Puedes agregar más modelos aquí si los necesitas.
+
+    def fit_biomass_logistic(self, time, biomass, bounds):
+        popt, _ = curve_fit(self.logistic, time, biomass, bounds=bounds, maxfev=10000)
+        self.params['biomass'] = {'xo': popt[0], 'xm': popt[1], 'um': popt[2]}
+        y_pred = self.logistic(time, *popt)
+        self.r2['biomass'] = 1 - (np.sum((biomass - y_pred) ** 2) / np.sum((biomass - np.mean(biomass)) ** 2))
+        self.rmse['biomass'] = np.sqrt(mean_squared_error(biomass, y_pred))
+        return y_pred
+
+    def fit_substrate_logistic(self, time, substrate, biomass_params, bounds):
+        popt, _ = curve_fit(lambda t, so, p, q: self.substrate(t, so, p, q, *biomass_params.values()),
+                            time, substrate, bounds=bounds)
+        self.params['substrate'] = {'so': popt[0], 'p': popt[1], 'q': popt[2]}
+        y_pred = self.substrate(time, *popt, *biomass_params.values())
+        self.r2['substrate'] = 1 - (np.sum((substrate - y_pred) ** 2) / np.sum((substrate - np.mean(substrate)) ** 2))
+        self.rmse['substrate'] = np.sqrt(mean_squared_error(substrate, y_pred))
+        return y_pred
+
+    def fit_product_logistic(self, time, product, biomass_params, bounds):
+        popt, _ = curve_fit(lambda t, po, alpha, beta: self.product(t, po, alpha, beta, *biomass_params.values()),
+                            time, product, bounds=bounds)
+        self.params['product'] = {'po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
+        y_pred = self.product(time, *popt, *biomass_params.values())
+        self.r2['product'] = 1 - (np.sum((product - y_pred) ** 2) / np.sum((product - np.mean(product)) ** 2))
+        self.rmse['product'] = np.sqrt(mean_squared_error(product, y_pred))
+        return y_pred
+
+    # Métodos de visualización de resultados
+    def generate_fine_time_grid(self, time):
+        # Generar una malla temporal más fina para curvas suaves
+        time_fine = np.linspace(time.min(), time.max(), 500)
+        return time_fine
+
+    def solve_differential_equations(self, time, initial_conditions, params):
+        # Resolver la ecuación diferencial para biomasa
+        xo, xm, um = params['biomass'].values()
+        biomass_params = [xo, xm, um]
+        time_fine = self.generate_fine_time_grid(time)
+
+        # Resolver biomasa
+        X0 = xo
+        X = odeint(self.logistic_diff, X0, time_fine, args=(biomass_params,)).flatten()
+
+        # Crear función de interpolación para X(t)
+        X_func = interp1d(time_fine, X, kind='linear', fill_value="extrapolate")
+
+        # Resolver sustrato
+        so, p, q = params['substrate'].values()
+        substrate_params = [so, p, q]
+        S0 = so
+        S = odeint(self.substrate_diff, S0, time_fine, args=(substrate_params, biomass_params, X_func)).flatten()
+
+        # Resolver producto
+        po, alpha, beta = params['product'].values()
+        product_params = [po, alpha, beta]
+        P0 = po
+        P = odeint(self.product_diff, P0, time_fine, args=(product_params, biomass_params, X_func)).flatten()
+
+        return X, S, P, time_fine
+
+    def plot_results(self, time, biomass, substrate, product,
+                     y_pred_biomass, y_pred_substrate, y_pred_product,
+                     biomass_std=None, substrate_std=None, product_std=None,
+                     experiment_name='', legend_position='best', params_position='upper right',
+                     show_legend=True, show_params=True,
+                     style='whitegrid',
+                     line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
+                     use_differential=False):
+        sns.set_style(style)  # Establecer el estilo seleccionado
+
+        if use_differential:
+            y_pred_biomass, y_pred_substrate, y_pred_product, time_to_plot = self.solve_differential_equations(
+                time, [biomass[0], substrate[0], product[0]], self.params)
+        else:
+            time_to_plot = time
+
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15))
+        fig.suptitle(f'{experiment_name}', fontsize=16)
+
+        plots = [
+            (ax1, biomass, y_pred_biomass, biomass_std, 'Biomasa', 'Modelo', self.params['biomass'],
+             self.r2['biomass'], self.rmse['biomass']),
+            (ax2, substrate, y_pred_substrate, substrate_std, 'Sustrato', 'Modelo', self.params['substrate'],
+             self.r2['substrate'], self.rmse['substrate']),
+            (ax3, product, y_pred_product, product_std, 'Producto', 'Modelo', self.params['product'],
+             self.r2['product'], self.rmse['product'])
+        ]
+
+        for idx, (ax, data, y_pred, data_std, ylabel, model_name, params, r2, rmse) in enumerate(plots):
+            if data_std is not None:
+                ax.errorbar(time, data, yerr=data_std, fmt=marker_style, color=point_color,
+                            label='Datos experimentales', capsize=5)
+            else:
+                ax.plot(time, data, marker=marker_style, linestyle='', color=point_color,
+                        label='Datos experimentales')
+            if use_differential:
+                ax.plot(time_to_plot, y_pred, linestyle=line_style, color=line_color, label=model_name)
+            else:
+                ax.plot(time, y_pred, linestyle=line_style, color=line_color, label=model_name)
+            ax.set_xlabel('Tiempo')
+            ax.set_ylabel(ylabel)
+            if show_legend:
+                ax.legend(loc=legend_position)
+            ax.set_title(f'{ylabel}')
+
+            if show_params:
+                param_text = '\n'.join([f"{k} = {v:.4f}" for k, v in params.items()])
+                text = f"{param_text}\nR² = {r2:.4f}\nRMSE = {rmse:.4f}"
+
+                # Si la posición es 'outside right', ajustar la posición del texto
+                if params_position == 'outside right':
+                    bbox_props = dict(boxstyle='round', facecolor='white', alpha=0.5)
+                    ax.annotate(text, xy=(1.05, 0.5), xycoords='axes fraction',
+                                verticalalignment='center', bbox=bbox_props)
+                else:
+                    if params_position in ['upper right', 'lower right']:
+                        text_x = 0.95
+                        ha = 'right'
+                    else:
+                        text_x = 0.05
+                        ha = 'left'
+
+                    if params_position in ['upper right', 'upper left']:
+                        text_y = 0.95
+                        va = 'top'
+                    else:
+                        text_y = 0.05
+                        va = 'bottom'
+
+                    ax.text(text_x, text_y, text, transform=ax.transAxes,
+                            verticalalignment=va, horizontalalignment=ha,
+                            bbox={'boxstyle': 'round', 'facecolor': 'white', 'alpha': 0.5})
+
+        plt.tight_layout()
+        return fig
+
+    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,
+                              experiment_name='', legend_position='best', params_position='upper right',
+                              show_legend=True, show_params=True,
+                              style='whitegrid',
+                              line_color='#0000FF', point_color='#000000', line_style='-', marker_style='o',
+                              use_differential=False):
+        sns.set_style(style)  # Establecer el estilo seleccionado
+
+        if use_differential:
+            y_pred_biomass, y_pred_substrate, y_pred_product, time_to_plot = self.solve_differential_equations(
+                time, [biomass[0], substrate[0], product[0]], self.params)
+        else:
+            time_to_plot = time
+
+        fig, ax1 = plt.subplots(figsize=(10, 7))
+        fig.suptitle(f'{experiment_name}', fontsize=16)
+
+        # Colores específicos para cada variable
+        colors = {'Biomasa': 'blue', 'Sustrato': 'green', 'Producto': 'red'}
+
+        # Plot Biomasa en ax1
+        ax1.set_xlabel('Tiempo')
+        ax1.set_ylabel('Biomasa', color=colors['Biomasa'])
+        if biomass_std is not None:
+            ax1.errorbar(time, biomass, yerr=biomass_std, fmt=marker_style, color=colors['Biomasa'],
+                         label='Biomasa (Datos)', capsize=5)
+        else:
+            ax1.plot(time, biomass, marker=marker_style, linestyle='', color=colors['Biomasa'],
+                     label='Biomasa (Datos)')
+        if use_differential:
+            ax1.plot(time_to_plot, y_pred_biomass, linestyle=line_style, color=colors['Biomasa'],
+                     label='Biomasa (Modelo)')
+        else:
+            ax1.plot(time, y_pred_biomass, linestyle=line_style, color=colors['Biomasa'],
+                     label='Biomasa (Modelo)')
+        ax1.tick_params(axis='y', labelcolor=colors['Biomasa'])
+
+        # Crear segundo eje y para Sustrato
+        ax2 = ax1.twinx()
+        ax2.set_ylabel('Sustrato', color=colors['Sustrato'])
+        if substrate_std is not None:
+            ax2.errorbar(time, substrate, yerr=substrate_std, fmt=marker_style, color=colors['Sustrato'],
+                         label='Sustrato (Datos)', capsize=5)
+        else:
+            ax2.plot(time, substrate, marker=marker_style, linestyle='', color=colors['Sustrato'],
+                     label='Sustrato (Datos)')
+        if use_differential:
+            ax2.plot(time_to_plot, y_pred_substrate, linestyle=line_style, color=colors['Sustrato'],
+                     label='Sustrato (Modelo)')
+        else:
+            ax2.plot(time, y_pred_substrate, linestyle=line_style, color=colors['Sustrato'],
+                     label='Sustrato (Modelo)')
+        ax2.tick_params(axis='y', labelcolor=colors['Sustrato'])
+
+        # Crear tercer eje y para Producto
+        ax3 = ax1.twinx()
+        # Desplazar el tercer eje para evitar superposición
+        ax3.spines["right"].set_position(("axes", 1.1))
+        ax3.set_frame_on(True)
+        ax3.patch.set_visible(False)
+        for sp in ax3.spines.values():
+            sp.set_visible(True)
+
+        ax3.set_ylabel('Producto', color=colors['Producto'])
+        if product_std is not None:
+            ax3.errorbar(time, product, yerr=product_std, fmt=marker_style, color=colors['Producto'],
+                         label='Producto (Datos)', capsize=5)
+        else:
+            ax3.plot(time, product, marker=marker_style, linestyle='', color=colors['Producto'],
+                     label='Producto (Datos)')
+        if use_differential:
+            ax3.plot(time_to_plot, y_pred_product, linestyle=line_style, color=colors['Producto'],
+                     label='Producto (Modelo)')
+        else:
+            ax3.plot(time, y_pred_product, linestyle=line_style, color=colors['Producto'],
+                     label='Producto (Modelo)')
+        ax3.tick_params(axis='y', labelcolor=colors['Producto'])
+
+        # Manejo de leyendas
+        lines_labels = [ax.get_legend_handles_labels() for ax in [ax1, ax2, ax3]]
+        lines, labels = [sum(lol, []) for lol in zip(*lines_labels)]
+        if show_legend:
+            ax1.legend(lines, labels, loc=legend_position)
+
+        # Mostrar parámetros y estadísticas en el gráfico
+        if show_params:
+            param_text_biomass = '\n'.join([f"{k} = {v:.4f}" for k, v in self.params['biomass'].items()])
+            text_biomass = f"Biomasa:\n{param_text_biomass}\nR² = {self.r2['biomass']:.4f}\nRMSE = {self.rmse['biomass']:.4f}"
+
+            param_text_substrate = '\n'.join([f"{k} = {v:.4f}" for k, v in self.params['substrate'].items()])
+            text_substrate = f"Sustrato:\n{param_text_substrate}\nR² = {self.r2['substrate']:.4f}\nRMSE = {self.rmse['substrate']:.4f}"
+
+            param_text_product = '\n'.join([f"{k} = {v:.4f}" for k, v in self.params['product'].items()])
+            text_product = f"Producto:\n{param_text_product}\nR² = {self.r2['product']:.4f}\nRMSE = {self.rmse['product']:.4f}"
+
+            total_text = f"{text_biomass}\n\n{text_substrate}\n\n{text_product}"
+
+            if params_position == 'outside right':
+                bbox_props = dict(boxstyle='round', facecolor='white', alpha=0.5)
+                ax3.annotate(total_text, xy=(1.2, 0.5), xycoords='axes fraction',
+                             verticalalignment='center', bbox=bbox_props)
+            else:
+                if params_position in ['upper right', 'lower right']:
+                    text_x = 0.95
+                    ha = 'right'
+                else:
+                    text_x = 0.05
+                    ha = 'left'
+
+                if params_position in ['upper right', 'upper left']:
+                    text_y = 0.95
+                    va = 'top'
+                else:
+                    text_y = 0.05
+                    va = 'bottom'
+
+                ax1.text(text_x, text_y, total_text, transform=ax1.transAxes,
+                         verticalalignment=va, horizontalalignment=ha,
+                         bbox={'boxstyle': 'round', 'facecolor': 'white', 'alpha': 0.5})
+
+        plt.tight_layout()
+        return fig
+
+# Función de procesamiento de datos
+def process_data(file, legend_position, params_position, model_type, experiment_names, lower_bounds, upper_bounds,
+                 mode='independent', style='whitegrid', line_color='#0000FF', point_color='#000000',
+                 line_style='-', marker_style='o', show_legend=True, show_params=True, use_differential=False):
+    # Leer todas las hojas del archivo Excel
+    xls = pd.ExcelFile(file.name)
+    sheet_names = xls.sheet_names
+
+    model = BioprocessModel()
+    model.fit_model(model_type)
+    figures = []
+
+    # Si no se proporcionan suficientes límites, usar valores predeterminados
+    default_lower_bounds = (0, 0, 0)
+    default_upper_bounds = (np.inf, np.inf, np.inf)
+
+    experiment_counter = 0  # Contador global de experimentos
+
+    for sheet_name in sheet_names:
+        df = pd.read_excel(file.name, sheet_name=sheet_name, header=[0, 1])
+
+        # Procesar datos
+        model.process_data(df)
+        time = model.time
+
+        if mode == 'independent':
+            # Modo independiente: iterar sobre cada experimento
+            num_experiments = len(df.columns.levels[0])
+            for idx in range(num_experiments):
+                col = df.columns.levels[0][idx]
+                time = df[(col, 'Tiempo')].dropna().values
+                biomass = df[(col, 'Biomasa')].dropna().values
+                substrate = df[(col, 'Sustrato')].dropna().values
+                product = df[(col, 'Producto')].dropna().values
+
+                # Si hay replicados en el experimento, calcular la desviación estándar
+                biomass_std = None
+                substrate_std = None
+                product_std = None
+                if biomass.ndim > 1:
+                    biomass_std = np.std(biomass, axis=0, ddof=1)
+                    biomass = np.mean(biomass, axis=0)
+                if substrate.ndim > 1:
+                    substrate_std = np.std(substrate, axis=0, ddof=1)
+                    substrate = np.mean(substrate, axis=0)
+                if product.ndim > 1:
+                    product_std = np.std(product, axis=0, ddof=1)
+                    product = np.mean(product, axis=0)
+
+                # Obtener límites o usar valores predeterminados
+                lower_bound = lower_bounds[experiment_counter] if experiment_counter < len(lower_bounds) else default_lower_bounds
+                upper_bound = upper_bounds[experiment_counter] if experiment_counter < len(upper_bounds) else default_upper_bounds
+                bounds = (lower_bound, upper_bound)
+
+                # Ajustar el modelo
+                y_pred_biomass = model.fit_biomass(time, biomass, bounds)
+                y_pred_substrate = model.fit_substrate(time, substrate, model.params['biomass'], bounds)
+                y_pred_product = model.fit_product(time, product, model.params['biomass'], bounds)
+
+                # Usar el nombre del experimento proporcionado o un nombre por defecto
+                experiment_name = experiment_names[experiment_counter] if experiment_counter < len(experiment_names) else f"Tratamiento {experiment_counter + 1}"
+
+                if mode == 'combinado':
+                    fig = model.plot_combined_results(time, biomass, substrate, product,
+                                                      y_pred_biomass, y_pred_substrate, y_pred_product,
+                                                      biomass_std, substrate_std, product_std,
+                                                      experiment_name, legend_position, params_position,
+                                                      show_legend, show_params,
+                                                      style,
+                                                      line_color, point_color, line_style, marker_style,
+                                                      use_differential)
+                else:
+                    fig = model.plot_results(time, biomass, substrate, product,
+                                             y_pred_biomass, y_pred_substrate, y_pred_product,
+                                             biomass_std, substrate_std, product_std,
+                                             experiment_name, legend_position, params_position,
+                                             show_legend, show_params,
+                                             style,
+                                             line_color, point_color, line_style, marker_style,
+                                             use_differential)
+                figures.append(fig)
+
+                experiment_counter += 1
+
+        elif mode == 'average':
+            # Modo promedio: usar dataxp, datasp y datapp
+            time = df[(df.columns.levels[0][0], 'Tiempo')].dropna().values
+            biomass = model.dataxp[-1]
+            substrate = model.datasp[-1]
+            product = model.datapp[-1]
+
+            # Obtener las desviaciones estándar
+            biomass_std = model.datax_std[-1]
+            substrate_std = model.datas_std[-1]
+            product_std = model.datap_std[-1]
+
+            # Obtener límites o usar valores predeterminados
+            lower_bound = lower_bounds[experiment_counter] if experiment_counter < len(lower_bounds) else default_lower_bounds
+            upper_bound = upper_bounds[experiment_counter] if experiment_counter < len(upper_bounds) else default_upper_bounds
+            bounds = (lower_bound, upper_bound)
+
+            # Ajustar el modelo
+            y_pred_biomass = model.fit_biomass(time, biomass, bounds)
+            y_pred_substrate = model.fit_substrate(time, substrate, model.params['biomass'], bounds)
+            y_pred_product = model.fit_product(time, product, model.params['biomass'], bounds)
+
+            # Usar el nombre del experimento proporcionado o un nombre por defecto
+            experiment_name = experiment_names[experiment_counter] if experiment_counter < len(experiment_names) else f"Tratamiento {experiment_counter + 1}"
+
+            if mode == 'combinado':
+                fig = model.plot_combined_results(time, biomass, substrate, product,
+                                                  y_pred_biomass, y_pred_substrate, y_pred_product,
+                                                  biomass_std, substrate_std, product_std,
+                                                  experiment_name, legend_position, params_position,
+                                                  show_legend, show_params,
+                                                  style,
+                                                  line_color, point_color, line_style, marker_style,
+                                                  use_differential)
+            else:
+                fig = model.plot_results(time, biomass, substrate, product,
+                                         y_pred_biomass, y_pred_substrate, y_pred_product,
+                                         biomass_std, substrate_std, product_std,
+                                         experiment_name, legend_position, params_position,
+                                         show_legend, show_params,
+                                         style,
+                                         line_color, point_color, line_style, marker_style,
+                                         use_differential)
+            figures.append(fig)
+
+            experiment_counter += 1
+
+        elif mode == 'combinado':
+            # Modo combinado: combinar las gráficas en una sola
+            time = df[(df.columns.levels[0][0], 'Tiempo')].dropna().values
+            biomass = model.dataxp[-1]
+            substrate = model.datasp[-1]
+            product = model.datapp[-1]
+
+            # Obtener las desviaciones estándar
+            biomass_std = model.datax_std[-1]
+            substrate_std = model.datas_std[-1]
+            product_std = model.datap_std[-1]
+
+            # Obtener límites o usar valores predeterminados
+            lower_bound = lower_bounds[experiment_counter] if experiment_counter < len(lower_bounds) else default_lower_bounds
+            upper_bound = upper_bounds[experiment_counter] if experiment_counter < len(upper_bounds) else default_upper_bounds
+            bounds = (lower_bound, upper_bound)
+
+            # Ajustar el modelo
+            y_pred_biomass = model.fit_biomass(time, biomass, bounds)
+            y_pred_substrate = model.fit_substrate(time, substrate, model.params['biomass'], bounds)
+            y_pred_product = model.fit_product(time, product, model.params['biomass'], bounds)
+
+            # Usar el nombre del experimento proporcionado o un nombre por defecto
+            experiment_name = experiment_names[experiment_counter] if experiment_counter < len(experiment_names) else f"Tratamiento {experiment_counter + 1}"
+
+            fig = model.plot_combined_results(time, biomass, substrate, product,
+                                              y_pred_biomass, y_pred_substrate, y_pred_product,
+                                              biomass_std, substrate_std, product_std,
+                                              experiment_name, legend_position, params_position,
+                                              show_legend, show_params,
+                                              style,
+                                              line_color, point_color, line_style, marker_style,
+                                              use_differential)
+            figures.append(fig)
+
+            experiment_counter += 1
+
+    return figures
+
+def create_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("# Modelos de Bioproceso: Logístico y Luedeking-Piret")
+        gr.Markdown(
+            "Sube un archivo Excel con múltiples pestañas. Cada pestaña debe contener columnas 'Tiempo', 'Biomasa', 'Sustrato' y 'Producto' para cada experimento.")
+
+        file_input = gr.File(label="Subir archivo Excel")
+
+        with gr.Row():
+            with gr.Column():
+                legend_position = gr.Radio(
+                    choices=["upper left", "upper right", "lower left", "lower right", "best"],
+                    label="Posición de la leyenda",
+                    value="best"
+                )
+                show_legend = gr.Checkbox(label="Mostrar Leyenda", value=True)
+
+            with gr.Column():
+                params_positions = ["upper left", "upper right", "lower left", "lower right", "outside right"]
+                params_position = gr.Radio(
+                    choices=params_positions,
+                    label="Posición de los parámetros",
+                    value="upper right"
+                )
+                show_params = gr.Checkbox(label="Mostrar Parámetros", value=True)
+
+        model_type = gr.Radio(["logistic"], label="Tipo de Modelo", value="logistic")
+        mode = gr.Radio(["independent", "average", "combinado"], label="Modo de Análisis", value="independent")
+
+        use_differential = gr.Checkbox(label="Usar ecuaciones diferenciales para graficar", value=False)
+
+        experiment_names = gr.Textbox(
+            label="Nombres de los experimentos (uno por línea)",
+            placeholder="Experimento 1\nExperimento 2\n...",
+            lines=5
+        )
+
+        with gr.Row():
+            with gr.Column():
+                lower_bounds = gr.Textbox(
+                    label="Lower Bounds (uno por línea, formato: xo,xm,um)",
+                    placeholder="0,0,0\n0,0,0\n...",
+                    lines=5
+                )
+
+            with gr.Column():
+                upper_bounds = gr.Textbox(
+                    label="Upper Bounds (uno por línea, formato: xo,xm,um)",
+                    placeholder="inf,inf,inf\ninf,inf,inf\n...",
+                    lines=5
+                )
+
+        # Añadir un desplegable para seleccionar el estilo del gráfico
+        styles = ['white', 'dark', 'whitegrid', 'darkgrid', 'ticks']
+        style_dropdown = gr.Dropdown(choices=styles, label="Selecciona el estilo de gráfico", value='whitegrid')
+
+        # Añadir color pickers para líneas y puntos
+        line_color_picker = gr.ColorPicker(label="Color de la línea", value='#0000FF')
+        point_color_picker = gr.ColorPicker(label="Color de los puntos", value='#000000')
+
+        # Añadir listas desplegables para tipo de línea y tipo de punto
+        line_style_options = ['-', '--', '-.', ':']
+        line_style_dropdown = gr.Dropdown(choices=line_style_options, label="Estilo de línea", value='-')
+
+        marker_style_options = ['o', 's', '^', 'v', 'D', 'x', '+', '*']
+        marker_style_dropdown = gr.Dropdown(choices=marker_style_options, label="Estilo de punto", value='o')
+
+        simulate_btn = gr.Button("Simular")
+
+        # Definir un componente gr.Gallery para las salidas
+        output_gallery = gr.Gallery(label="Resultados", columns=2, height='auto')
+
+        def process_and_plot(file, legend_position, params_position, model_type, mode, experiment_names,
+                             lower_bounds, upper_bounds, style,
+                             line_color, point_color, line_style, marker_style,
+                             show_legend, show_params, use_differential):
+            # Dividir los nombres de experimentos y límites en listas
+            experiment_names_list = experiment_names.strip().split('\n') if experiment_names.strip() else []
+            lower_bounds_list = [tuple(map(float, lb.split(','))) for lb in
+                                 lower_bounds.strip().split('\n')] if lower_bounds.strip() else []
+            upper_bounds_list = [tuple(map(float, ub.split(','))) for ub in
+                                 upper_bounds.strip().split('\n')] if upper_bounds.strip() else []
+
+            # Procesar los datos y generar gráficos
+            figures = process_data(file, legend_position, params_position, model_type, experiment_names_list,
+                                   lower_bounds_list, upper_bounds_list, mode, style,
+                                   line_color, point_color, line_style, marker_style,
+                                   show_legend, show_params, use_differential)
+
+            # Convertir las figuras a imágenes y devolverlas como lista
+            image_list = []
+            for fig in figures:
+                buf = io.BytesIO()
+                fig.savefig(buf, format='png')
+                buf.seek(0)
+                image = Image.open(buf)
+                image_list.append(image)
+
+            return image_list
+
+        simulate_btn.click(
+            fn=process_and_plot,
+            inputs=[file_input,
+                    legend_position,
+                    params_position,
+                    model_type,
+                    mode,
+                    experiment_names,
+                    lower_bounds,
+                    upper_bounds,
+                    style_dropdown,
+                    line_color_picker,
+                    point_color_picker,
+                    line_style_dropdown,
+                    marker_style_dropdown,
+                    show_legend,
+                    show_params,
+                    use_differential],
+            outputs=output_gallery
+        )
+
+    return demo
 
-from bioprocess_model import BioprocessModel
-from decorators import gpu_decorator  # Asegúrate de que la ruta es correcta
-
-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')
-        # Evaluar la cadena de límites
-        bounds = eval(f"[{bounds_str}]")
-        if len(bounds) != num_params:
-            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 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
-
-@gpu_decorator(duration=300)
-def generate_analysis(prompt, max_length=1024, device=None):
-    # Implementación existente para generar análisis usando Hugging Face o similar
-    # Por ejemplo, podrías usar un modelo de lenguaje para generar texto
-    # Aquí se deja como placeholder
-    analysis = "Análisis generado por el modelo de lenguaje."
-    return analysis
-
-@gpu_decorator(duration=600)  # Ajusta la duración según tus necesidades
-def process_and_plot(
-    file,
-    biomass_eq1, biomass_eq2, biomass_eq3,
-    biomass_param1, biomass_param2, biomass_param3,
-    biomass_bound1, biomass_bound2, biomass_bound3,
-    substrate_eq1, substrate_eq2, substrate_eq3,
-    substrate_param1, substrate_param2, substrate_param3,
-    substrate_bound1, substrate_bound2, substrate_bound3,
-    product_eq1, product_eq2, product_eq3,
-    product_param1, product_param2, product_param3,
-    product_bound1, product_bound2, product_bound3,
-    legend_position,
-    show_legend,
-    show_params,
-    biomass_eq_count,
-    substrate_eq_count,
-    product_eq_count,
-    device=None
-):
-    # Leer el archivo Excel
-    df = pd.read_excel(file.name)
-    
-    # Verificar que las columnas necesarias estén presentes
-    expected_columns = ['Tiempo', 'Biomasa', 'Sustrato', 'Producto']
-    for col in expected_columns:
-        if col not in df.columns:
-            raise KeyError(f"La columna esperada '{col}' no se encuentra en el archivo Excel.")
-
-    # Asignar los datos desde las columnas
-    time = df['Tiempo'].values
-    biomass_data = df['Biomasa'].values
-    substrate_data = df['Sustrato'].values
-    product_data = df['Producto'].values
-
-    # Convierte los contadores a enteros
-    biomass_eq_count = int(biomass_eq_count)
-    substrate_eq_count = int(substrate_eq_count)
-    product_eq_count = int(product_eq_count)
-
-    # Recolecta las ecuaciones, parámetros y límites según los contadores
-    biomass_eqs = [biomass_eq1, biomass_eq2, biomass_eq3][:biomass_eq_count]
-    biomass_params = [biomass_param1, biomass_param2, biomass_param3][:biomass_eq_count]
-    biomass_bounds = [biomass_bound1, biomass_bound2, biomass_bound3][:biomass_eq_count]
-
-    substrate_eqs = [substrate_eq1, substrate_eq2, substrate_eq3][:substrate_eq_count]
-    substrate_params = [substrate_param1, substrate_param2, substrate_param3][:substrate_eq_count]
-    substrate_bounds = [substrate_bound1, substrate_bound2, substrate_bound3][:substrate_eq_count]
-
-    product_eqs = [product_eq1, product_eq2, product_eq3][:product_eq_count]
-    product_params = [product_param1, product_param2, product_param3][:product_eq_count]
-    product_bounds = [product_bound1, product_bound2, product_bound3][:product_eq_count]
-
-    biomass_results = []
-    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]
-
-        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))
-
-        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}")
-
-    # Ajusta los modelos de Sustrato
-    for i in range(len(substrate_eqs)):
-        equation = substrate_eqs[i]
-        params_str = substrate_params[i]
-        bounds_str = substrate_bounds[i]
-
-        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 = [param.strip() for param in params_str.split(',')]
-        lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
-
-        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)):
-        equation = product_eqs[i]
-        params_str = product_params[i]
-        bounds_str = product_bounds[i]
-
-        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 = [param.strip() for param in params_str.split(',')]
-        lower_bounds, upper_bounds = parse_bounds(bounds_str, len(params))
-
-        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))
-
-    # Gráfica de Biomasa
-    axs[0].plot(time, biomass_data, 'o', label='Datos de Biomasa')
-    for i, result in enumerate(biomass_results):
-        axs[0].plot(time, result['y_pred'], '-', label=f'Modelo de Biomasa {i+1}')
-    axs[0].set_xlabel('Tiempo')
-    axs[0].set_ylabel('Biomasa')
-    if show_legend:
-        axs[0].legend(loc=legend_position)
-
-    # Gráfica de Sustrato
-    axs[1].plot(time, substrate_data, 'o', label='Datos de Sustrato')
-    for i, result in enumerate(substrate_results):
-        axs[1].plot(time, result['y_pred'], '-', label=f'Modelo de Sustrato {i+1}')
-    axs[1].set_xlabel('Tiempo')
-    axs[1].set_ylabel('Sustrato')
-    if show_legend:
-        axs[1].legend(loc=legend_position)
-
-    # Gráfica de Producto
-    axs[2].plot(time, product_data, 'o', label='Datos de Producto')
-    for i, result in enumerate(product_results):
-        axs[2].plot(time, result['y_pred'], '-', label=f'Modelo de Producto {i+1}')
-    axs[2].set_xlabel('Tiempo')
-    axs[2].set_ylabel('Producto')
-    if show_legend:
-        axs[2].legend(loc=legend_position)
-
-    plt.tight_layout()
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png')
-    buf.seek(0)
-    image = Image.open(buf)
-
-    prompt = f"""
-Eres un experto en modelado de bioprocesos.
-Analiza los siguientes resultados experimentales y proporciona un veredicto sobre la calidad de los modelos, sugiriendo mejoras si es necesario.
-Biomasa:
-{biomass_results}
-Sustrato:
-{substrate_results}
-Producto:
-{product_results}
-"""
-    analysis = generate_analysis(prompt, device=device)
-
-    return image, analysis
+# Crear y lanzar la interfaz
+demo = create_interface()
+demo.launch(share=True)